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_TLSGD_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
934 ppc64_elf_unhandled_reloc
),
936 HOW (R_PPC64_GOT_TLSLD_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
937 ppc64_elf_unhandled_reloc
),
939 HOW (R_PPC64_GOT_TPREL_PCREL34
, 4, 34, 0x3ffff0000ffffULL
, 0, TRUE
, signed,
940 ppc64_elf_unhandled_reloc
),
942 HOW (R_PPC64_GOT_DTPREL_PCREL34
, 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
, bfd_reloc_code_real_type code
)
1004 enum elf_ppc64_reloc_type r
= R_PPC64_NONE
;
1006 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1007 /* Initialize howto table if needed. */
1013 /* xgettext:c-format */
1014 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd
,
1016 bfd_set_error (bfd_error_bad_value
);
1019 case BFD_RELOC_NONE
: r
= R_PPC64_NONE
;
1021 case BFD_RELOC_32
: r
= R_PPC64_ADDR32
;
1023 case BFD_RELOC_PPC_BA26
: r
= R_PPC64_ADDR24
;
1025 case BFD_RELOC_16
: r
= R_PPC64_ADDR16
;
1027 case BFD_RELOC_LO16
: r
= R_PPC64_ADDR16_LO
;
1029 case BFD_RELOC_HI16
: r
= R_PPC64_ADDR16_HI
;
1031 case BFD_RELOC_PPC64_ADDR16_HIGH
: r
= R_PPC64_ADDR16_HIGH
;
1033 case BFD_RELOC_HI16_S
: r
= R_PPC64_ADDR16_HA
;
1035 case BFD_RELOC_PPC64_ADDR16_HIGHA
: r
= R_PPC64_ADDR16_HIGHA
;
1037 case BFD_RELOC_PPC_BA16
: r
= R_PPC64_ADDR14
;
1039 case BFD_RELOC_PPC_BA16_BRTAKEN
: r
= R_PPC64_ADDR14_BRTAKEN
;
1041 case BFD_RELOC_PPC_BA16_BRNTAKEN
: r
= R_PPC64_ADDR14_BRNTAKEN
;
1043 case BFD_RELOC_PPC_B26
: r
= R_PPC64_REL24
;
1045 case BFD_RELOC_PPC64_REL24_NOTOC
: r
= R_PPC64_REL24_NOTOC
;
1047 case BFD_RELOC_PPC_B16
: r
= R_PPC64_REL14
;
1049 case BFD_RELOC_PPC_B16_BRTAKEN
: r
= R_PPC64_REL14_BRTAKEN
;
1051 case BFD_RELOC_PPC_B16_BRNTAKEN
: r
= R_PPC64_REL14_BRNTAKEN
;
1053 case BFD_RELOC_16_GOTOFF
: r
= R_PPC64_GOT16
;
1055 case BFD_RELOC_LO16_GOTOFF
: r
= R_PPC64_GOT16_LO
;
1057 case BFD_RELOC_HI16_GOTOFF
: r
= R_PPC64_GOT16_HI
;
1059 case BFD_RELOC_HI16_S_GOTOFF
: r
= R_PPC64_GOT16_HA
;
1061 case BFD_RELOC_PPC_COPY
: r
= R_PPC64_COPY
;
1063 case BFD_RELOC_PPC_GLOB_DAT
: r
= R_PPC64_GLOB_DAT
;
1065 case BFD_RELOC_32_PCREL
: r
= R_PPC64_REL32
;
1067 case BFD_RELOC_32_PLTOFF
: r
= R_PPC64_PLT32
;
1069 case BFD_RELOC_32_PLT_PCREL
: r
= R_PPC64_PLTREL32
;
1071 case BFD_RELOC_LO16_PLTOFF
: r
= R_PPC64_PLT16_LO
;
1073 case BFD_RELOC_HI16_PLTOFF
: r
= R_PPC64_PLT16_HI
;
1075 case BFD_RELOC_HI16_S_PLTOFF
: r
= R_PPC64_PLT16_HA
;
1077 case BFD_RELOC_16_BASEREL
: r
= R_PPC64_SECTOFF
;
1079 case BFD_RELOC_LO16_BASEREL
: r
= R_PPC64_SECTOFF_LO
;
1081 case BFD_RELOC_HI16_BASEREL
: r
= R_PPC64_SECTOFF_HI
;
1083 case BFD_RELOC_HI16_S_BASEREL
: r
= R_PPC64_SECTOFF_HA
;
1085 case BFD_RELOC_CTOR
: r
= R_PPC64_ADDR64
;
1087 case BFD_RELOC_64
: r
= R_PPC64_ADDR64
;
1089 case BFD_RELOC_PPC64_HIGHER
: r
= R_PPC64_ADDR16_HIGHER
;
1091 case BFD_RELOC_PPC64_HIGHER_S
: r
= R_PPC64_ADDR16_HIGHERA
;
1093 case BFD_RELOC_PPC64_HIGHEST
: r
= R_PPC64_ADDR16_HIGHEST
;
1095 case BFD_RELOC_PPC64_HIGHEST_S
: r
= R_PPC64_ADDR16_HIGHESTA
;
1097 case BFD_RELOC_64_PCREL
: r
= R_PPC64_REL64
;
1099 case BFD_RELOC_64_PLTOFF
: r
= R_PPC64_PLT64
;
1101 case BFD_RELOC_64_PLT_PCREL
: r
= R_PPC64_PLTREL64
;
1103 case BFD_RELOC_PPC_TOC16
: r
= R_PPC64_TOC16
;
1105 case BFD_RELOC_PPC64_TOC16_LO
: r
= R_PPC64_TOC16_LO
;
1107 case BFD_RELOC_PPC64_TOC16_HI
: r
= R_PPC64_TOC16_HI
;
1109 case BFD_RELOC_PPC64_TOC16_HA
: r
= R_PPC64_TOC16_HA
;
1111 case BFD_RELOC_PPC64_TOC
: r
= R_PPC64_TOC
;
1113 case BFD_RELOC_PPC64_PLTGOT16
: r
= R_PPC64_PLTGOT16
;
1115 case BFD_RELOC_PPC64_PLTGOT16_LO
: r
= R_PPC64_PLTGOT16_LO
;
1117 case BFD_RELOC_PPC64_PLTGOT16_HI
: r
= R_PPC64_PLTGOT16_HI
;
1119 case BFD_RELOC_PPC64_PLTGOT16_HA
: r
= R_PPC64_PLTGOT16_HA
;
1121 case BFD_RELOC_PPC64_ADDR16_DS
: r
= R_PPC64_ADDR16_DS
;
1123 case BFD_RELOC_PPC64_ADDR16_LO_DS
: r
= R_PPC64_ADDR16_LO_DS
;
1125 case BFD_RELOC_PPC64_GOT16_DS
: r
= R_PPC64_GOT16_DS
;
1127 case BFD_RELOC_PPC64_GOT16_LO_DS
: r
= R_PPC64_GOT16_LO_DS
;
1129 case BFD_RELOC_PPC64_PLT16_LO_DS
: r
= R_PPC64_PLT16_LO_DS
;
1131 case BFD_RELOC_PPC64_SECTOFF_DS
: r
= R_PPC64_SECTOFF_DS
;
1133 case BFD_RELOC_PPC64_SECTOFF_LO_DS
: r
= R_PPC64_SECTOFF_LO_DS
;
1135 case BFD_RELOC_PPC64_TOC16_DS
: r
= R_PPC64_TOC16_DS
;
1137 case BFD_RELOC_PPC64_TOC16_LO_DS
: r
= R_PPC64_TOC16_LO_DS
;
1139 case BFD_RELOC_PPC64_PLTGOT16_DS
: r
= R_PPC64_PLTGOT16_DS
;
1141 case BFD_RELOC_PPC64_PLTGOT16_LO_DS
: r
= R_PPC64_PLTGOT16_LO_DS
;
1143 case BFD_RELOC_PPC64_TLS_PCREL
:
1144 case BFD_RELOC_PPC_TLS
: r
= R_PPC64_TLS
;
1146 case BFD_RELOC_PPC_TLSGD
: r
= R_PPC64_TLSGD
;
1148 case BFD_RELOC_PPC_TLSLD
: r
= R_PPC64_TLSLD
;
1150 case BFD_RELOC_PPC_DTPMOD
: r
= R_PPC64_DTPMOD64
;
1152 case BFD_RELOC_PPC_TPREL16
: r
= R_PPC64_TPREL16
;
1154 case BFD_RELOC_PPC_TPREL16_LO
: r
= R_PPC64_TPREL16_LO
;
1156 case BFD_RELOC_PPC_TPREL16_HI
: r
= R_PPC64_TPREL16_HI
;
1158 case BFD_RELOC_PPC64_TPREL16_HIGH
: r
= R_PPC64_TPREL16_HIGH
;
1160 case BFD_RELOC_PPC_TPREL16_HA
: r
= R_PPC64_TPREL16_HA
;
1162 case BFD_RELOC_PPC64_TPREL16_HIGHA
: r
= R_PPC64_TPREL16_HIGHA
;
1164 case BFD_RELOC_PPC_TPREL
: r
= R_PPC64_TPREL64
;
1166 case BFD_RELOC_PPC_DTPREL16
: r
= R_PPC64_DTPREL16
;
1168 case BFD_RELOC_PPC_DTPREL16_LO
: r
= R_PPC64_DTPREL16_LO
;
1170 case BFD_RELOC_PPC_DTPREL16_HI
: r
= R_PPC64_DTPREL16_HI
;
1172 case BFD_RELOC_PPC64_DTPREL16_HIGH
: r
= R_PPC64_DTPREL16_HIGH
;
1174 case BFD_RELOC_PPC_DTPREL16_HA
: r
= R_PPC64_DTPREL16_HA
;
1176 case BFD_RELOC_PPC64_DTPREL16_HIGHA
: r
= R_PPC64_DTPREL16_HIGHA
;
1178 case BFD_RELOC_PPC_DTPREL
: r
= R_PPC64_DTPREL64
;
1180 case BFD_RELOC_PPC_GOT_TLSGD16
: r
= R_PPC64_GOT_TLSGD16
;
1182 case BFD_RELOC_PPC_GOT_TLSGD16_LO
: r
= R_PPC64_GOT_TLSGD16_LO
;
1184 case BFD_RELOC_PPC_GOT_TLSGD16_HI
: r
= R_PPC64_GOT_TLSGD16_HI
;
1186 case BFD_RELOC_PPC_GOT_TLSGD16_HA
: r
= R_PPC64_GOT_TLSGD16_HA
;
1188 case BFD_RELOC_PPC_GOT_TLSLD16
: r
= R_PPC64_GOT_TLSLD16
;
1190 case BFD_RELOC_PPC_GOT_TLSLD16_LO
: r
= R_PPC64_GOT_TLSLD16_LO
;
1192 case BFD_RELOC_PPC_GOT_TLSLD16_HI
: r
= R_PPC64_GOT_TLSLD16_HI
;
1194 case BFD_RELOC_PPC_GOT_TLSLD16_HA
: r
= R_PPC64_GOT_TLSLD16_HA
;
1196 case BFD_RELOC_PPC_GOT_TPREL16
: r
= R_PPC64_GOT_TPREL16_DS
;
1198 case BFD_RELOC_PPC_GOT_TPREL16_LO
: r
= R_PPC64_GOT_TPREL16_LO_DS
;
1200 case BFD_RELOC_PPC_GOT_TPREL16_HI
: r
= R_PPC64_GOT_TPREL16_HI
;
1202 case BFD_RELOC_PPC_GOT_TPREL16_HA
: r
= R_PPC64_GOT_TPREL16_HA
;
1204 case BFD_RELOC_PPC_GOT_DTPREL16
: r
= R_PPC64_GOT_DTPREL16_DS
;
1206 case BFD_RELOC_PPC_GOT_DTPREL16_LO
: r
= R_PPC64_GOT_DTPREL16_LO_DS
;
1208 case BFD_RELOC_PPC_GOT_DTPREL16_HI
: r
= R_PPC64_GOT_DTPREL16_HI
;
1210 case BFD_RELOC_PPC_GOT_DTPREL16_HA
: r
= R_PPC64_GOT_DTPREL16_HA
;
1212 case BFD_RELOC_PPC64_TPREL16_DS
: r
= R_PPC64_TPREL16_DS
;
1214 case BFD_RELOC_PPC64_TPREL16_LO_DS
: r
= R_PPC64_TPREL16_LO_DS
;
1216 case BFD_RELOC_PPC64_TPREL16_HIGHER
: r
= R_PPC64_TPREL16_HIGHER
;
1218 case BFD_RELOC_PPC64_TPREL16_HIGHERA
: r
= R_PPC64_TPREL16_HIGHERA
;
1220 case BFD_RELOC_PPC64_TPREL16_HIGHEST
: r
= R_PPC64_TPREL16_HIGHEST
;
1222 case BFD_RELOC_PPC64_TPREL16_HIGHESTA
: r
= R_PPC64_TPREL16_HIGHESTA
;
1224 case BFD_RELOC_PPC64_DTPREL16_DS
: r
= R_PPC64_DTPREL16_DS
;
1226 case BFD_RELOC_PPC64_DTPREL16_LO_DS
: r
= R_PPC64_DTPREL16_LO_DS
;
1228 case BFD_RELOC_PPC64_DTPREL16_HIGHER
: r
= R_PPC64_DTPREL16_HIGHER
;
1230 case BFD_RELOC_PPC64_DTPREL16_HIGHERA
: r
= R_PPC64_DTPREL16_HIGHERA
;
1232 case BFD_RELOC_PPC64_DTPREL16_HIGHEST
: r
= R_PPC64_DTPREL16_HIGHEST
;
1234 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA
: r
= R_PPC64_DTPREL16_HIGHESTA
;
1236 case BFD_RELOC_16_PCREL
: r
= R_PPC64_REL16
;
1238 case BFD_RELOC_LO16_PCREL
: r
= R_PPC64_REL16_LO
;
1240 case BFD_RELOC_HI16_PCREL
: r
= R_PPC64_REL16_HI
;
1242 case BFD_RELOC_HI16_S_PCREL
: r
= R_PPC64_REL16_HA
;
1244 case BFD_RELOC_PPC64_REL16_HIGH
: r
= R_PPC64_REL16_HIGH
;
1246 case BFD_RELOC_PPC64_REL16_HIGHA
: r
= R_PPC64_REL16_HIGHA
;
1248 case BFD_RELOC_PPC64_REL16_HIGHER
: r
= R_PPC64_REL16_HIGHER
;
1250 case BFD_RELOC_PPC64_REL16_HIGHERA
: r
= R_PPC64_REL16_HIGHERA
;
1252 case BFD_RELOC_PPC64_REL16_HIGHEST
: r
= R_PPC64_REL16_HIGHEST
;
1254 case BFD_RELOC_PPC64_REL16_HIGHESTA
: r
= R_PPC64_REL16_HIGHESTA
;
1256 case BFD_RELOC_PPC_16DX_HA
: r
= R_PPC64_16DX_HA
;
1258 case BFD_RELOC_PPC_REL16DX_HA
: r
= R_PPC64_REL16DX_HA
;
1260 case BFD_RELOC_PPC64_ENTRY
: r
= R_PPC64_ENTRY
;
1262 case BFD_RELOC_PPC64_ADDR64_LOCAL
: r
= R_PPC64_ADDR64_LOCAL
;
1264 case BFD_RELOC_PPC64_D34
: r
= R_PPC64_D34
;
1266 case BFD_RELOC_PPC64_D34_LO
: r
= R_PPC64_D34_LO
;
1268 case BFD_RELOC_PPC64_D34_HI30
: r
= R_PPC64_D34_HI30
;
1270 case BFD_RELOC_PPC64_D34_HA30
: r
= R_PPC64_D34_HA30
;
1272 case BFD_RELOC_PPC64_PCREL34
: r
= R_PPC64_PCREL34
;
1274 case BFD_RELOC_PPC64_GOT_PCREL34
: r
= R_PPC64_GOT_PCREL34
;
1276 case BFD_RELOC_PPC64_PLT_PCREL34
: r
= R_PPC64_PLT_PCREL34
;
1278 case BFD_RELOC_PPC64_TPREL34
: r
= R_PPC64_TPREL34
;
1280 case BFD_RELOC_PPC64_DTPREL34
: r
= R_PPC64_DTPREL34
;
1282 case BFD_RELOC_PPC64_GOT_TLSGD_PCREL34
: r
= R_PPC64_GOT_TLSGD_PCREL34
;
1284 case BFD_RELOC_PPC64_GOT_TLSLD_PCREL34
: r
= R_PPC64_GOT_TLSLD_PCREL34
;
1286 case BFD_RELOC_PPC64_GOT_TPREL_PCREL34
: r
= R_PPC64_GOT_TPREL_PCREL34
;
1288 case BFD_RELOC_PPC64_GOT_DTPREL_PCREL34
: r
= R_PPC64_GOT_DTPREL_PCREL34
;
1290 case BFD_RELOC_PPC64_ADDR16_HIGHER34
: r
= R_PPC64_ADDR16_HIGHER34
;
1292 case BFD_RELOC_PPC64_ADDR16_HIGHERA34
: r
= R_PPC64_ADDR16_HIGHERA34
;
1294 case BFD_RELOC_PPC64_ADDR16_HIGHEST34
: r
= R_PPC64_ADDR16_HIGHEST34
;
1296 case BFD_RELOC_PPC64_ADDR16_HIGHESTA34
: r
= R_PPC64_ADDR16_HIGHESTA34
;
1298 case BFD_RELOC_PPC64_REL16_HIGHER34
: r
= R_PPC64_REL16_HIGHER34
;
1300 case BFD_RELOC_PPC64_REL16_HIGHERA34
: r
= R_PPC64_REL16_HIGHERA34
;
1302 case BFD_RELOC_PPC64_REL16_HIGHEST34
: r
= R_PPC64_REL16_HIGHEST34
;
1304 case BFD_RELOC_PPC64_REL16_HIGHESTA34
: r
= R_PPC64_REL16_HIGHESTA34
;
1306 case BFD_RELOC_PPC64_D28
: r
= R_PPC64_D28
;
1308 case BFD_RELOC_PPC64_PCREL28
: r
= R_PPC64_PCREL28
;
1310 case BFD_RELOC_VTABLE_INHERIT
: r
= R_PPC64_GNU_VTINHERIT
;
1312 case BFD_RELOC_VTABLE_ENTRY
: r
= R_PPC64_GNU_VTENTRY
;
1316 return ppc64_elf_howto_table
[r
];
1319 static reloc_howto_type
*
1320 ppc64_elf_reloc_name_lookup (bfd
*abfd
, const char *r_name
)
1323 static char *compat_map
[][2] = {
1324 { "R_PPC64_GOT_TLSGD34", "R_PPC64_GOT_TLSGD_PCREL34" },
1325 { "R_PPC64_GOT_TLSLD34", "R_PPC64_GOT_TLSLD_PCREL34" },
1326 { "R_PPC64_GOT_TPREL34", "R_PPC64_GOT_TPREL_PCREL34" },
1327 { "R_PPC64_GOT_DTPREL34", "R_PPC64_GOT_DTPREL_PCREL34" }
1330 for (i
= 0; i
< ARRAY_SIZE (ppc64_elf_howto_raw
); i
++)
1331 if (ppc64_elf_howto_raw
[i
].name
!= NULL
1332 && strcasecmp (ppc64_elf_howto_raw
[i
].name
, r_name
) == 0)
1333 return &ppc64_elf_howto_raw
[i
];
1335 /* Handle old names of relocations in case they were used by
1337 FIXME: Remove this soon. Mapping the reloc names is very likely
1338 completely unnecessary. */
1339 for (i
= 0; i
< ARRAY_SIZE (compat_map
); i
++)
1340 if (strcasecmp (compat_map
[i
][0], r_name
) == 0)
1342 _bfd_error_handler (_("warning: %s should be used rather than %s"),
1343 compat_map
[i
][1], compat_map
[i
][0]);
1344 return ppc64_elf_reloc_name_lookup (abfd
, compat_map
[i
][1]);
1350 /* Set the howto pointer for a PowerPC ELF reloc. */
1353 ppc64_elf_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1354 Elf_Internal_Rela
*dst
)
1358 /* Initialize howto table if needed. */
1359 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
1362 type
= ELF64_R_TYPE (dst
->r_info
);
1363 if (type
>= ARRAY_SIZE (ppc64_elf_howto_table
))
1365 /* xgettext:c-format */
1366 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1368 bfd_set_error (bfd_error_bad_value
);
1371 cache_ptr
->howto
= ppc64_elf_howto_table
[type
];
1372 if (cache_ptr
->howto
== NULL
|| cache_ptr
->howto
->name
== NULL
)
1374 /* xgettext:c-format */
1375 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1377 bfd_set_error (bfd_error_bad_value
);
1384 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
1386 static bfd_reloc_status_type
1387 ppc64_elf_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1388 void *data
, asection
*input_section
,
1389 bfd
*output_bfd
, char **error_message
)
1391 enum elf_ppc64_reloc_type r_type
;
1393 bfd_size_type octets
;
1396 /* If this is a relocatable link (output_bfd test tells us), just
1397 call the generic function. Any adjustment will be done at final
1399 if (output_bfd
!= NULL
)
1400 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1401 input_section
, output_bfd
, error_message
);
1403 /* Adjust the addend for sign extension of the low 16 (or 34) bits.
1404 We won't actually be using the low bits, so trashing them
1406 r_type
= reloc_entry
->howto
->type
;
1407 if (r_type
== R_PPC64_ADDR16_HIGHERA34
1408 || r_type
== R_PPC64_ADDR16_HIGHESTA34
1409 || r_type
== R_PPC64_REL16_HIGHERA34
1410 || r_type
== R_PPC64_REL16_HIGHESTA34
)
1411 reloc_entry
->addend
+= 1ULL << 33;
1413 reloc_entry
->addend
+= 1U << 15;
1414 if (r_type
!= R_PPC64_REL16DX_HA
)
1415 return bfd_reloc_continue
;
1418 if (!bfd_is_com_section (symbol
->section
))
1419 value
= symbol
->value
;
1420 value
+= (reloc_entry
->addend
1421 + symbol
->section
->output_offset
1422 + symbol
->section
->output_section
->vma
);
1423 value
-= (reloc_entry
->address
1424 + input_section
->output_offset
1425 + input_section
->output_section
->vma
);
1426 value
= (bfd_signed_vma
) value
>> 16;
1428 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1429 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1431 insn
|= (value
& 0xffc1) | ((value
& 0x3e) << 15);
1432 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1433 if (value
+ 0x8000 > 0xffff)
1434 return bfd_reloc_overflow
;
1435 return bfd_reloc_ok
;
1438 static bfd_reloc_status_type
1439 ppc64_elf_branch_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1440 void *data
, asection
*input_section
,
1441 bfd
*output_bfd
, char **error_message
)
1443 if (output_bfd
!= NULL
)
1444 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1445 input_section
, output_bfd
, error_message
);
1447 if (strcmp (symbol
->section
->name
, ".opd") == 0
1448 && (symbol
->section
->owner
->flags
& DYNAMIC
) == 0)
1450 bfd_vma dest
= opd_entry_value (symbol
->section
,
1451 symbol
->value
+ reloc_entry
->addend
,
1453 if (dest
!= (bfd_vma
) -1)
1454 reloc_entry
->addend
= dest
- (symbol
->value
1455 + symbol
->section
->output_section
->vma
1456 + symbol
->section
->output_offset
);
1460 elf_symbol_type
*elfsym
= (elf_symbol_type
*) symbol
;
1462 if (symbol
->section
->owner
!= abfd
1463 && symbol
->section
->owner
!= NULL
1464 && abiversion (symbol
->section
->owner
) >= 2)
1468 for (i
= 0; i
< symbol
->section
->owner
->symcount
; ++i
)
1470 asymbol
*symdef
= symbol
->section
->owner
->outsymbols
[i
];
1472 if (strcmp (symdef
->name
, symbol
->name
) == 0)
1474 elfsym
= (elf_symbol_type
*) symdef
;
1480 += PPC64_LOCAL_ENTRY_OFFSET (elfsym
->internal_elf_sym
.st_other
);
1482 return bfd_reloc_continue
;
1485 static bfd_reloc_status_type
1486 ppc64_elf_brtaken_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1487 void *data
, asection
*input_section
,
1488 bfd
*output_bfd
, char **error_message
)
1491 enum elf_ppc64_reloc_type r_type
;
1492 bfd_size_type octets
;
1493 /* Assume 'at' branch hints. */
1494 bfd_boolean is_isa_v2
= TRUE
;
1496 /* If this is a relocatable link (output_bfd test tells us), just
1497 call the generic function. Any adjustment will be done at final
1499 if (output_bfd
!= NULL
)
1500 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1501 input_section
, output_bfd
, error_message
);
1503 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1504 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ octets
);
1505 insn
&= ~(0x01 << 21);
1506 r_type
= reloc_entry
->howto
->type
;
1507 if (r_type
== R_PPC64_ADDR14_BRTAKEN
1508 || r_type
== R_PPC64_REL14_BRTAKEN
)
1509 insn
|= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1513 /* Set 'a' bit. This is 0b00010 in BO field for branch
1514 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1515 for branch on CTR insns (BO == 1a00t or 1a01t). */
1516 if ((insn
& (0x14 << 21)) == (0x04 << 21))
1518 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
1528 if (!bfd_is_com_section (symbol
->section
))
1529 target
= symbol
->value
;
1530 target
+= symbol
->section
->output_section
->vma
;
1531 target
+= symbol
->section
->output_offset
;
1532 target
+= reloc_entry
->addend
;
1534 from
= (reloc_entry
->address
1535 + input_section
->output_offset
1536 + input_section
->output_section
->vma
);
1538 /* Invert 'y' bit if not the default. */
1539 if ((bfd_signed_vma
) (target
- from
) < 0)
1542 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ octets
);
1544 return ppc64_elf_branch_reloc (abfd
, reloc_entry
, symbol
, data
,
1545 input_section
, output_bfd
, error_message
);
1548 static bfd_reloc_status_type
1549 ppc64_elf_sectoff_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1550 void *data
, asection
*input_section
,
1551 bfd
*output_bfd
, char **error_message
)
1553 /* If this is a relocatable link (output_bfd test tells us), just
1554 call the generic function. Any adjustment will be done at final
1556 if (output_bfd
!= NULL
)
1557 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1558 input_section
, output_bfd
, error_message
);
1560 /* Subtract the symbol section base address. */
1561 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1562 return bfd_reloc_continue
;
1565 static bfd_reloc_status_type
1566 ppc64_elf_sectoff_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1567 void *data
, asection
*input_section
,
1568 bfd
*output_bfd
, char **error_message
)
1570 /* If this is a relocatable link (output_bfd test tells us), just
1571 call the generic function. Any adjustment will be done at final
1573 if (output_bfd
!= NULL
)
1574 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1575 input_section
, output_bfd
, error_message
);
1577 /* Subtract the symbol section base address. */
1578 reloc_entry
->addend
-= symbol
->section
->output_section
->vma
;
1580 /* Adjust the addend for sign extension of the low 16 bits. */
1581 reloc_entry
->addend
+= 0x8000;
1582 return bfd_reloc_continue
;
1585 static bfd_reloc_status_type
1586 ppc64_elf_toc_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1587 void *data
, asection
*input_section
,
1588 bfd
*output_bfd
, char **error_message
)
1592 /* If this is a relocatable link (output_bfd test tells us), just
1593 call the generic function. Any adjustment will be done at final
1595 if (output_bfd
!= NULL
)
1596 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1597 input_section
, output_bfd
, error_message
);
1599 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1601 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1603 /* Subtract the TOC base address. */
1604 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1605 return bfd_reloc_continue
;
1608 static bfd_reloc_status_type
1609 ppc64_elf_toc_ha_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1610 void *data
, asection
*input_section
,
1611 bfd
*output_bfd
, char **error_message
)
1615 /* If this is a relocatable link (output_bfd test tells us), just
1616 call the generic function. Any adjustment will be done at final
1618 if (output_bfd
!= NULL
)
1619 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1620 input_section
, output_bfd
, error_message
);
1622 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1624 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1626 /* Subtract the TOC base address. */
1627 reloc_entry
->addend
-= TOCstart
+ TOC_BASE_OFF
;
1629 /* Adjust the addend for sign extension of the low 16 bits. */
1630 reloc_entry
->addend
+= 0x8000;
1631 return bfd_reloc_continue
;
1634 static bfd_reloc_status_type
1635 ppc64_elf_toc64_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1636 void *data
, asection
*input_section
,
1637 bfd
*output_bfd
, char **error_message
)
1640 bfd_size_type octets
;
1642 /* If this is a relocatable link (output_bfd test tells us), just
1643 call the generic function. Any adjustment will be done at final
1645 if (output_bfd
!= NULL
)
1646 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1647 input_section
, output_bfd
, error_message
);
1649 TOCstart
= _bfd_get_gp_value (input_section
->output_section
->owner
);
1651 TOCstart
= ppc64_elf_set_toc (NULL
, input_section
->output_section
->owner
);
1653 octets
= reloc_entry
->address
* OCTETS_PER_BYTE (abfd
, input_section
);
1654 bfd_put_64 (abfd
, TOCstart
+ TOC_BASE_OFF
, (bfd_byte
*) data
+ octets
);
1655 return bfd_reloc_ok
;
1658 static bfd_reloc_status_type
1659 ppc64_elf_prefix_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1660 void *data
, asection
*input_section
,
1661 bfd
*output_bfd
, char **error_message
)
1666 if (output_bfd
!= NULL
)
1667 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1668 input_section
, output_bfd
, error_message
);
1670 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
1672 insn
|= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1674 targ
= (symbol
->section
->output_section
->vma
1675 + symbol
->section
->output_offset
1676 + reloc_entry
->addend
);
1677 if (!bfd_is_com_section (symbol
->section
))
1678 targ
+= symbol
->value
;
1679 if (reloc_entry
->howto
->type
== R_PPC64_D34_HA30
)
1681 if (reloc_entry
->howto
->pc_relative
)
1683 bfd_vma from
= (reloc_entry
->address
1684 + input_section
->output_offset
1685 + input_section
->output_section
->vma
);
1688 targ
>>= reloc_entry
->howto
->rightshift
;
1689 insn
&= ~reloc_entry
->howto
->dst_mask
;
1690 insn
|= ((targ
<< 16) | (targ
& 0xffff)) & reloc_entry
->howto
->dst_mask
;
1691 bfd_put_32 (abfd
, insn
>> 32, (bfd_byte
*) data
+ reloc_entry
->address
);
1692 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
+ 4);
1693 if (reloc_entry
->howto
->complain_on_overflow
== complain_overflow_signed
1694 && (targ
+ (1ULL << (reloc_entry
->howto
->bitsize
- 1))
1695 >= 1ULL << reloc_entry
->howto
->bitsize
))
1696 return bfd_reloc_overflow
;
1697 return bfd_reloc_ok
;
1700 static bfd_reloc_status_type
1701 ppc64_elf_unhandled_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
1702 void *data
, asection
*input_section
,
1703 bfd
*output_bfd
, char **error_message
)
1705 /* If this is a relocatable link (output_bfd test tells us), just
1706 call the generic function. Any adjustment will be done at final
1708 if (output_bfd
!= NULL
)
1709 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
1710 input_section
, output_bfd
, error_message
);
1712 if (error_message
!= NULL
)
1714 static char buf
[60];
1715 sprintf (buf
, "generic linker can't handle %s",
1716 reloc_entry
->howto
->name
);
1717 *error_message
= buf
;
1719 return bfd_reloc_dangerous
;
1722 /* Track GOT entries needed for a given symbol. We might need more
1723 than one got entry per symbol. */
1726 struct got_entry
*next
;
1728 /* The symbol addend that we'll be placing in the GOT. */
1731 /* Unlike other ELF targets, we use separate GOT entries for the same
1732 symbol referenced from different input files. This is to support
1733 automatic multiple TOC/GOT sections, where the TOC base can vary
1734 from one input file to another. After partitioning into TOC groups
1735 we merge entries within the group.
1737 Point to the BFD owning this GOT entry. */
1740 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
1741 TLS_TPREL or TLS_DTPREL for tls entries. */
1742 unsigned char tls_type
;
1744 /* Non-zero if got.ent points to real entry. */
1745 unsigned char is_indirect
;
1747 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
1750 bfd_signed_vma refcount
;
1752 struct got_entry
*ent
;
1756 /* The same for PLT. */
1759 struct plt_entry
*next
;
1765 bfd_signed_vma refcount
;
1770 struct ppc64_elf_obj_tdata
1772 struct elf_obj_tdata elf
;
1774 /* Shortcuts to dynamic linker sections. */
1778 /* Used during garbage collection. We attach global symbols defined
1779 on removed .opd entries to this section so that the sym is removed. */
1780 asection
*deleted_section
;
1782 /* TLS local dynamic got entry handling. Support for multiple GOT
1783 sections means we potentially need one of these for each input bfd. */
1784 struct got_entry tlsld_got
;
1788 /* A copy of relocs before they are modified for --emit-relocs. */
1789 Elf_Internal_Rela
*relocs
;
1791 /* Section contents. */
1795 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
1796 the reloc to be in the range -32768 to 32767. */
1797 unsigned int has_small_toc_reloc
: 1;
1799 /* Set if toc/got ha relocs detected not using r2, or lo reloc
1800 instruction not one we handle. */
1801 unsigned int unexpected_toc_insn
: 1;
1803 /* Set if PLT/GOT/TOC relocs that can be optimised are present in
1805 unsigned int has_optrel
: 1;
1808 #define ppc64_elf_tdata(bfd) \
1809 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
1811 #define ppc64_tlsld_got(bfd) \
1812 (&ppc64_elf_tdata (bfd)->tlsld_got)
1814 #define is_ppc64_elf(bfd) \
1815 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
1816 && elf_object_id (bfd) == PPC64_ELF_DATA)
1818 /* Override the generic function because we store some extras. */
1821 ppc64_elf_mkobject (bfd
*abfd
)
1823 return bfd_elf_allocate_object (abfd
, sizeof (struct ppc64_elf_obj_tdata
),
1827 /* Fix bad default arch selected for a 64 bit input bfd when the
1828 default is 32 bit. Also select arch based on apuinfo. */
1831 ppc64_elf_object_p (bfd
*abfd
)
1833 if (!abfd
->arch_info
->the_default
)
1836 if (abfd
->arch_info
->bits_per_word
== 32)
1838 Elf_Internal_Ehdr
*i_ehdr
= elf_elfheader (abfd
);
1840 if (i_ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
)
1842 /* Relies on arch after 32 bit default being 64 bit default. */
1843 abfd
->arch_info
= abfd
->arch_info
->next
;
1844 BFD_ASSERT (abfd
->arch_info
->bits_per_word
== 64);
1847 return _bfd_elf_ppc_set_arch (abfd
);
1850 /* Support for core dump NOTE sections. */
1853 ppc64_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1855 size_t offset
, size
;
1857 if (note
->descsz
!= 504)
1861 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1864 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
1870 /* Make a ".reg/999" section. */
1871 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1872 size
, note
->descpos
+ offset
);
1876 ppc64_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1878 if (note
->descsz
!= 136)
1881 elf_tdata (abfd
)->core
->pid
1882 = bfd_get_32 (abfd
, note
->descdata
+ 24);
1883 elf_tdata (abfd
)->core
->program
1884 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
1885 elf_tdata (abfd
)->core
->command
1886 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
1892 ppc64_elf_write_core_note (bfd
*abfd
, char *buf
, int *bufsiz
, int note_type
,
1902 char data
[136] ATTRIBUTE_NONSTRING
;
1905 va_start (ap
, note_type
);
1906 memset (data
, 0, sizeof (data
));
1907 strncpy (data
+ 40, va_arg (ap
, const char *), 16);
1908 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1910 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
1911 -Wstringop-truncation:
1912 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
1914 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
1916 strncpy (data
+ 56, va_arg (ap
, const char *), 80);
1917 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
1921 return elfcore_write_note (abfd
, buf
, bufsiz
,
1922 "CORE", note_type
, data
, sizeof (data
));
1933 va_start (ap
, note_type
);
1934 memset (data
, 0, 112);
1935 pid
= va_arg (ap
, long);
1936 bfd_put_32 (abfd
, pid
, data
+ 32);
1937 cursig
= va_arg (ap
, int);
1938 bfd_put_16 (abfd
, cursig
, data
+ 12);
1939 greg
= va_arg (ap
, const void *);
1940 memcpy (data
+ 112, greg
, 384);
1941 memset (data
+ 496, 0, 8);
1943 return elfcore_write_note (abfd
, buf
, bufsiz
,
1944 "CORE", note_type
, data
, sizeof (data
));
1949 /* Add extra PPC sections. */
1951 static const struct bfd_elf_special_section ppc64_elf_special_sections
[] =
1953 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS
, 0 },
1954 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1955 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1956 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1957 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1958 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1959 { NULL
, 0, 0, 0, 0 }
1962 enum _ppc64_sec_type
{
1968 struct _ppc64_elf_section_data
1970 struct bfd_elf_section_data elf
;
1974 /* An array with one entry for each opd function descriptor,
1975 and some spares since opd entries may be either 16 or 24 bytes. */
1976 #define OPD_NDX(OFF) ((OFF) >> 4)
1977 struct _opd_sec_data
1979 /* Points to the function code section for local opd entries. */
1980 asection
**func_sec
;
1982 /* After editing .opd, adjust references to opd local syms. */
1986 /* An array for toc sections, indexed by offset/8. */
1987 struct _toc_sec_data
1989 /* Specifies the relocation symbol index used at a given toc offset. */
1992 /* And the relocation addend. */
1997 enum _ppc64_sec_type sec_type
:2;
1999 /* Flag set when small branches are detected. Used to
2000 select suitable defaults for the stub group size. */
2001 unsigned int has_14bit_branch
:1;
2003 /* Flag set when PLTCALL relocs are detected. */
2004 unsigned int has_pltcall
:1;
2006 /* Flag set when section has PLT/GOT/TOC relocations that can be
2008 unsigned int has_optrel
:1;
2011 #define ppc64_elf_section_data(sec) \
2012 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2015 ppc64_elf_new_section_hook (bfd
*abfd
, asection
*sec
)
2017 if (!sec
->used_by_bfd
)
2019 struct _ppc64_elf_section_data
*sdata
;
2020 size_t amt
= sizeof (*sdata
);
2022 sdata
= bfd_zalloc (abfd
, amt
);
2025 sec
->used_by_bfd
= sdata
;
2028 return _bfd_elf_new_section_hook (abfd
, sec
);
2032 ppc64_elf_section_flags (const Elf_Internal_Shdr
*hdr
)
2034 const char *name
= hdr
->bfd_section
->name
;
2036 if (strncmp (name
, ".sbss", 5) == 0
2037 || strncmp (name
, ".sdata", 6) == 0)
2038 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2043 static struct _opd_sec_data
*
2044 get_opd_info (asection
* sec
)
2047 && ppc64_elf_section_data (sec
) != NULL
2048 && ppc64_elf_section_data (sec
)->sec_type
== sec_opd
)
2049 return &ppc64_elf_section_data (sec
)->u
.opd
;
2053 /* Parameters for the qsort hook. */
2054 static bfd_boolean synthetic_relocatable
;
2055 static asection
*synthetic_opd
;
2057 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2060 compare_symbols (const void *ap
, const void *bp
)
2062 const asymbol
*a
= *(const asymbol
**) ap
;
2063 const asymbol
*b
= *(const asymbol
**) bp
;
2065 /* Section symbols first. */
2066 if ((a
->flags
& BSF_SECTION_SYM
) && !(b
->flags
& BSF_SECTION_SYM
))
2068 if (!(a
->flags
& BSF_SECTION_SYM
) && (b
->flags
& BSF_SECTION_SYM
))
2071 /* then .opd symbols. */
2072 if (synthetic_opd
!= NULL
)
2074 if (strcmp (a
->section
->name
, ".opd") == 0
2075 && strcmp (b
->section
->name
, ".opd") != 0)
2077 if (strcmp (a
->section
->name
, ".opd") != 0
2078 && strcmp (b
->section
->name
, ".opd") == 0)
2082 /* then other code symbols. */
2083 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2084 == (SEC_CODE
| SEC_ALLOC
))
2085 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2086 != (SEC_CODE
| SEC_ALLOC
)))
2089 if (((a
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2090 != (SEC_CODE
| SEC_ALLOC
))
2091 && ((b
->section
->flags
& (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
))
2092 == (SEC_CODE
| SEC_ALLOC
)))
2095 if (synthetic_relocatable
)
2097 if (a
->section
->id
< b
->section
->id
)
2100 if (a
->section
->id
> b
->section
->id
)
2104 if (a
->value
+ a
->section
->vma
< b
->value
+ b
->section
->vma
)
2107 if (a
->value
+ a
->section
->vma
> b
->value
+ b
->section
->vma
)
2110 /* For syms with the same value, prefer strong dynamic global function
2111 syms over other syms. */
2112 if ((a
->flags
& BSF_GLOBAL
) != 0 && (b
->flags
& BSF_GLOBAL
) == 0)
2115 if ((a
->flags
& BSF_GLOBAL
) == 0 && (b
->flags
& BSF_GLOBAL
) != 0)
2118 if ((a
->flags
& BSF_FUNCTION
) != 0 && (b
->flags
& BSF_FUNCTION
) == 0)
2121 if ((a
->flags
& BSF_FUNCTION
) == 0 && (b
->flags
& BSF_FUNCTION
) != 0)
2124 if ((a
->flags
& BSF_WEAK
) == 0 && (b
->flags
& BSF_WEAK
) != 0)
2127 if ((a
->flags
& BSF_WEAK
) != 0 && (b
->flags
& BSF_WEAK
) == 0)
2130 if ((a
->flags
& BSF_DYNAMIC
) != 0 && (b
->flags
& BSF_DYNAMIC
) == 0)
2133 if ((a
->flags
& BSF_DYNAMIC
) == 0 && (b
->flags
& BSF_DYNAMIC
) != 0)
2136 /* Finally, sort on where the symbol is in memory. The symbols will
2137 be in at most two malloc'd blocks, one for static syms, one for
2138 dynamic syms, and we distinguish the two blocks above by testing
2139 BSF_DYNAMIC. Since we are sorting the symbol pointers which were
2140 originally in the same order as the symbols (and we're not
2141 sorting the symbols themselves), this ensures a stable sort. */
2149 /* Search SYMS for a symbol of the given VALUE. */
2152 sym_exists_at (asymbol
**syms
, size_t lo
, size_t hi
, unsigned int id
,
2157 if (id
== (unsigned) -1)
2161 mid
= (lo
+ hi
) >> 1;
2162 if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
< value
)
2164 else if (syms
[mid
]->value
+ syms
[mid
]->section
->vma
> value
)
2174 mid
= (lo
+ hi
) >> 1;
2175 if (syms
[mid
]->section
->id
< id
)
2177 else if (syms
[mid
]->section
->id
> id
)
2179 else if (syms
[mid
]->value
< value
)
2181 else if (syms
[mid
]->value
> value
)
2191 section_covers_vma (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*section
, void *ptr
)
2193 bfd_vma vma
= *(bfd_vma
*) ptr
;
2194 return ((section
->flags
& SEC_ALLOC
) != 0
2195 && section
->vma
<= vma
2196 && vma
< section
->vma
+ section
->size
);
2199 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2200 entry syms. Also generate @plt symbols for the glink branch table.
2201 Returns count of synthetic symbols in RET or -1 on error. */
2204 ppc64_elf_get_synthetic_symtab (bfd
*abfd
,
2205 long static_count
, asymbol
**static_syms
,
2206 long dyn_count
, asymbol
**dyn_syms
,
2212 size_t symcount
, codesecsym
, codesecsymend
, secsymend
, opdsymend
;
2213 asection
*opd
= NULL
;
2214 bfd_boolean relocatable
= (abfd
->flags
& (EXEC_P
| DYNAMIC
)) == 0;
2216 int abi
= abiversion (abfd
);
2222 opd
= bfd_get_section_by_name (abfd
, ".opd");
2223 if (opd
== NULL
&& abi
== 1)
2235 symcount
= static_count
;
2237 symcount
+= dyn_count
;
2241 syms
= bfd_malloc ((symcount
+ 1) * sizeof (*syms
));
2245 if (!relocatable
&& static_count
!= 0 && dyn_count
!= 0)
2247 /* Use both symbol tables. */
2248 memcpy (syms
, static_syms
, static_count
* sizeof (*syms
));
2249 memcpy (syms
+ static_count
, dyn_syms
,
2250 (dyn_count
+ 1) * sizeof (*syms
));
2252 else if (!relocatable
&& static_count
== 0)
2253 memcpy (syms
, dyn_syms
, (symcount
+ 1) * sizeof (*syms
));
2255 memcpy (syms
, static_syms
, (symcount
+ 1) * sizeof (*syms
));
2257 /* Trim uninteresting symbols. Interesting symbols are section,
2258 function, and notype symbols. */
2259 for (i
= 0, j
= 0; i
< symcount
; ++i
)
2260 if ((syms
[i
]->flags
& (BSF_FILE
| BSF_OBJECT
| BSF_THREAD_LOCAL
2261 | BSF_RELC
| BSF_SRELC
)) == 0)
2262 syms
[j
++] = syms
[i
];
2265 synthetic_relocatable
= relocatable
;
2266 synthetic_opd
= opd
;
2267 qsort (syms
, symcount
, sizeof (*syms
), compare_symbols
);
2269 if (!relocatable
&& symcount
> 1)
2271 /* Trim duplicate syms, since we may have merged the normal
2272 and dynamic symbols. Actually, we only care about syms
2273 that have different values, so trim any with the same
2274 value. Don't consider ifunc and ifunc resolver symbols
2275 duplicates however, because GDB wants to know whether a
2276 text symbol is an ifunc resolver. */
2277 for (i
= 1, j
= 1; i
< symcount
; ++i
)
2279 const asymbol
*s0
= syms
[i
- 1];
2280 const asymbol
*s1
= syms
[i
];
2282 if ((s0
->value
+ s0
->section
->vma
2283 != s1
->value
+ s1
->section
->vma
)
2284 || ((s0
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
2285 != (s1
->flags
& BSF_GNU_INDIRECT_FUNCTION
)))
2286 syms
[j
++] = syms
[i
];
2292 /* Note that here and in compare_symbols we can't compare opd and
2293 sym->section directly. With separate debug info files, the
2294 symbols will be extracted from the debug file while abfd passed
2295 to this function is the real binary. */
2296 if (strcmp (syms
[i
]->section
->name
, ".opd") == 0)
2300 for (; i
< symcount
; ++i
)
2301 if (((syms
[i
]->section
->flags
& (SEC_CODE
| SEC_ALLOC
2302 | SEC_THREAD_LOCAL
))
2303 != (SEC_CODE
| SEC_ALLOC
))
2304 || (syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2308 for (; i
< symcount
; ++i
)
2309 if ((syms
[i
]->flags
& BSF_SECTION_SYM
) == 0)
2313 for (; i
< symcount
; ++i
)
2314 if (strcmp (syms
[i
]->section
->name
, ".opd") != 0)
2318 for (; i
< symcount
; ++i
)
2319 if (((syms
[i
]->section
->flags
2320 & (SEC_CODE
| SEC_ALLOC
| SEC_THREAD_LOCAL
)))
2321 != (SEC_CODE
| SEC_ALLOC
))
2329 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2334 if (opdsymend
== secsymend
)
2337 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2338 relcount
= (opd
->flags
& SEC_RELOC
) ? opd
->reloc_count
: 0;
2342 if (!(*slurp_relocs
) (abfd
, opd
, static_syms
, FALSE
))
2349 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2353 while (r
< opd
->relocation
+ relcount
2354 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2357 if (r
== opd
->relocation
+ relcount
)
2360 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2363 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2366 sym
= *r
->sym_ptr_ptr
;
2367 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2368 sym
->section
->id
, sym
->value
+ r
->addend
))
2371 size
+= sizeof (asymbol
);
2372 size
+= strlen (syms
[i
]->name
) + 2;
2378 s
= *ret
= bfd_malloc (size
);
2385 names
= (char *) (s
+ count
);
2387 for (i
= secsymend
, r
= opd
->relocation
; i
< opdsymend
; ++i
)
2391 while (r
< opd
->relocation
+ relcount
2392 && r
->address
< syms
[i
]->value
+ opd
->vma
)
2395 if (r
== opd
->relocation
+ relcount
)
2398 if (r
->address
!= syms
[i
]->value
+ opd
->vma
)
2401 if (r
->howto
->type
!= R_PPC64_ADDR64
)
2404 sym
= *r
->sym_ptr_ptr
;
2405 if (!sym_exists_at (syms
, opdsymend
, symcount
,
2406 sym
->section
->id
, sym
->value
+ r
->addend
))
2411 s
->flags
|= BSF_SYNTHETIC
;
2412 s
->section
= sym
->section
;
2413 s
->value
= sym
->value
+ r
->addend
;
2416 len
= strlen (syms
[i
]->name
);
2417 memcpy (names
, syms
[i
]->name
, len
+ 1);
2419 /* Have udata.p point back to the original symbol this
2420 synthetic symbol was derived from. */
2421 s
->udata
.p
= syms
[i
];
2428 bfd_boolean (*slurp_relocs
) (bfd
*, asection
*, asymbol
**, bfd_boolean
);
2429 bfd_byte
*contents
= NULL
;
2431 size_t plt_count
= 0;
2432 bfd_vma glink_vma
= 0, resolv_vma
= 0;
2433 asection
*dynamic
, *glink
= NULL
, *relplt
= NULL
;
2436 if (opd
!= NULL
&& !bfd_malloc_and_get_section (abfd
, opd
, &contents
))
2438 free_contents_and_exit_err
:
2440 free_contents_and_exit
:
2446 for (i
= secsymend
; i
< opdsymend
; ++i
)
2450 /* Ignore bogus symbols. */
2451 if (syms
[i
]->value
> opd
->size
- 8)
2454 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2455 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2458 size
+= sizeof (asymbol
);
2459 size
+= strlen (syms
[i
]->name
) + 2;
2463 /* Get start of .glink stubs from DT_PPC64_GLINK. */
2465 && (dynamic
= bfd_get_section_by_name (abfd
, ".dynamic")) != NULL
)
2467 bfd_byte
*dynbuf
, *extdyn
, *extdynend
;
2469 void (*swap_dyn_in
) (bfd
*, const void *, Elf_Internal_Dyn
*);
2471 if (!bfd_malloc_and_get_section (abfd
, dynamic
, &dynbuf
))
2472 goto free_contents_and_exit_err
;
2474 extdynsize
= get_elf_backend_data (abfd
)->s
->sizeof_dyn
;
2475 swap_dyn_in
= get_elf_backend_data (abfd
)->s
->swap_dyn_in
;
2478 extdynend
= extdyn
+ dynamic
->size
;
2479 for (; extdyn
< extdynend
; extdyn
+= extdynsize
)
2481 Elf_Internal_Dyn dyn
;
2482 (*swap_dyn_in
) (abfd
, extdyn
, &dyn
);
2484 if (dyn
.d_tag
== DT_NULL
)
2487 if (dyn
.d_tag
== DT_PPC64_GLINK
)
2489 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
2490 See comment in ppc64_elf_finish_dynamic_sections. */
2491 glink_vma
= dyn
.d_un
.d_val
+ 8 * 4;
2492 /* The .glink section usually does not survive the final
2493 link; search for the section (usually .text) where the
2494 glink stubs now reside. */
2495 glink
= bfd_sections_find_if (abfd
, section_covers_vma
,
2506 /* Determine __glink trampoline by reading the relative branch
2507 from the first glink stub. */
2509 unsigned int off
= 0;
2511 while (bfd_get_section_contents (abfd
, glink
, buf
,
2512 glink_vma
+ off
- glink
->vma
, 4))
2514 unsigned int insn
= bfd_get_32 (abfd
, buf
);
2516 if ((insn
& ~0x3fffffc) == 0)
2519 = glink_vma
+ off
+ (insn
^ 0x2000000) - 0x2000000;
2528 size
+= sizeof (asymbol
) + sizeof ("__glink_PLTresolve");
2530 relplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
2533 slurp_relocs
= get_elf_backend_data (abfd
)->s
->slurp_reloc_table
;
2534 if (!(*slurp_relocs
) (abfd
, relplt
, dyn_syms
, TRUE
))
2535 goto free_contents_and_exit_err
;
2537 plt_count
= relplt
->size
/ sizeof (Elf64_External_Rela
);
2538 size
+= plt_count
* sizeof (asymbol
);
2540 p
= relplt
->relocation
;
2541 for (i
= 0; i
< plt_count
; i
++, p
++)
2543 size
+= strlen ((*p
->sym_ptr_ptr
)->name
) + sizeof ("@plt");
2545 size
+= sizeof ("+0x") - 1 + 16;
2551 goto free_contents_and_exit
;
2552 s
= *ret
= bfd_malloc (size
);
2554 goto free_contents_and_exit_err
;
2556 names
= (char *) (s
+ count
+ plt_count
+ (resolv_vma
!= 0));
2558 for (i
= secsymend
; i
< opdsymend
; ++i
)
2562 if (syms
[i
]->value
> opd
->size
- 8)
2565 ent
= bfd_get_64 (abfd
, contents
+ syms
[i
]->value
);
2566 if (!sym_exists_at (syms
, opdsymend
, symcount
, -1, ent
))
2570 asection
*sec
= abfd
->sections
;
2577 size_t mid
= (lo
+ hi
) >> 1;
2578 if (syms
[mid
]->section
->vma
< ent
)
2580 else if (syms
[mid
]->section
->vma
> ent
)
2584 sec
= syms
[mid
]->section
;
2589 if (lo
>= hi
&& lo
> codesecsym
)
2590 sec
= syms
[lo
- 1]->section
;
2592 for (; sec
!= NULL
; sec
= sec
->next
)
2596 /* SEC_LOAD may not be set if SEC is from a separate debug
2598 if ((sec
->flags
& SEC_ALLOC
) == 0)
2600 if ((sec
->flags
& SEC_CODE
) != 0)
2603 s
->flags
|= BSF_SYNTHETIC
;
2604 s
->value
= ent
- s
->section
->vma
;
2607 len
= strlen (syms
[i
]->name
);
2608 memcpy (names
, syms
[i
]->name
, len
+ 1);
2610 /* Have udata.p point back to the original symbol this
2611 synthetic symbol was derived from. */
2612 s
->udata
.p
= syms
[i
];
2618 if (glink
!= NULL
&& relplt
!= NULL
)
2622 /* Add a symbol for the main glink trampoline. */
2623 memset (s
, 0, sizeof *s
);
2625 s
->flags
= BSF_GLOBAL
| BSF_SYNTHETIC
;
2627 s
->value
= resolv_vma
- glink
->vma
;
2629 memcpy (names
, "__glink_PLTresolve",
2630 sizeof ("__glink_PLTresolve"));
2631 names
+= sizeof ("__glink_PLTresolve");
2636 /* FIXME: It would be very much nicer to put sym@plt on the
2637 stub rather than on the glink branch table entry. The
2638 objdump disassembler would then use a sensible symbol
2639 name on plt calls. The difficulty in doing so is
2640 a) finding the stubs, and,
2641 b) matching stubs against plt entries, and,
2642 c) there can be multiple stubs for a given plt entry.
2644 Solving (a) could be done by code scanning, but older
2645 ppc64 binaries used different stubs to current code.
2646 (b) is the tricky one since you need to known the toc
2647 pointer for at least one function that uses a pic stub to
2648 be able to calculate the plt address referenced.
2649 (c) means gdb would need to set multiple breakpoints (or
2650 find the glink branch itself) when setting breakpoints
2651 for pending shared library loads. */
2652 p
= relplt
->relocation
;
2653 for (i
= 0; i
< plt_count
; i
++, p
++)
2657 *s
= **p
->sym_ptr_ptr
;
2658 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
2659 we are defining a symbol, ensure one of them is set. */
2660 if ((s
->flags
& BSF_LOCAL
) == 0)
2661 s
->flags
|= BSF_GLOBAL
;
2662 s
->flags
|= BSF_SYNTHETIC
;
2664 s
->value
= glink_vma
- glink
->vma
;
2667 len
= strlen ((*p
->sym_ptr_ptr
)->name
);
2668 memcpy (names
, (*p
->sym_ptr_ptr
)->name
, len
);
2672 memcpy (names
, "+0x", sizeof ("+0x") - 1);
2673 names
+= sizeof ("+0x") - 1;
2674 bfd_sprintf_vma (abfd
, names
, p
->addend
);
2675 names
+= strlen (names
);
2677 memcpy (names
, "@plt", sizeof ("@plt"));
2678 names
+= sizeof ("@plt");
2698 /* The following functions are specific to the ELF linker, while
2699 functions above are used generally. Those named ppc64_elf_* are
2700 called by the main ELF linker code. They appear in this file more
2701 or less in the order in which they are called. eg.
2702 ppc64_elf_check_relocs is called early in the link process,
2703 ppc64_elf_finish_dynamic_sections is one of the last functions
2706 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2707 functions have both a function code symbol and a function descriptor
2708 symbol. A call to foo in a relocatable object file looks like:
2715 The function definition in another object file might be:
2719 . .quad .TOC.@tocbase
2725 When the linker resolves the call during a static link, the branch
2726 unsurprisingly just goes to .foo and the .opd information is unused.
2727 If the function definition is in a shared library, things are a little
2728 different: The call goes via a plt call stub, the opd information gets
2729 copied to the plt, and the linker patches the nop.
2737 . std 2,40(1) # in practice, the call stub
2738 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
2739 . addi 11,11,Lfoo@toc@l # this is the general idea
2747 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2749 The "reloc ()" notation is supposed to indicate that the linker emits
2750 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
2753 What are the difficulties here? Well, firstly, the relocations
2754 examined by the linker in check_relocs are against the function code
2755 sym .foo, while the dynamic relocation in the plt is emitted against
2756 the function descriptor symbol, foo. Somewhere along the line, we need
2757 to carefully copy dynamic link information from one symbol to the other.
2758 Secondly, the generic part of the elf linker will make .foo a dynamic
2759 symbol as is normal for most other backends. We need foo dynamic
2760 instead, at least for an application final link. However, when
2761 creating a shared library containing foo, we need to have both symbols
2762 dynamic so that references to .foo are satisfied during the early
2763 stages of linking. Otherwise the linker might decide to pull in a
2764 definition from some other object, eg. a static library.
2766 Update: As of August 2004, we support a new convention. Function
2767 calls may use the function descriptor symbol, ie. "bl foo". This
2768 behaves exactly as "bl .foo". */
2770 /* Of those relocs that might be copied as dynamic relocs, this
2771 function selects those that must be copied when linking a shared
2772 library or PIE, even when the symbol is local. */
2775 must_be_dyn_reloc (struct bfd_link_info
*info
,
2776 enum elf_ppc64_reloc_type r_type
)
2781 /* Only relative relocs can be resolved when the object load
2782 address isn't fixed. DTPREL64 is excluded because the
2783 dynamic linker needs to differentiate global dynamic from
2784 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
2791 case R_PPC64_TOC16_DS
:
2792 case R_PPC64_TOC16_LO
:
2793 case R_PPC64_TOC16_HI
:
2794 case R_PPC64_TOC16_HA
:
2795 case R_PPC64_TOC16_LO_DS
:
2798 case R_PPC64_TPREL16
:
2799 case R_PPC64_TPREL16_LO
:
2800 case R_PPC64_TPREL16_HI
:
2801 case R_PPC64_TPREL16_HA
:
2802 case R_PPC64_TPREL16_DS
:
2803 case R_PPC64_TPREL16_LO_DS
:
2804 case R_PPC64_TPREL16_HIGH
:
2805 case R_PPC64_TPREL16_HIGHA
:
2806 case R_PPC64_TPREL16_HIGHER
:
2807 case R_PPC64_TPREL16_HIGHERA
:
2808 case R_PPC64_TPREL16_HIGHEST
:
2809 case R_PPC64_TPREL16_HIGHESTA
:
2810 case R_PPC64_TPREL64
:
2811 case R_PPC64_TPREL34
:
2812 /* These relocations are relative but in a shared library the
2813 linker doesn't know the thread pointer base. */
2814 return bfd_link_dll (info
);
2818 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
2819 copying dynamic variables from a shared lib into an app's .dynbss
2820 section, and instead use a dynamic relocation to point into the
2821 shared lib. With code that gcc generates it is vital that this be
2822 enabled; In the PowerPC64 ELFv1 ABI the address of a function is
2823 actually the address of a function descriptor which resides in the
2824 .opd section. gcc uses the descriptor directly rather than going
2825 via the GOT as some other ABIs do, which means that initialized
2826 function pointers reference the descriptor. Thus, a function
2827 pointer initialized to the address of a function in a shared
2828 library will either require a .dynbss copy and a copy reloc, or a
2829 dynamic reloc. Using a .dynbss copy redefines the function
2830 descriptor symbol to point to the copy. This presents a problem as
2831 a PLT entry for that function is also initialized from the function
2832 descriptor symbol and the copy may not be initialized first. */
2833 #define ELIMINATE_COPY_RELOCS 1
2835 /* Section name for stubs is the associated section name plus this
2837 #define STUB_SUFFIX ".stub"
2840 ppc_stub_long_branch:
2841 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
2842 destination, but a 24 bit branch in a stub section will reach.
2845 ppc_stub_plt_branch:
2846 Similar to the above, but a 24 bit branch in the stub section won't
2847 reach its destination.
2848 . addis %r12,%r2,xxx@toc@ha
2849 . ld %r12,xxx@toc@l(%r12)
2854 Used to call a function in a shared library. If it so happens that
2855 the plt entry referenced crosses a 64k boundary, then an extra
2856 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
2857 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
2858 . addis %r11,%r2,xxx@toc@ha
2859 . ld %r12,xxx+0@toc@l(%r11)
2861 . ld %r2,xxx+8@toc@l(%r11)
2862 . ld %r11,xxx+16@toc@l(%r11)
2865 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
2866 code to adjust the value and save r2 to support multiple toc sections.
2867 A ppc_stub_long_branch with an r2 offset looks like:
2869 . addis %r2,%r2,off@ha
2870 . addi %r2,%r2,off@l
2873 A ppc_stub_plt_branch with an r2 offset looks like:
2875 . addis %r12,%r2,xxx@toc@ha
2876 . ld %r12,xxx@toc@l(%r12)
2877 . addis %r2,%r2,off@ha
2878 . addi %r2,%r2,off@l
2882 All of the above stubs are shown as their ELFv1 variants. ELFv2
2883 variants exist too, simpler for plt calls since a new toc pointer
2884 and static chain are not loaded by the stub. In addition, ELFv2
2885 has some more complex stubs to handle calls marked with NOTOC
2886 relocs from functions where r2 is not a valid toc pointer. These
2887 come in two flavours, the ones shown below, and _both variants that
2888 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
2889 one call is from a function where r2 is used as the toc pointer but
2890 needs a toc adjusting stub for small-model multi-toc, and another
2891 call is from a function where r2 is not valid.
2892 ppc_stub_long_branch_notoc:
2898 . addis %r12,%r11,dest-1b@ha
2899 . addi %r12,%r12,dest-1b@l
2902 ppc_stub_plt_branch_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 . add %r12,%r11,%r12
2917 ppc_stub_plt_call_notoc:
2923 . lis %r12,xxx-1b@highest
2924 . ori %r12,%r12,xxx-1b@higher
2926 . oris %r12,%r12,xxx-1b@high
2927 . ori %r12,%r12,xxx-1b@l
2928 . ldx %r12,%r11,%r12
2932 There are also ELFv1 power10 variants of these stubs.
2933 ppc_stub_long_branch_notoc:
2934 . pla %r12,dest@pcrel
2936 ppc_stub_plt_branch_notoc:
2937 . lis %r11,(dest-1f)@highesta34
2938 . ori %r11,%r11,(dest-1f)@highera34
2940 . 1: pla %r12,dest@pcrel
2941 . add %r12,%r11,%r12
2944 ppc_stub_plt_call_notoc:
2945 . lis %r11,(xxx-1f)@highesta34
2946 . ori %r11,%r11,(xxx-1f)@highera34
2948 . 1: pla %r12,xxx@pcrel
2949 . ldx %r12,%r11,%r12
2953 In cases where the high instructions would add zero, they are
2954 omitted and following instructions modified in some cases.
2955 For example, a power10 ppc_stub_plt_call_notoc might simplify down
2957 . pld %r12,xxx@pcrel
2961 For a given stub group (a set of sections all using the same toc
2962 pointer value) there will be just one stub type used for any
2963 particular function symbol. For example, if printf is called from
2964 code with the tocsave optimization (ie. r2 saved in function
2965 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
2966 and from other code without the tocsave optimization requiring a
2967 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
2968 type will be created. Calls with the tocsave optimization will
2969 enter this stub after the instruction saving r2. A similar
2970 situation exists when calls are marked with R_PPC64_REL24_NOTOC
2971 relocations. These require a ppc_stub_plt_call_notoc linkage stub
2972 to call an external function like printf. If other calls to printf
2973 require a ppc_stub_plt_call linkage stub then a single
2974 ppc_stub_plt_call_notoc linkage stub will be used for both types of
2975 call. If other calls to printf require a ppc_stub_plt_call_r2save
2976 linkage stub then a single ppc_stub_plt_call_both linkage stub will
2977 be created and calls not requiring r2 to be saved will enter the
2978 stub after the r2 save instruction. There is an analogous
2979 hierarchy of long branch and plt branch stubs for local call
2985 ppc_stub_long_branch
,
2986 ppc_stub_long_branch_r2off
,
2987 ppc_stub_long_branch_notoc
,
2988 ppc_stub_long_branch_both
, /* r2off and notoc variants both needed. */
2989 ppc_stub_plt_branch
,
2990 ppc_stub_plt_branch_r2off
,
2991 ppc_stub_plt_branch_notoc
,
2992 ppc_stub_plt_branch_both
,
2994 ppc_stub_plt_call_r2save
,
2995 ppc_stub_plt_call_notoc
,
2996 ppc_stub_plt_call_both
,
2997 ppc_stub_global_entry
,
3001 /* Information on stub grouping. */
3004 /* The stub section. */
3006 /* This is the section to which stubs in the group will be attached. */
3009 struct map_stub
*next
;
3010 /* Whether to emit a copy of register save/restore functions in this
3013 /* Current offset within stubs after the insn restoring lr in a
3014 _notoc or _both stub using bcl for pc-relative addressing, or
3015 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
3016 unsigned int lr_restore
;
3017 /* Accumulated size of EH info emitted to describe return address
3018 if stubs modify lr. Does not include 17 byte FDE header. */
3019 unsigned int eh_size
;
3020 /* Offset in glink_eh_frame to the start of EH info for this group. */
3021 unsigned int eh_base
;
3024 struct ppc_stub_hash_entry
3026 /* Base hash table entry structure. */
3027 struct bfd_hash_entry root
;
3029 enum ppc_stub_type stub_type
;
3031 /* Group information. */
3032 struct map_stub
*group
;
3034 /* Offset within stub_sec of the beginning of this stub. */
3035 bfd_vma stub_offset
;
3037 /* Given the symbol's value and its section we can determine its final
3038 value when building the stubs (so the stub knows where to jump. */
3039 bfd_vma target_value
;
3040 asection
*target_section
;
3042 /* The symbol table entry, if any, that this was derived from. */
3043 struct ppc_link_hash_entry
*h
;
3044 struct plt_entry
*plt_ent
;
3047 unsigned char symtype
;
3049 /* Symbol st_other. */
3050 unsigned char other
;
3053 struct ppc_branch_hash_entry
3055 /* Base hash table entry structure. */
3056 struct bfd_hash_entry root
;
3058 /* Offset within branch lookup table. */
3059 unsigned int offset
;
3061 /* Generation marker. */
3065 /* Used to track dynamic relocations for local symbols. */
3066 struct ppc_dyn_relocs
3068 struct ppc_dyn_relocs
*next
;
3070 /* The input section of the reloc. */
3073 /* Total number of relocs copied for the input section. */
3074 unsigned int count
: 31;
3076 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3077 unsigned int ifunc
: 1;
3080 struct ppc_link_hash_entry
3082 struct elf_link_hash_entry elf
;
3086 /* A pointer to the most recently used stub hash entry against this
3088 struct ppc_stub_hash_entry
*stub_cache
;
3090 /* A pointer to the next symbol starting with a '.' */
3091 struct ppc_link_hash_entry
*next_dot_sym
;
3094 /* Link between function code and descriptor symbols. */
3095 struct ppc_link_hash_entry
*oh
;
3097 /* Flag function code and descriptor symbols. */
3098 unsigned int is_func
:1;
3099 unsigned int is_func_descriptor
:1;
3100 unsigned int fake
:1;
3102 /* Whether global opd/toc sym has been adjusted or not.
3103 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3104 should be set for all globals defined in any opd/toc section. */
3105 unsigned int adjust_done
:1;
3107 /* Set if this is an out-of-line register save/restore function,
3108 with non-standard calling convention. */
3109 unsigned int save_res
:1;
3111 /* Set if a duplicate symbol with non-zero localentry is detected,
3112 even when the duplicate symbol does not provide a definition. */
3113 unsigned int non_zero_localentry
:1;
3115 /* Contexts in which symbol is used in the GOT (or TOC).
3116 Bits are or'd into the mask as the corresponding relocs are
3117 encountered during check_relocs, with TLS_TLS being set when any
3118 of the other TLS bits are set. tls_optimize clears bits when
3119 optimizing to indicate the corresponding GOT entry type is not
3120 needed. If set, TLS_TLS is never cleared. tls_optimize may also
3121 set TLS_GDIE when a GD reloc turns into an IE one.
3122 These flags are also kept for local symbols. */
3123 #define TLS_TLS 1 /* Any TLS reloc. */
3124 #define TLS_GD 2 /* GD reloc. */
3125 #define TLS_LD 4 /* LD reloc. */
3126 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
3127 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
3128 #define TLS_MARK 32 /* __tls_get_addr call marked. */
3129 #define TLS_GDIE 64 /* GOT TPREL reloc resulting from GD->IE. */
3130 #define TLS_EXPLICIT 256 /* TOC section TLS reloc, not stored. */
3131 unsigned char tls_mask
;
3133 /* The above field is also used to mark function symbols. In which
3134 case TLS_TLS will be 0. */
3135 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
3136 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
3137 #define NON_GOT 256 /* local symbol plt, not stored. */
3140 static inline struct ppc_link_hash_entry
*
3141 ppc_elf_hash_entry (struct elf_link_hash_entry
*ent
)
3143 return (struct ppc_link_hash_entry
*) ent
;
3146 /* ppc64 ELF linker hash table. */
3148 struct ppc_link_hash_table
3150 struct elf_link_hash_table elf
;
3152 /* The stub hash table. */
3153 struct bfd_hash_table stub_hash_table
;
3155 /* Another hash table for plt_branch stubs. */
3156 struct bfd_hash_table branch_hash_table
;
3158 /* Hash table for function prologue tocsave. */
3159 htab_t tocsave_htab
;
3161 /* Various options and other info passed from the linker. */
3162 struct ppc64_elf_params
*params
;
3164 /* The size of sec_info below. */
3165 unsigned int sec_info_arr_size
;
3167 /* Per-section array of extra section info. Done this way rather
3168 than as part of ppc64_elf_section_data so we have the info for
3169 non-ppc64 sections. */
3172 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3177 /* The section group that this section belongs to. */
3178 struct map_stub
*group
;
3179 /* A temp section list pointer. */
3184 /* Linked list of groups. */
3185 struct map_stub
*group
;
3187 /* Temp used when calculating TOC pointers. */
3190 asection
*toc_first_sec
;
3192 /* Used when adding symbols. */
3193 struct ppc_link_hash_entry
*dot_syms
;
3195 /* Shortcuts to get to dynamic linker sections. */
3197 asection
*global_entry
;
3200 asection
*relpltlocal
;
3203 asection
*glink_eh_frame
;
3205 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3206 struct ppc_link_hash_entry
*tls_get_addr
;
3207 struct ppc_link_hash_entry
*tls_get_addr_fd
;
3208 struct ppc_link_hash_entry
*tga_desc
;
3209 struct ppc_link_hash_entry
*tga_desc_fd
;
3210 struct map_stub
*tga_group
;
3212 /* The size of reliplt used by got entry relocs. */
3213 bfd_size_type got_reli_size
;
3216 unsigned long stub_count
[ppc_stub_global_entry
];
3218 /* Number of stubs against global syms. */
3219 unsigned long stub_globals
;
3221 /* Set if we're linking code with function descriptors. */
3222 unsigned int opd_abi
:1;
3224 /* Support for multiple toc sections. */
3225 unsigned int do_multi_toc
:1;
3226 unsigned int multi_toc_needed
:1;
3227 unsigned int second_toc_pass
:1;
3228 unsigned int do_toc_opt
:1;
3230 /* Set if tls optimization is enabled. */
3231 unsigned int do_tls_opt
:1;
3233 /* Set if inline plt calls should be converted to direct calls. */
3234 unsigned int can_convert_all_inline_plt
:1;
3237 unsigned int stub_error
:1;
3239 /* Whether func_desc_adjust needs to be run over symbols. */
3240 unsigned int need_func_desc_adj
:1;
3242 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
3243 unsigned int has_plt_localentry0
:1;
3245 /* Whether calls are made via the PLT from NOTOC functions. */
3246 unsigned int notoc_plt
:1;
3248 /* Whether to use power10 instructions in linkage stubs. */
3249 unsigned int power10_stubs
:1;
3251 /* Incremented every time we size stubs. */
3252 unsigned int stub_iteration
;
3254 /* Small local sym cache. */
3255 struct sym_cache sym_cache
;
3258 /* Rename some of the generic section flags to better document how they
3261 /* Nonzero if this section has TLS related relocations. */
3262 #define has_tls_reloc sec_flg0
3264 /* Nonzero if this section has a call to __tls_get_addr lacking marker
3266 #define nomark_tls_get_addr sec_flg1
3268 /* Nonzero if this section has any toc or got relocs. */
3269 #define has_toc_reloc sec_flg2
3271 /* Nonzero if this section has a call to another section that uses
3273 #define makes_toc_func_call sec_flg3
3275 /* Recursion protection when determining above flag. */
3276 #define call_check_in_progress sec_flg4
3277 #define call_check_done sec_flg5
3279 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3281 #define ppc_hash_table(p) \
3282 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3283 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3285 #define ppc_stub_hash_lookup(table, string, create, copy) \
3286 ((struct ppc_stub_hash_entry *) \
3287 bfd_hash_lookup ((table), (string), (create), (copy)))
3289 #define ppc_branch_hash_lookup(table, string, create, copy) \
3290 ((struct ppc_branch_hash_entry *) \
3291 bfd_hash_lookup ((table), (string), (create), (copy)))
3293 /* Create an entry in the stub hash table. */
3295 static struct bfd_hash_entry
*
3296 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
3297 struct bfd_hash_table
*table
,
3300 /* Allocate the structure if it has not already been allocated by a
3304 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_stub_hash_entry
));
3309 /* Call the allocation method of the superclass. */
3310 entry
= bfd_hash_newfunc (entry
, table
, string
);
3313 struct ppc_stub_hash_entry
*eh
;
3315 /* Initialize the local fields. */
3316 eh
= (struct ppc_stub_hash_entry
*) entry
;
3317 eh
->stub_type
= ppc_stub_none
;
3319 eh
->stub_offset
= 0;
3320 eh
->target_value
= 0;
3321 eh
->target_section
= NULL
;
3330 /* Create an entry in the branch hash table. */
3332 static struct bfd_hash_entry
*
3333 branch_hash_newfunc (struct bfd_hash_entry
*entry
,
3334 struct bfd_hash_table
*table
,
3337 /* Allocate the structure if it has not already been allocated by a
3341 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_branch_hash_entry
));
3346 /* Call the allocation method of the superclass. */
3347 entry
= bfd_hash_newfunc (entry
, table
, string
);
3350 struct ppc_branch_hash_entry
*eh
;
3352 /* Initialize the local fields. */
3353 eh
= (struct ppc_branch_hash_entry
*) entry
;
3361 /* Create an entry in a ppc64 ELF linker hash table. */
3363 static struct bfd_hash_entry
*
3364 link_hash_newfunc (struct bfd_hash_entry
*entry
,
3365 struct bfd_hash_table
*table
,
3368 /* Allocate the structure if it has not already been allocated by a
3372 entry
= bfd_hash_allocate (table
, sizeof (struct ppc_link_hash_entry
));
3377 /* Call the allocation method of the superclass. */
3378 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
3381 struct ppc_link_hash_entry
*eh
= (struct ppc_link_hash_entry
*) entry
;
3383 memset (&eh
->u
.stub_cache
, 0,
3384 (sizeof (struct ppc_link_hash_entry
)
3385 - offsetof (struct ppc_link_hash_entry
, u
.stub_cache
)));
3387 /* When making function calls, old ABI code references function entry
3388 points (dot symbols), while new ABI code references the function
3389 descriptor symbol. We need to make any combination of reference and
3390 definition work together, without breaking archive linking.
3392 For a defined function "foo" and an undefined call to "bar":
3393 An old object defines "foo" and ".foo", references ".bar" (possibly
3395 A new object defines "foo" and references "bar".
3397 A new object thus has no problem with its undefined symbols being
3398 satisfied by definitions in an old object. On the other hand, the
3399 old object won't have ".bar" satisfied by a new object.
3401 Keep a list of newly added dot-symbols. */
3403 if (string
[0] == '.')
3405 struct ppc_link_hash_table
*htab
;
3407 htab
= (struct ppc_link_hash_table
*) table
;
3408 eh
->u
.next_dot_sym
= htab
->dot_syms
;
3409 htab
->dot_syms
= eh
;
3416 struct tocsave_entry
3423 tocsave_htab_hash (const void *p
)
3425 const struct tocsave_entry
*e
= (const struct tocsave_entry
*) p
;
3426 return ((bfd_vma
) (intptr_t) e
->sec
^ e
->offset
) >> 3;
3430 tocsave_htab_eq (const void *p1
, const void *p2
)
3432 const struct tocsave_entry
*e1
= (const struct tocsave_entry
*) p1
;
3433 const struct tocsave_entry
*e2
= (const struct tocsave_entry
*) p2
;
3434 return e1
->sec
== e2
->sec
&& e1
->offset
== e2
->offset
;
3437 /* Destroy a ppc64 ELF linker hash table. */
3440 ppc64_elf_link_hash_table_free (bfd
*obfd
)
3442 struct ppc_link_hash_table
*htab
;
3444 htab
= (struct ppc_link_hash_table
*) obfd
->link
.hash
;
3445 if (htab
->tocsave_htab
)
3446 htab_delete (htab
->tocsave_htab
);
3447 bfd_hash_table_free (&htab
->branch_hash_table
);
3448 bfd_hash_table_free (&htab
->stub_hash_table
);
3449 _bfd_elf_link_hash_table_free (obfd
);
3452 /* Create a ppc64 ELF linker hash table. */
3454 static struct bfd_link_hash_table
*
3455 ppc64_elf_link_hash_table_create (bfd
*abfd
)
3457 struct ppc_link_hash_table
*htab
;
3458 size_t amt
= sizeof (struct ppc_link_hash_table
);
3460 htab
= bfd_zmalloc (amt
);
3464 if (!_bfd_elf_link_hash_table_init (&htab
->elf
, abfd
, link_hash_newfunc
,
3465 sizeof (struct ppc_link_hash_entry
),
3472 /* Init the stub hash table too. */
3473 if (!bfd_hash_table_init (&htab
->stub_hash_table
, stub_hash_newfunc
,
3474 sizeof (struct ppc_stub_hash_entry
)))
3476 _bfd_elf_link_hash_table_free (abfd
);
3480 /* And the branch hash table. */
3481 if (!bfd_hash_table_init (&htab
->branch_hash_table
, branch_hash_newfunc
,
3482 sizeof (struct ppc_branch_hash_entry
)))
3484 bfd_hash_table_free (&htab
->stub_hash_table
);
3485 _bfd_elf_link_hash_table_free (abfd
);
3489 htab
->tocsave_htab
= htab_try_create (1024,
3493 if (htab
->tocsave_htab
== NULL
)
3495 ppc64_elf_link_hash_table_free (abfd
);
3498 htab
->elf
.root
.hash_table_free
= ppc64_elf_link_hash_table_free
;
3500 /* Initializing two fields of the union is just cosmetic. We really
3501 only care about glist, but when compiled on a 32-bit host the
3502 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3503 debugger inspection of these fields look nicer. */
3504 htab
->elf
.init_got_refcount
.refcount
= 0;
3505 htab
->elf
.init_got_refcount
.glist
= NULL
;
3506 htab
->elf
.init_plt_refcount
.refcount
= 0;
3507 htab
->elf
.init_plt_refcount
.glist
= NULL
;
3508 htab
->elf
.init_got_offset
.offset
= 0;
3509 htab
->elf
.init_got_offset
.glist
= NULL
;
3510 htab
->elf
.init_plt_offset
.offset
= 0;
3511 htab
->elf
.init_plt_offset
.glist
= NULL
;
3513 return &htab
->elf
.root
;
3516 /* Create sections for linker generated code. */
3519 create_linkage_sections (bfd
*dynobj
, struct bfd_link_info
*info
)
3521 struct ppc_link_hash_table
*htab
;
3524 htab
= ppc_hash_table (info
);
3526 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_READONLY
3527 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3528 if (htab
->params
->save_restore_funcs
)
3530 /* Create .sfpr for code to save and restore fp regs. */
3531 htab
->sfpr
= bfd_make_section_anyway_with_flags (dynobj
, ".sfpr",
3533 if (htab
->sfpr
== NULL
3534 || !bfd_set_section_alignment (htab
->sfpr
, 2))
3538 if (bfd_link_relocatable (info
))
3541 /* Create .glink for lazy dynamic linking support. */
3542 htab
->glink
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3544 if (htab
->glink
== NULL
3545 || !bfd_set_section_alignment (htab
->glink
, 3))
3548 /* The part of .glink used by global entry stubs, separate so that
3549 it can be aligned appropriately without affecting htab->glink. */
3550 htab
->global_entry
= bfd_make_section_anyway_with_flags (dynobj
, ".glink",
3552 if (htab
->global_entry
== NULL
3553 || !bfd_set_section_alignment (htab
->global_entry
, 2))
3556 if (!info
->no_ld_generated_unwind_info
)
3558 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_HAS_CONTENTS
3559 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3560 htab
->glink_eh_frame
= bfd_make_section_anyway_with_flags (dynobj
,
3563 if (htab
->glink_eh_frame
== NULL
3564 || !bfd_set_section_alignment (htab
->glink_eh_frame
, 2))
3568 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
3569 htab
->elf
.iplt
= bfd_make_section_anyway_with_flags (dynobj
, ".iplt", flags
);
3570 if (htab
->elf
.iplt
== NULL
3571 || !bfd_set_section_alignment (htab
->elf
.iplt
, 3))
3574 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3575 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3577 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.iplt", flags
);
3578 if (htab
->elf
.irelplt
== NULL
3579 || !bfd_set_section_alignment (htab
->elf
.irelplt
, 3))
3582 /* Create branch lookup table for plt_branch stubs. */
3583 flags
= (SEC_ALLOC
| SEC_LOAD
3584 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3585 htab
->brlt
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3587 if (htab
->brlt
== NULL
3588 || !bfd_set_section_alignment (htab
->brlt
, 3))
3591 /* Local plt entries, put in .branch_lt but a separate section for
3593 htab
->pltlocal
= bfd_make_section_anyway_with_flags (dynobj
, ".branch_lt",
3595 if (htab
->pltlocal
== NULL
3596 || !bfd_set_section_alignment (htab
->pltlocal
, 3))
3599 if (!bfd_link_pic (info
))
3602 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
3603 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
3605 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3606 if (htab
->relbrlt
== NULL
3607 || !bfd_set_section_alignment (htab
->relbrlt
, 3))
3611 = bfd_make_section_anyway_with_flags (dynobj
, ".rela.branch_lt", flags
);
3612 if (htab
->relpltlocal
== NULL
3613 || !bfd_set_section_alignment (htab
->relpltlocal
, 3))
3619 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3622 ppc64_elf_init_stub_bfd (struct bfd_link_info
*info
,
3623 struct ppc64_elf_params
*params
)
3625 struct ppc_link_hash_table
*htab
;
3627 elf_elfheader (params
->stub_bfd
)->e_ident
[EI_CLASS
] = ELFCLASS64
;
3629 /* Always hook our dynamic sections into the first bfd, which is the
3630 linker created stub bfd. This ensures that the GOT header is at
3631 the start of the output TOC section. */
3632 htab
= ppc_hash_table (info
);
3633 htab
->elf
.dynobj
= params
->stub_bfd
;
3634 htab
->params
= params
;
3636 return create_linkage_sections (htab
->elf
.dynobj
, info
);
3639 /* Build a name for an entry in the stub hash table. */
3642 ppc_stub_name (const asection
*input_section
,
3643 const asection
*sym_sec
,
3644 const struct ppc_link_hash_entry
*h
,
3645 const Elf_Internal_Rela
*rel
)
3650 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3651 offsets from a sym as a branch target? In fact, we could
3652 probably assume the addend is always zero. */
3653 BFD_ASSERT (((int) rel
->r_addend
& 0xffffffff) == rel
->r_addend
);
3657 len
= 8 + 1 + strlen (h
->elf
.root
.root
.string
) + 1 + 8 + 1;
3658 stub_name
= bfd_malloc (len
);
3659 if (stub_name
== NULL
)
3662 len
= sprintf (stub_name
, "%08x.%s+%x",
3663 input_section
->id
& 0xffffffff,
3664 h
->elf
.root
.root
.string
,
3665 (int) rel
->r_addend
& 0xffffffff);
3669 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3670 stub_name
= bfd_malloc (len
);
3671 if (stub_name
== NULL
)
3674 len
= sprintf (stub_name
, "%08x.%x:%x+%x",
3675 input_section
->id
& 0xffffffff,
3676 sym_sec
->id
& 0xffffffff,
3677 (int) ELF64_R_SYM (rel
->r_info
) & 0xffffffff,
3678 (int) rel
->r_addend
& 0xffffffff);
3680 if (len
> 2 && stub_name
[len
- 2] == '+' && stub_name
[len
- 1] == '0')
3681 stub_name
[len
- 2] = 0;
3685 /* Look up an entry in the stub hash. Stub entries are cached because
3686 creating the stub name takes a bit of time. */
3688 static struct ppc_stub_hash_entry
*
3689 ppc_get_stub_entry (const asection
*input_section
,
3690 const asection
*sym_sec
,
3691 struct ppc_link_hash_entry
*h
,
3692 const Elf_Internal_Rela
*rel
,
3693 struct ppc_link_hash_table
*htab
)
3695 struct ppc_stub_hash_entry
*stub_entry
;
3696 struct map_stub
*group
;
3698 /* If this input section is part of a group of sections sharing one
3699 stub section, then use the id of the first section in the group.
3700 Stub names need to include a section id, as there may well be
3701 more than one stub used to reach say, printf, and we need to
3702 distinguish between them. */
3703 group
= htab
->sec_info
[input_section
->id
].u
.group
;
3707 if (h
!= NULL
&& h
->u
.stub_cache
!= NULL
3708 && h
->u
.stub_cache
->h
== h
3709 && h
->u
.stub_cache
->group
== group
)
3711 stub_entry
= h
->u
.stub_cache
;
3717 stub_name
= ppc_stub_name (group
->link_sec
, sym_sec
, h
, rel
);
3718 if (stub_name
== NULL
)
3721 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
3722 stub_name
, FALSE
, FALSE
);
3724 h
->u
.stub_cache
= stub_entry
;
3732 /* Add a new stub entry to the stub hash. Not all fields of the new
3733 stub entry are initialised. */
3735 static struct ppc_stub_hash_entry
*
3736 ppc_add_stub (const char *stub_name
,
3738 struct bfd_link_info
*info
)
3740 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3741 struct map_stub
*group
;
3744 struct ppc_stub_hash_entry
*stub_entry
;
3746 group
= htab
->sec_info
[section
->id
].u
.group
;
3747 link_sec
= group
->link_sec
;
3748 stub_sec
= group
->stub_sec
;
3749 if (stub_sec
== NULL
)
3755 namelen
= strlen (link_sec
->name
);
3756 len
= namelen
+ sizeof (STUB_SUFFIX
);
3757 s_name
= bfd_alloc (htab
->params
->stub_bfd
, len
);
3761 memcpy (s_name
, link_sec
->name
, namelen
);
3762 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
3763 stub_sec
= (*htab
->params
->add_stub_section
) (s_name
, link_sec
);
3764 if (stub_sec
== NULL
)
3766 group
->stub_sec
= stub_sec
;
3769 /* Enter this entry into the linker stub hash table. */
3770 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3772 if (stub_entry
== NULL
)
3774 /* xgettext:c-format */
3775 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3776 section
->owner
, stub_name
);
3780 stub_entry
->group
= group
;
3781 stub_entry
->stub_offset
= 0;
3785 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3786 not already done. */
3789 create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3791 asection
*got
, *relgot
;
3793 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
3795 if (!is_ppc64_elf (abfd
))
3801 && !_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
3804 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3805 | SEC_LINKER_CREATED
);
3807 got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3809 || !bfd_set_section_alignment (got
, 3))
3812 relgot
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got",
3813 flags
| SEC_READONLY
);
3815 || !bfd_set_section_alignment (relgot
, 3))
3818 ppc64_elf_tdata (abfd
)->got
= got
;
3819 ppc64_elf_tdata (abfd
)->relgot
= relgot
;
3823 /* Follow indirect and warning symbol links. */
3825 static inline struct bfd_link_hash_entry
*
3826 follow_link (struct bfd_link_hash_entry
*h
)
3828 while (h
->type
== bfd_link_hash_indirect
3829 || h
->type
== bfd_link_hash_warning
)
3834 static inline struct elf_link_hash_entry
*
3835 elf_follow_link (struct elf_link_hash_entry
*h
)
3837 return (struct elf_link_hash_entry
*) follow_link (&h
->root
);
3840 static inline struct ppc_link_hash_entry
*
3841 ppc_follow_link (struct ppc_link_hash_entry
*h
)
3843 return ppc_elf_hash_entry (elf_follow_link (&h
->elf
));
3846 /* Merge PLT info on FROM with that on TO. */
3849 move_plt_plist (struct ppc_link_hash_entry
*from
,
3850 struct ppc_link_hash_entry
*to
)
3852 if (from
->elf
.plt
.plist
!= NULL
)
3854 if (to
->elf
.plt
.plist
!= NULL
)
3856 struct plt_entry
**entp
;
3857 struct plt_entry
*ent
;
3859 for (entp
= &from
->elf
.plt
.plist
; (ent
= *entp
) != NULL
; )
3861 struct plt_entry
*dent
;
3863 for (dent
= to
->elf
.plt
.plist
; dent
!= NULL
; dent
= dent
->next
)
3864 if (dent
->addend
== ent
->addend
)
3866 dent
->plt
.refcount
+= ent
->plt
.refcount
;
3873 *entp
= to
->elf
.plt
.plist
;
3876 to
->elf
.plt
.plist
= from
->elf
.plt
.plist
;
3877 from
->elf
.plt
.plist
= NULL
;
3881 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3884 ppc64_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3885 struct elf_link_hash_entry
*dir
,
3886 struct elf_link_hash_entry
*ind
)
3888 struct ppc_link_hash_entry
*edir
, *eind
;
3890 edir
= ppc_elf_hash_entry (dir
);
3891 eind
= ppc_elf_hash_entry (ind
);
3893 edir
->is_func
|= eind
->is_func
;
3894 edir
->is_func_descriptor
|= eind
->is_func_descriptor
;
3895 edir
->tls_mask
|= eind
->tls_mask
;
3896 if (eind
->oh
!= NULL
)
3897 edir
->oh
= ppc_follow_link (eind
->oh
);
3899 if (edir
->elf
.versioned
!= versioned_hidden
)
3900 edir
->elf
.ref_dynamic
|= eind
->elf
.ref_dynamic
;
3901 edir
->elf
.ref_regular
|= eind
->elf
.ref_regular
;
3902 edir
->elf
.ref_regular_nonweak
|= eind
->elf
.ref_regular_nonweak
;
3903 edir
->elf
.non_got_ref
|= eind
->elf
.non_got_ref
;
3904 edir
->elf
.needs_plt
|= eind
->elf
.needs_plt
;
3905 edir
->elf
.pointer_equality_needed
|= eind
->elf
.pointer_equality_needed
;
3907 /* If we were called to copy over info for a weak sym, don't copy
3908 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
3909 in order to simplify readonly_dynrelocs and save a field in the
3910 symbol hash entry, but that means dyn_relocs can't be used in any
3911 tests about a specific symbol, or affect other symbol flags which
3913 if (eind
->elf
.root
.type
!= bfd_link_hash_indirect
)
3916 /* Copy over any dynamic relocs we may have on the indirect sym. */
3917 if (ind
->dyn_relocs
!= NULL
)
3919 if (dir
->dyn_relocs
!= NULL
)
3921 struct elf_dyn_relocs
**pp
;
3922 struct elf_dyn_relocs
*p
;
3924 /* Add reloc counts against the indirect sym to the direct sym
3925 list. Merge any entries against the same section. */
3926 for (pp
= &ind
->dyn_relocs
; (p
= *pp
) != NULL
; )
3928 struct elf_dyn_relocs
*q
;
3930 for (q
= dir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
3931 if (q
->sec
== p
->sec
)
3933 q
->pc_count
+= p
->pc_count
;
3934 q
->count
+= p
->count
;
3941 *pp
= dir
->dyn_relocs
;
3944 dir
->dyn_relocs
= ind
->dyn_relocs
;
3945 ind
->dyn_relocs
= NULL
;
3948 /* Copy over got entries that we may have already seen to the
3949 symbol which just became indirect. */
3950 if (eind
->elf
.got
.glist
!= NULL
)
3952 if (edir
->elf
.got
.glist
!= NULL
)
3954 struct got_entry
**entp
;
3955 struct got_entry
*ent
;
3957 for (entp
= &eind
->elf
.got
.glist
; (ent
= *entp
) != NULL
; )
3959 struct got_entry
*dent
;
3961 for (dent
= edir
->elf
.got
.glist
; dent
!= NULL
; dent
= dent
->next
)
3962 if (dent
->addend
== ent
->addend
3963 && dent
->owner
== ent
->owner
3964 && dent
->tls_type
== ent
->tls_type
)
3966 dent
->got
.refcount
+= ent
->got
.refcount
;
3973 *entp
= edir
->elf
.got
.glist
;
3976 edir
->elf
.got
.glist
= eind
->elf
.got
.glist
;
3977 eind
->elf
.got
.glist
= NULL
;
3980 /* And plt entries. */
3981 move_plt_plist (eind
, edir
);
3983 if (eind
->elf
.dynindx
!= -1)
3985 if (edir
->elf
.dynindx
!= -1)
3986 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
3987 edir
->elf
.dynstr_index
);
3988 edir
->elf
.dynindx
= eind
->elf
.dynindx
;
3989 edir
->elf
.dynstr_index
= eind
->elf
.dynstr_index
;
3990 eind
->elf
.dynindx
= -1;
3991 eind
->elf
.dynstr_index
= 0;
3995 /* Find the function descriptor hash entry from the given function code
3996 hash entry FH. Link the entries via their OH fields. */
3998 static struct ppc_link_hash_entry
*
3999 lookup_fdh (struct ppc_link_hash_entry
*fh
, struct ppc_link_hash_table
*htab
)
4001 struct ppc_link_hash_entry
*fdh
= fh
->oh
;
4005 const char *fd_name
= fh
->elf
.root
.root
.string
+ 1;
4007 fdh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, fd_name
,
4008 FALSE
, FALSE
, FALSE
));
4012 fdh
->is_func_descriptor
= 1;
4018 fdh
= ppc_follow_link (fdh
);
4019 fdh
->is_func_descriptor
= 1;
4024 /* Make a fake function descriptor sym for the undefined code sym FH. */
4026 static struct ppc_link_hash_entry
*
4027 make_fdh (struct bfd_link_info
*info
,
4028 struct ppc_link_hash_entry
*fh
)
4030 bfd
*abfd
= fh
->elf
.root
.u
.undef
.abfd
;
4031 struct bfd_link_hash_entry
*bh
= NULL
;
4032 struct ppc_link_hash_entry
*fdh
;
4033 flagword flags
= (fh
->elf
.root
.type
== bfd_link_hash_undefweak
4037 if (!_bfd_generic_link_add_one_symbol (info
, abfd
,
4038 fh
->elf
.root
.root
.string
+ 1,
4039 flags
, bfd_und_section_ptr
, 0,
4040 NULL
, FALSE
, FALSE
, &bh
))
4043 fdh
= (struct ppc_link_hash_entry
*) bh
;
4044 fdh
->elf
.non_elf
= 0;
4046 fdh
->is_func_descriptor
= 1;
4053 /* Fix function descriptor symbols defined in .opd sections to be
4057 ppc64_elf_add_symbol_hook (bfd
*ibfd
,
4058 struct bfd_link_info
*info
,
4059 Elf_Internal_Sym
*isym
,
4061 flagword
*flags ATTRIBUTE_UNUSED
,
4066 && strcmp ((*sec
)->name
, ".opd") == 0)
4070 if (!(ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
4071 || ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
))
4072 isym
->st_info
= ELF_ST_INFO (ELF_ST_BIND (isym
->st_info
), STT_FUNC
);
4074 /* If the symbol is a function defined in .opd, and the function
4075 code is in a discarded group, let it appear to be undefined. */
4076 if (!bfd_link_relocatable (info
)
4077 && (*sec
)->reloc_count
!= 0
4078 && opd_entry_value (*sec
, *value
, &code_sec
, NULL
,
4079 FALSE
) != (bfd_vma
) -1
4080 && discarded_section (code_sec
))
4082 *sec
= bfd_und_section_ptr
;
4083 isym
->st_shndx
= SHN_UNDEF
;
4086 else if (*sec
!= NULL
4087 && strcmp ((*sec
)->name
, ".toc") == 0
4088 && ELF_ST_TYPE (isym
->st_info
) == STT_OBJECT
)
4090 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4092 htab
->params
->object_in_toc
= 1;
4095 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4097 if (abiversion (ibfd
) == 0)
4098 set_abiversion (ibfd
, 2);
4099 else if (abiversion (ibfd
) == 1)
4101 _bfd_error_handler (_("symbol '%s' has invalid st_other"
4102 " for ABI version 1"), *name
);
4103 bfd_set_error (bfd_error_bad_value
);
4111 /* Merge non-visibility st_other attributes: local entry point. */
4114 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
4115 const Elf_Internal_Sym
*isym
,
4116 bfd_boolean definition
,
4117 bfd_boolean dynamic
)
4119 if (definition
&& (!dynamic
|| !h
->def_regular
))
4120 h
->other
= ((isym
->st_other
& ~ELF_ST_VISIBILITY (-1))
4121 | ELF_ST_VISIBILITY (h
->other
));
4124 /* Hook called on merging a symbol. We use this to clear "fake" since
4125 we now have a real symbol. */
4128 ppc64_elf_merge_symbol (struct elf_link_hash_entry
*h
,
4129 const Elf_Internal_Sym
*isym
,
4130 asection
**psec ATTRIBUTE_UNUSED
,
4131 bfd_boolean newdef ATTRIBUTE_UNUSED
,
4132 bfd_boolean olddef ATTRIBUTE_UNUSED
,
4133 bfd
*oldbfd ATTRIBUTE_UNUSED
,
4134 const asection
*oldsec ATTRIBUTE_UNUSED
)
4136 ppc_elf_hash_entry (h
)->fake
= 0;
4137 if ((STO_PPC64_LOCAL_MASK
& isym
->st_other
) != 0)
4138 ppc_elf_hash_entry (h
)->non_zero_localentry
= 1;
4142 /* This function makes an old ABI object reference to ".bar" cause the
4143 inclusion of a new ABI object archive that defines "bar".
4144 NAME is a symbol defined in an archive. Return a symbol in the hash
4145 table that might be satisfied by the archive symbols. */
4147 static struct elf_link_hash_entry
*
4148 ppc64_elf_archive_symbol_lookup (bfd
*abfd
,
4149 struct bfd_link_info
*info
,
4152 struct elf_link_hash_entry
*h
;
4156 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, name
);
4158 /* Don't return this sym if it is a fake function descriptor
4159 created by add_symbol_adjust. */
4160 && !ppc_elf_hash_entry (h
)->fake
)
4166 len
= strlen (name
);
4167 dot_name
= bfd_alloc (abfd
, len
+ 2);
4168 if (dot_name
== NULL
)
4169 return (struct elf_link_hash_entry
*) -1;
4171 memcpy (dot_name
+ 1, name
, len
+ 1);
4172 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, dot_name
);
4173 bfd_release (abfd
, dot_name
);
4177 if (strcmp (name
, "__tls_get_addr_opt") == 0)
4178 h
= _bfd_elf_archive_symbol_lookup (abfd
, info
, "__tls_get_addr_desc");
4182 /* This function satisfies all old ABI object references to ".bar" if a
4183 new ABI object defines "bar". Well, at least, undefined dot symbols
4184 are made weak. This stops later archive searches from including an
4185 object if we already have a function descriptor definition. It also
4186 prevents the linker complaining about undefined symbols.
4187 We also check and correct mismatched symbol visibility here. The
4188 most restrictive visibility of the function descriptor and the
4189 function entry symbol is used. */
4192 add_symbol_adjust (struct ppc_link_hash_entry
*eh
, struct bfd_link_info
*info
)
4194 struct ppc_link_hash_table
*htab
;
4195 struct ppc_link_hash_entry
*fdh
;
4197 if (eh
->elf
.root
.type
== bfd_link_hash_warning
)
4198 eh
= (struct ppc_link_hash_entry
*) eh
->elf
.root
.u
.i
.link
;
4200 if (eh
->elf
.root
.type
== bfd_link_hash_indirect
)
4203 if (eh
->elf
.root
.root
.string
[0] != '.')
4206 htab
= ppc_hash_table (info
);
4210 fdh
= lookup_fdh (eh
, htab
);
4212 && !bfd_link_relocatable (info
)
4213 && (eh
->elf
.root
.type
== bfd_link_hash_undefined
4214 || eh
->elf
.root
.type
== bfd_link_hash_undefweak
)
4215 && eh
->elf
.ref_regular
)
4217 /* Make an undefined function descriptor sym, in order to
4218 pull in an --as-needed shared lib. Archives are handled
4220 fdh
= make_fdh (info
, eh
);
4227 unsigned entry_vis
= ELF_ST_VISIBILITY (eh
->elf
.other
) - 1;
4228 unsigned descr_vis
= ELF_ST_VISIBILITY (fdh
->elf
.other
) - 1;
4230 /* Make both descriptor and entry symbol have the most
4231 constraining visibility of either symbol. */
4232 if (entry_vis
< descr_vis
)
4233 fdh
->elf
.other
+= entry_vis
- descr_vis
;
4234 else if (entry_vis
> descr_vis
)
4235 eh
->elf
.other
+= descr_vis
- entry_vis
;
4237 /* Propagate reference flags from entry symbol to function
4238 descriptor symbol. */
4239 fdh
->elf
.root
.non_ir_ref_regular
|= eh
->elf
.root
.non_ir_ref_regular
;
4240 fdh
->elf
.root
.non_ir_ref_dynamic
|= eh
->elf
.root
.non_ir_ref_dynamic
;
4241 fdh
->elf
.ref_regular
|= eh
->elf
.ref_regular
;
4242 fdh
->elf
.ref_regular_nonweak
|= eh
->elf
.ref_regular_nonweak
;
4244 if (!fdh
->elf
.forced_local
4245 && fdh
->elf
.dynindx
== -1
4246 && fdh
->elf
.versioned
!= versioned_hidden
4247 && (bfd_link_dll (info
)
4248 || fdh
->elf
.def_dynamic
4249 || fdh
->elf
.ref_dynamic
)
4250 && (eh
->elf
.ref_regular
4251 || eh
->elf
.def_regular
))
4253 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
4261 /* Set up opd section info and abiversion for IBFD, and process list
4262 of dot-symbols we made in link_hash_newfunc. */
4265 ppc64_elf_before_check_relocs (bfd
*ibfd
, struct bfd_link_info
*info
)
4267 struct ppc_link_hash_table
*htab
;
4268 struct ppc_link_hash_entry
**p
, *eh
;
4269 asection
*opd
= bfd_get_section_by_name (ibfd
, ".opd");
4271 if (opd
!= NULL
&& opd
->size
!= 0)
4273 BFD_ASSERT (ppc64_elf_section_data (opd
)->sec_type
== sec_normal
);
4274 ppc64_elf_section_data (opd
)->sec_type
= sec_opd
;
4276 if (abiversion (ibfd
) == 0)
4277 set_abiversion (ibfd
, 1);
4278 else if (abiversion (ibfd
) >= 2)
4280 /* xgettext:c-format */
4281 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
4282 ibfd
, abiversion (ibfd
));
4283 bfd_set_error (bfd_error_bad_value
);
4288 if (is_ppc64_elf (info
->output_bfd
))
4290 /* For input files without an explicit abiversion in e_flags
4291 we should have flagged any with symbol st_other bits set
4292 as ELFv1 and above flagged those with .opd as ELFv2.
4293 Set the output abiversion if not yet set, and for any input
4294 still ambiguous, take its abiversion from the output.
4295 Differences in ABI are reported later. */
4296 if (abiversion (info
->output_bfd
) == 0)
4297 set_abiversion (info
->output_bfd
, abiversion (ibfd
));
4298 else if (abiversion (ibfd
) == 0)
4299 set_abiversion (ibfd
, abiversion (info
->output_bfd
));
4302 htab
= ppc_hash_table (info
);
4306 if (opd
!= NULL
&& opd
->size
!= 0
4307 && (ibfd
->flags
& DYNAMIC
) == 0
4308 && (opd
->flags
& SEC_RELOC
) != 0
4309 && opd
->reloc_count
!= 0
4310 && !bfd_is_abs_section (opd
->output_section
)
4311 && info
->gc_sections
)
4313 /* Garbage collection needs some extra help with .opd sections.
4314 We don't want to necessarily keep everything referenced by
4315 relocs in .opd, as that would keep all functions. Instead,
4316 if we reference an .opd symbol (a function descriptor), we
4317 want to keep the function code symbol's section. This is
4318 easy for global symbols, but for local syms we need to keep
4319 information about the associated function section. */
4321 asection
**opd_sym_map
;
4322 Elf_Internal_Shdr
*symtab_hdr
;
4323 Elf_Internal_Rela
*relocs
, *rel_end
, *rel
;
4325 amt
= OPD_NDX (opd
->size
) * sizeof (*opd_sym_map
);
4326 opd_sym_map
= bfd_zalloc (ibfd
, amt
);
4327 if (opd_sym_map
== NULL
)
4329 ppc64_elf_section_data (opd
)->u
.opd
.func_sec
= opd_sym_map
;
4330 relocs
= _bfd_elf_link_read_relocs (ibfd
, opd
, NULL
, NULL
,
4334 symtab_hdr
= &elf_symtab_hdr (ibfd
);
4335 rel_end
= relocs
+ opd
->reloc_count
- 1;
4336 for (rel
= relocs
; rel
< rel_end
; rel
++)
4338 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
4339 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
4341 if (r_type
== R_PPC64_ADDR64
4342 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
4343 && r_symndx
< symtab_hdr
->sh_info
)
4345 Elf_Internal_Sym
*isym
;
4348 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
, ibfd
, r_symndx
);
4351 if (elf_section_data (opd
)->relocs
!= relocs
)
4356 s
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
4357 if (s
!= NULL
&& s
!= opd
)
4358 opd_sym_map
[OPD_NDX (rel
->r_offset
)] = s
;
4361 if (elf_section_data (opd
)->relocs
!= relocs
)
4365 p
= &htab
->dot_syms
;
4366 while ((eh
= *p
) != NULL
)
4369 if (&eh
->elf
== htab
->elf
.hgot
)
4371 else if (htab
->elf
.hgot
== NULL
4372 && strcmp (eh
->elf
.root
.root
.string
, ".TOC.") == 0)
4373 htab
->elf
.hgot
= &eh
->elf
;
4374 else if (abiversion (ibfd
) <= 1)
4376 htab
->need_func_desc_adj
= 1;
4377 if (!add_symbol_adjust (eh
, info
))
4380 p
= &eh
->u
.next_dot_sym
;
4385 /* Undo hash table changes when an --as-needed input file is determined
4386 not to be needed. */
4389 ppc64_elf_notice_as_needed (bfd
*ibfd
,
4390 struct bfd_link_info
*info
,
4391 enum notice_asneeded_action act
)
4393 if (act
== notice_not_needed
)
4395 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
4400 htab
->dot_syms
= NULL
;
4402 return _bfd_elf_notice_as_needed (ibfd
, info
, act
);
4405 /* If --just-symbols against a final linked binary, then assume we need
4406 toc adjusting stubs when calling functions defined there. */
4409 ppc64_elf_link_just_syms (asection
*sec
, struct bfd_link_info
*info
)
4411 if ((sec
->flags
& SEC_CODE
) != 0
4412 && (sec
->owner
->flags
& (EXEC_P
| DYNAMIC
)) != 0
4413 && is_ppc64_elf (sec
->owner
))
4415 if (abiversion (sec
->owner
) >= 2
4416 || bfd_get_section_by_name (sec
->owner
, ".opd") != NULL
)
4417 sec
->has_toc_reloc
= 1;
4419 _bfd_elf_link_just_syms (sec
, info
);
4422 static struct plt_entry
**
4423 update_local_sym_info (bfd
*abfd
, Elf_Internal_Shdr
*symtab_hdr
,
4424 unsigned long r_symndx
, bfd_vma r_addend
, int tls_type
)
4426 struct got_entry
**local_got_ents
= elf_local_got_ents (abfd
);
4427 struct plt_entry
**local_plt
;
4428 unsigned char *local_got_tls_masks
;
4430 if (local_got_ents
== NULL
)
4432 bfd_size_type size
= symtab_hdr
->sh_info
;
4434 size
*= (sizeof (*local_got_ents
)
4435 + sizeof (*local_plt
)
4436 + sizeof (*local_got_tls_masks
));
4437 local_got_ents
= bfd_zalloc (abfd
, size
);
4438 if (local_got_ents
== NULL
)
4440 elf_local_got_ents (abfd
) = local_got_ents
;
4443 if ((tls_type
& (NON_GOT
| TLS_EXPLICIT
)) == 0)
4445 struct got_entry
*ent
;
4447 for (ent
= local_got_ents
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
4448 if (ent
->addend
== r_addend
4449 && ent
->owner
== abfd
4450 && ent
->tls_type
== tls_type
)
4454 size_t amt
= sizeof (*ent
);
4455 ent
= bfd_alloc (abfd
, amt
);
4458 ent
->next
= local_got_ents
[r_symndx
];
4459 ent
->addend
= r_addend
;
4461 ent
->tls_type
= tls_type
;
4462 ent
->is_indirect
= FALSE
;
4463 ent
->got
.refcount
= 0;
4464 local_got_ents
[r_symndx
] = ent
;
4466 ent
->got
.refcount
+= 1;
4469 local_plt
= (struct plt_entry
**) (local_got_ents
+ symtab_hdr
->sh_info
);
4470 local_got_tls_masks
= (unsigned char *) (local_plt
+ symtab_hdr
->sh_info
);
4471 local_got_tls_masks
[r_symndx
] |= tls_type
& 0xff;
4473 return local_plt
+ r_symndx
;
4477 update_plt_info (bfd
*abfd
, struct plt_entry
**plist
, bfd_vma addend
)
4479 struct plt_entry
*ent
;
4481 for (ent
= *plist
; ent
!= NULL
; ent
= ent
->next
)
4482 if (ent
->addend
== addend
)
4486 size_t amt
= sizeof (*ent
);
4487 ent
= bfd_alloc (abfd
, amt
);
4491 ent
->addend
= addend
;
4492 ent
->plt
.refcount
= 0;
4495 ent
->plt
.refcount
+= 1;
4500 is_branch_reloc (enum elf_ppc64_reloc_type r_type
)
4502 return (r_type
== R_PPC64_REL24
4503 || r_type
== R_PPC64_REL24_NOTOC
4504 || r_type
== R_PPC64_REL14
4505 || r_type
== R_PPC64_REL14_BRTAKEN
4506 || r_type
== R_PPC64_REL14_BRNTAKEN
4507 || r_type
== R_PPC64_ADDR24
4508 || r_type
== R_PPC64_ADDR14
4509 || r_type
== R_PPC64_ADDR14_BRTAKEN
4510 || r_type
== R_PPC64_ADDR14_BRNTAKEN
4511 || r_type
== R_PPC64_PLTCALL
4512 || r_type
== R_PPC64_PLTCALL_NOTOC
);
4515 /* Relocs on inline plt call sequence insns prior to the call. */
4518 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type
)
4520 return (r_type
== R_PPC64_PLT16_HA
4521 || r_type
== R_PPC64_PLT16_HI
4522 || r_type
== R_PPC64_PLT16_LO
4523 || r_type
== R_PPC64_PLT16_LO_DS
4524 || r_type
== R_PPC64_PLT_PCREL34
4525 || r_type
== R_PPC64_PLT_PCREL34_NOTOC
4526 || r_type
== R_PPC64_PLTSEQ
4527 || r_type
== R_PPC64_PLTSEQ_NOTOC
);
4530 /* Look through the relocs for a section during the first phase, and
4531 calculate needed space in the global offset table, procedure
4532 linkage table, and dynamic reloc sections. */
4535 ppc64_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4536 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4538 struct ppc_link_hash_table
*htab
;
4539 Elf_Internal_Shdr
*symtab_hdr
;
4540 struct elf_link_hash_entry
**sym_hashes
;
4541 const Elf_Internal_Rela
*rel
;
4542 const Elf_Internal_Rela
*rel_end
;
4544 struct elf_link_hash_entry
*tga
, *dottga
;
4547 if (bfd_link_relocatable (info
))
4550 BFD_ASSERT (is_ppc64_elf (abfd
));
4552 htab
= ppc_hash_table (info
);
4556 tga
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
4557 FALSE
, FALSE
, TRUE
);
4558 dottga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
4559 FALSE
, FALSE
, TRUE
);
4560 symtab_hdr
= &elf_symtab_hdr (abfd
);
4561 sym_hashes
= elf_sym_hashes (abfd
);
4563 is_opd
= ppc64_elf_section_data (sec
)->sec_type
== sec_opd
;
4564 rel_end
= relocs
+ sec
->reloc_count
;
4565 for (rel
= relocs
; rel
< rel_end
; rel
++)
4567 unsigned long r_symndx
;
4568 struct elf_link_hash_entry
*h
;
4569 enum elf_ppc64_reloc_type r_type
;
4571 struct _ppc64_elf_section_data
*ppc64_sec
;
4572 struct plt_entry
**ifunc
, **plt_list
;
4574 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4575 if (r_symndx
< symtab_hdr
->sh_info
)
4579 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4580 h
= elf_follow_link (h
);
4582 if (h
== htab
->elf
.hgot
)
4583 sec
->has_toc_reloc
= 1;
4586 r_type
= ELF64_R_TYPE (rel
->r_info
);
4590 case R_PPC64_D34_LO
:
4591 case R_PPC64_D34_HI30
:
4592 case R_PPC64_D34_HA30
:
4594 case R_PPC64_TPREL34
:
4595 case R_PPC64_DTPREL34
:
4596 case R_PPC64_PCREL34
:
4597 case R_PPC64_GOT_PCREL34
:
4598 case R_PPC64_GOT_TLSGD_PCREL34
:
4599 case R_PPC64_GOT_TLSLD_PCREL34
:
4600 case R_PPC64_GOT_TPREL_PCREL34
:
4601 case R_PPC64_GOT_DTPREL_PCREL34
:
4602 case R_PPC64_PLT_PCREL34
:
4603 case R_PPC64_PLT_PCREL34_NOTOC
:
4604 case R_PPC64_PCREL28
:
4605 htab
->power10_stubs
= 1;
4613 case R_PPC64_PLT16_HA
:
4614 case R_PPC64_GOT_TLSLD16_HA
:
4615 case R_PPC64_GOT_TLSGD16_HA
:
4616 case R_PPC64_GOT_TPREL16_HA
:
4617 case R_PPC64_GOT_DTPREL16_HA
:
4618 case R_PPC64_GOT16_HA
:
4619 case R_PPC64_TOC16_HA
:
4620 case R_PPC64_PLT16_LO
:
4621 case R_PPC64_PLT16_LO_DS
:
4622 case R_PPC64_GOT_TLSLD16_LO
:
4623 case R_PPC64_GOT_TLSGD16_LO
:
4624 case R_PPC64_GOT_TPREL16_LO_DS
:
4625 case R_PPC64_GOT_DTPREL16_LO_DS
:
4626 case R_PPC64_GOT16_LO
:
4627 case R_PPC64_GOT16_LO_DS
:
4628 case R_PPC64_TOC16_LO
:
4629 case R_PPC64_TOC16_LO_DS
:
4630 case R_PPC64_GOT_PCREL34
:
4631 ppc64_elf_tdata (abfd
)->has_optrel
= 1;
4632 ppc64_elf_section_data (sec
)->has_optrel
= 1;
4641 if (h
->type
== STT_GNU_IFUNC
)
4644 ifunc
= &h
->plt
.plist
;
4649 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4654 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4656 ifunc
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4658 NON_GOT
| PLT_IFUNC
);
4669 /* These special tls relocs tie a call to __tls_get_addr with
4670 its parameter symbol. */
4672 ppc_elf_hash_entry (h
)->tls_mask
|= TLS_TLS
| TLS_MARK
;
4674 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4676 NON_GOT
| TLS_TLS
| TLS_MARK
))
4678 sec
->has_tls_reloc
= 1;
4681 case R_PPC64_GOT_TLSLD16
:
4682 case R_PPC64_GOT_TLSLD16_LO
:
4683 case R_PPC64_GOT_TLSLD16_HI
:
4684 case R_PPC64_GOT_TLSLD16_HA
:
4685 case R_PPC64_GOT_TLSLD_PCREL34
:
4686 tls_type
= TLS_TLS
| TLS_LD
;
4689 case R_PPC64_GOT_TLSGD16
:
4690 case R_PPC64_GOT_TLSGD16_LO
:
4691 case R_PPC64_GOT_TLSGD16_HI
:
4692 case R_PPC64_GOT_TLSGD16_HA
:
4693 case R_PPC64_GOT_TLSGD_PCREL34
:
4694 tls_type
= TLS_TLS
| TLS_GD
;
4697 case R_PPC64_GOT_TPREL16_DS
:
4698 case R_PPC64_GOT_TPREL16_LO_DS
:
4699 case R_PPC64_GOT_TPREL16_HI
:
4700 case R_PPC64_GOT_TPREL16_HA
:
4701 case R_PPC64_GOT_TPREL_PCREL34
:
4702 if (bfd_link_dll (info
))
4703 info
->flags
|= DF_STATIC_TLS
;
4704 tls_type
= TLS_TLS
| TLS_TPREL
;
4707 case R_PPC64_GOT_DTPREL16_DS
:
4708 case R_PPC64_GOT_DTPREL16_LO_DS
:
4709 case R_PPC64_GOT_DTPREL16_HI
:
4710 case R_PPC64_GOT_DTPREL16_HA
:
4711 case R_PPC64_GOT_DTPREL_PCREL34
:
4712 tls_type
= TLS_TLS
| TLS_DTPREL
;
4714 sec
->has_tls_reloc
= 1;
4718 case R_PPC64_GOT16_LO
:
4719 case R_PPC64_GOT16_HI
:
4720 case R_PPC64_GOT16_HA
:
4721 case R_PPC64_GOT16_DS
:
4722 case R_PPC64_GOT16_LO_DS
:
4723 case R_PPC64_GOT_PCREL34
:
4725 /* This symbol requires a global offset table entry. */
4726 sec
->has_toc_reloc
= 1;
4727 if (r_type
== R_PPC64_GOT_TLSLD16
4728 || r_type
== R_PPC64_GOT_TLSGD16
4729 || r_type
== R_PPC64_GOT_TPREL16_DS
4730 || r_type
== R_PPC64_GOT_DTPREL16_DS
4731 || r_type
== R_PPC64_GOT16
4732 || r_type
== R_PPC64_GOT16_DS
)
4734 htab
->do_multi_toc
= 1;
4735 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4738 if (ppc64_elf_tdata (abfd
)->got
== NULL
4739 && !create_got_section (abfd
, info
))
4744 struct ppc_link_hash_entry
*eh
;
4745 struct got_entry
*ent
;
4747 eh
= ppc_elf_hash_entry (h
);
4748 for (ent
= eh
->elf
.got
.glist
; ent
!= NULL
; ent
= ent
->next
)
4749 if (ent
->addend
== rel
->r_addend
4750 && ent
->owner
== abfd
4751 && ent
->tls_type
== tls_type
)
4755 size_t amt
= sizeof (*ent
);
4756 ent
= bfd_alloc (abfd
, amt
);
4759 ent
->next
= eh
->elf
.got
.glist
;
4760 ent
->addend
= rel
->r_addend
;
4762 ent
->tls_type
= tls_type
;
4763 ent
->is_indirect
= FALSE
;
4764 ent
->got
.refcount
= 0;
4765 eh
->elf
.got
.glist
= ent
;
4767 ent
->got
.refcount
+= 1;
4768 eh
->tls_mask
|= tls_type
;
4771 /* This is a global offset table entry for a local symbol. */
4772 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4773 rel
->r_addend
, tls_type
))
4777 case R_PPC64_PLT16_HA
:
4778 case R_PPC64_PLT16_HI
:
4779 case R_PPC64_PLT16_LO
:
4780 case R_PPC64_PLT16_LO_DS
:
4781 case R_PPC64_PLT_PCREL34
:
4782 case R_PPC64_PLT_PCREL34_NOTOC
:
4785 /* This symbol requires a procedure linkage table entry. */
4790 if (h
->root
.root
.string
[0] == '.'
4791 && h
->root
.root
.string
[1] != '\0')
4792 ppc_elf_hash_entry (h
)->is_func
= 1;
4793 ppc_elf_hash_entry (h
)->tls_mask
|= PLT_KEEP
;
4794 plt_list
= &h
->plt
.plist
;
4796 if (plt_list
== NULL
)
4797 plt_list
= update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
4799 NON_GOT
| PLT_KEEP
);
4800 if (!update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4804 /* The following relocations don't need to propagate the
4805 relocation if linking a shared object since they are
4806 section relative. */
4807 case R_PPC64_SECTOFF
:
4808 case R_PPC64_SECTOFF_LO
:
4809 case R_PPC64_SECTOFF_HI
:
4810 case R_PPC64_SECTOFF_HA
:
4811 case R_PPC64_SECTOFF_DS
:
4812 case R_PPC64_SECTOFF_LO_DS
:
4813 case R_PPC64_DTPREL16
:
4814 case R_PPC64_DTPREL16_LO
:
4815 case R_PPC64_DTPREL16_HI
:
4816 case R_PPC64_DTPREL16_HA
:
4817 case R_PPC64_DTPREL16_DS
:
4818 case R_PPC64_DTPREL16_LO_DS
:
4819 case R_PPC64_DTPREL16_HIGH
:
4820 case R_PPC64_DTPREL16_HIGHA
:
4821 case R_PPC64_DTPREL16_HIGHER
:
4822 case R_PPC64_DTPREL16_HIGHERA
:
4823 case R_PPC64_DTPREL16_HIGHEST
:
4824 case R_PPC64_DTPREL16_HIGHESTA
:
4829 case R_PPC64_REL16_LO
:
4830 case R_PPC64_REL16_HI
:
4831 case R_PPC64_REL16_HA
:
4832 case R_PPC64_REL16_HIGH
:
4833 case R_PPC64_REL16_HIGHA
:
4834 case R_PPC64_REL16_HIGHER
:
4835 case R_PPC64_REL16_HIGHERA
:
4836 case R_PPC64_REL16_HIGHEST
:
4837 case R_PPC64_REL16_HIGHESTA
:
4838 case R_PPC64_REL16_HIGHER34
:
4839 case R_PPC64_REL16_HIGHERA34
:
4840 case R_PPC64_REL16_HIGHEST34
:
4841 case R_PPC64_REL16_HIGHESTA34
:
4842 case R_PPC64_REL16DX_HA
:
4845 /* Not supported as a dynamic relocation. */
4846 case R_PPC64_ADDR64_LOCAL
:
4847 if (bfd_link_pic (info
))
4849 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
4851 /* xgettext:c-format */
4852 info
->callbacks
->einfo (_("%H: %s reloc unsupported "
4853 "in shared libraries and PIEs\n"),
4854 abfd
, sec
, rel
->r_offset
,
4855 ppc64_elf_howto_table
[r_type
]->name
);
4856 bfd_set_error (bfd_error_bad_value
);
4862 case R_PPC64_TOC16_DS
:
4863 htab
->do_multi_toc
= 1;
4864 ppc64_elf_tdata (abfd
)->has_small_toc_reloc
= 1;
4866 case R_PPC64_TOC16_LO
:
4867 case R_PPC64_TOC16_HI
:
4868 case R_PPC64_TOC16_HA
:
4869 case R_PPC64_TOC16_LO_DS
:
4870 sec
->has_toc_reloc
= 1;
4871 if (h
!= NULL
&& bfd_link_executable (info
))
4873 /* We may need a copy reloc. */
4875 /* Strongly prefer a copy reloc over a dynamic reloc.
4876 glibc ld.so as of 2019-08 will error out if one of
4877 these relocations is emitted. */
4887 /* This relocation describes the C++ object vtable hierarchy.
4888 Reconstruct it for later use during GC. */
4889 case R_PPC64_GNU_VTINHERIT
:
4890 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4894 /* This relocation describes which C++ vtable entries are actually
4895 used. Record for later use during GC. */
4896 case R_PPC64_GNU_VTENTRY
:
4897 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4902 case R_PPC64_REL14_BRTAKEN
:
4903 case R_PPC64_REL14_BRNTAKEN
:
4905 asection
*dest
= NULL
;
4907 /* Heuristic: If jumping outside our section, chances are
4908 we are going to need a stub. */
4911 /* If the sym is weak it may be overridden later, so
4912 don't assume we know where a weak sym lives. */
4913 if (h
->root
.type
== bfd_link_hash_defined
)
4914 dest
= h
->root
.u
.def
.section
;
4918 Elf_Internal_Sym
*isym
;
4920 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
4925 dest
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4929 ppc64_elf_section_data (sec
)->has_14bit_branch
= 1;
4933 case R_PPC64_PLTCALL
:
4934 case R_PPC64_PLTCALL_NOTOC
:
4935 ppc64_elf_section_data (sec
)->has_pltcall
= 1;
4939 case R_PPC64_REL24_NOTOC
:
4945 if (h
->root
.root
.string
[0] == '.'
4946 && h
->root
.root
.string
[1] != '\0')
4947 ppc_elf_hash_entry (h
)->is_func
= 1;
4949 if (h
== tga
|| h
== dottga
)
4951 sec
->has_tls_reloc
= 1;
4953 && (ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSGD
4954 || ELF64_R_TYPE (rel
[-1].r_info
) == R_PPC64_TLSLD
))
4955 /* We have a new-style __tls_get_addr call with
4959 /* Mark this section as having an old-style call. */
4960 sec
->nomark_tls_get_addr
= 1;
4962 plt_list
= &h
->plt
.plist
;
4965 /* We may need a .plt entry if the function this reloc
4966 refers to is in a shared lib. */
4968 && !update_plt_info (abfd
, plt_list
, rel
->r_addend
))
4972 case R_PPC64_ADDR14
:
4973 case R_PPC64_ADDR14_BRNTAKEN
:
4974 case R_PPC64_ADDR14_BRTAKEN
:
4975 case R_PPC64_ADDR24
:
4978 case R_PPC64_TPREL64
:
4979 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_TPREL
;
4980 if (bfd_link_dll (info
))
4981 info
->flags
|= DF_STATIC_TLS
;
4984 case R_PPC64_DTPMOD64
:
4985 if (rel
+ 1 < rel_end
4986 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
4987 && rel
[1].r_offset
== rel
->r_offset
+ 8)
4988 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_GD
;
4990 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_LD
;
4993 case R_PPC64_DTPREL64
:
4994 tls_type
= TLS_EXPLICIT
| TLS_TLS
| TLS_DTPREL
;
4996 && rel
[-1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPMOD64
)
4997 && rel
[-1].r_offset
== rel
->r_offset
- 8)
4998 /* This is the second reloc of a dtpmod, dtprel pair.
4999 Don't mark with TLS_DTPREL. */
5003 sec
->has_tls_reloc
= 1;
5005 ppc_elf_hash_entry (h
)->tls_mask
|= tls_type
& 0xff;
5007 if (!update_local_sym_info (abfd
, symtab_hdr
, r_symndx
,
5008 rel
->r_addend
, tls_type
))
5011 ppc64_sec
= ppc64_elf_section_data (sec
);
5012 if (ppc64_sec
->sec_type
!= sec_toc
)
5016 /* One extra to simplify get_tls_mask. */
5017 amt
= sec
->size
* sizeof (unsigned) / 8 + sizeof (unsigned);
5018 ppc64_sec
->u
.toc
.symndx
= bfd_zalloc (abfd
, amt
);
5019 if (ppc64_sec
->u
.toc
.symndx
== NULL
)
5021 amt
= sec
->size
* sizeof (bfd_vma
) / 8;
5022 ppc64_sec
->u
.toc
.add
= bfd_zalloc (abfd
, amt
);
5023 if (ppc64_sec
->u
.toc
.add
== NULL
)
5025 BFD_ASSERT (ppc64_sec
->sec_type
== sec_normal
);
5026 ppc64_sec
->sec_type
= sec_toc
;
5028 BFD_ASSERT (rel
->r_offset
% 8 == 0);
5029 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8] = r_symndx
;
5030 ppc64_sec
->u
.toc
.add
[rel
->r_offset
/ 8] = rel
->r_addend
;
5032 /* Mark the second slot of a GD or LD entry.
5033 -1 to indicate GD and -2 to indicate LD. */
5034 if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_GD
))
5035 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -1;
5036 else if (tls_type
== (TLS_EXPLICIT
| TLS_TLS
| TLS_LD
))
5037 ppc64_sec
->u
.toc
.symndx
[rel
->r_offset
/ 8 + 1] = -2;
5040 case R_PPC64_TPREL16
:
5041 case R_PPC64_TPREL16_LO
:
5042 case R_PPC64_TPREL16_HI
:
5043 case R_PPC64_TPREL16_HA
:
5044 case R_PPC64_TPREL16_DS
:
5045 case R_PPC64_TPREL16_LO_DS
:
5046 case R_PPC64_TPREL16_HIGH
:
5047 case R_PPC64_TPREL16_HIGHA
:
5048 case R_PPC64_TPREL16_HIGHER
:
5049 case R_PPC64_TPREL16_HIGHERA
:
5050 case R_PPC64_TPREL16_HIGHEST
:
5051 case R_PPC64_TPREL16_HIGHESTA
:
5052 case R_PPC64_TPREL34
:
5053 if (bfd_link_dll (info
))
5054 info
->flags
|= DF_STATIC_TLS
;
5057 case R_PPC64_ADDR64
:
5059 && rel
+ 1 < rel_end
5060 && ELF64_R_TYPE ((rel
+ 1)->r_info
) == R_PPC64_TOC
)
5063 ppc_elf_hash_entry (h
)->is_func
= 1;
5067 case R_PPC64_ADDR16
:
5068 case R_PPC64_ADDR16_DS
:
5069 case R_PPC64_ADDR16_HA
:
5070 case R_PPC64_ADDR16_HI
:
5071 case R_PPC64_ADDR16_HIGH
:
5072 case R_PPC64_ADDR16_HIGHA
:
5073 case R_PPC64_ADDR16_HIGHER
:
5074 case R_PPC64_ADDR16_HIGHERA
:
5075 case R_PPC64_ADDR16_HIGHEST
:
5076 case R_PPC64_ADDR16_HIGHESTA
:
5077 case R_PPC64_ADDR16_LO
:
5078 case R_PPC64_ADDR16_LO_DS
:
5080 case R_PPC64_D34_LO
:
5081 case R_PPC64_D34_HI30
:
5082 case R_PPC64_D34_HA30
:
5083 case R_PPC64_ADDR16_HIGHER34
:
5084 case R_PPC64_ADDR16_HIGHERA34
:
5085 case R_PPC64_ADDR16_HIGHEST34
:
5086 case R_PPC64_ADDR16_HIGHESTA34
:
5088 if (h
!= NULL
&& !bfd_link_pic (info
) && abiversion (abfd
) != 1
5089 && rel
->r_addend
== 0)
5091 /* We may need a .plt entry if this reloc refers to a
5092 function in a shared lib. */
5093 if (!update_plt_info (abfd
, &h
->plt
.plist
, 0))
5095 h
->pointer_equality_needed
= 1;
5102 case R_PPC64_ADDR32
:
5103 case R_PPC64_UADDR16
:
5104 case R_PPC64_UADDR32
:
5105 case R_PPC64_UADDR64
:
5107 if (h
!= NULL
&& bfd_link_executable (info
))
5108 /* We may need a copy reloc. */
5111 /* Don't propagate .opd relocs. */
5112 if (NO_OPD_RELOCS
&& is_opd
)
5115 /* If we are creating a shared library, and this is a reloc
5116 against a global symbol, or a non PC relative reloc
5117 against a local symbol, then we need to copy the reloc
5118 into the shared library. However, if we are linking with
5119 -Bsymbolic, we do not need to copy a reloc against a
5120 global symbol which is defined in an object we are
5121 including in the link (i.e., DEF_REGULAR is set). At
5122 this point we have not seen all the input files, so it is
5123 possible that DEF_REGULAR is not set now but will be set
5124 later (it is never cleared). In case of a weak definition,
5125 DEF_REGULAR may be cleared later by a strong definition in
5126 a shared library. We account for that possibility below by
5127 storing information in the dyn_relocs field of the hash
5128 table entry. A similar situation occurs when creating
5129 shared libraries and symbol visibility changes render the
5132 If on the other hand, we are creating an executable, we
5133 may need to keep relocations for symbols satisfied by a
5134 dynamic library if we manage to avoid copy relocs for the
5138 && (h
->root
.type
== bfd_link_hash_defweak
5139 || !h
->def_regular
))
5141 && !bfd_link_executable (info
)
5142 && !SYMBOLIC_BIND (info
, h
))
5143 || (bfd_link_pic (info
)
5144 && must_be_dyn_reloc (info
, r_type
))
5145 || (!bfd_link_pic (info
)
5148 /* We must copy these reloc types into the output file.
5149 Create a reloc section in dynobj and make room for
5153 sreloc
= _bfd_elf_make_dynamic_reloc_section
5154 (sec
, htab
->elf
.dynobj
, 3, abfd
, /*rela?*/ TRUE
);
5160 /* If this is a global symbol, we count the number of
5161 relocations we need for this symbol. */
5164 struct elf_dyn_relocs
*p
;
5165 struct elf_dyn_relocs
**head
;
5167 head
= &h
->dyn_relocs
;
5169 if (p
== NULL
|| p
->sec
!= sec
)
5171 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5181 if (!must_be_dyn_reloc (info
, r_type
))
5186 /* Track dynamic relocs needed for local syms too.
5187 We really need local syms available to do this
5189 struct ppc_dyn_relocs
*p
;
5190 struct ppc_dyn_relocs
**head
;
5191 bfd_boolean is_ifunc
;
5194 Elf_Internal_Sym
*isym
;
5196 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
5201 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5205 vpp
= &elf_section_data (s
)->local_dynrel
;
5206 head
= (struct ppc_dyn_relocs
**) vpp
;
5207 is_ifunc
= ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
;
5209 if (p
!= NULL
&& p
->sec
== sec
&& p
->ifunc
!= is_ifunc
)
5211 if (p
== NULL
|| p
->sec
!= sec
|| p
->ifunc
!= is_ifunc
)
5213 p
= bfd_alloc (htab
->elf
.dynobj
, sizeof *p
);
5219 p
->ifunc
= is_ifunc
;
5235 /* Merge backend specific data from an object file to the output
5236 object file when linking. */
5239 ppc64_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
5241 bfd
*obfd
= info
->output_bfd
;
5242 unsigned long iflags
, oflags
;
5244 if ((ibfd
->flags
& BFD_LINKER_CREATED
) != 0)
5247 if (!is_ppc64_elf (ibfd
) || !is_ppc64_elf (obfd
))
5250 if (!_bfd_generic_verify_endian_match (ibfd
, info
))
5253 iflags
= elf_elfheader (ibfd
)->e_flags
;
5254 oflags
= elf_elfheader (obfd
)->e_flags
;
5256 if (iflags
& ~EF_PPC64_ABI
)
5259 /* xgettext:c-format */
5260 (_("%pB uses unknown e_flags 0x%lx"), ibfd
, iflags
);
5261 bfd_set_error (bfd_error_bad_value
);
5264 else if (iflags
!= oflags
&& iflags
!= 0)
5267 /* xgettext:c-format */
5268 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
5269 ibfd
, iflags
, oflags
);
5270 bfd_set_error (bfd_error_bad_value
);
5274 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd
, info
))
5277 /* Merge Tag_compatibility attributes and any common GNU ones. */
5278 return _bfd_elf_merge_object_attributes (ibfd
, info
);
5282 ppc64_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
5284 /* Print normal ELF private data. */
5285 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5287 if (elf_elfheader (abfd
)->e_flags
!= 0)
5291 fprintf (file
, _("private flags = 0x%lx:"),
5292 elf_elfheader (abfd
)->e_flags
);
5294 if ((elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
) != 0)
5295 fprintf (file
, _(" [abiv%ld]"),
5296 elf_elfheader (abfd
)->e_flags
& EF_PPC64_ABI
);
5303 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5304 of the code entry point, and its section, which must be in the same
5305 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5308 opd_entry_value (asection
*opd_sec
,
5310 asection
**code_sec
,
5312 bfd_boolean in_code_sec
)
5314 bfd
*opd_bfd
= opd_sec
->owner
;
5315 Elf_Internal_Rela
*relocs
;
5316 Elf_Internal_Rela
*lo
, *hi
, *look
;
5319 /* No relocs implies we are linking a --just-symbols object, or looking
5320 at a final linked executable with addr2line or somesuch. */
5321 if (opd_sec
->reloc_count
== 0)
5323 bfd_byte
*contents
= ppc64_elf_tdata (opd_bfd
)->opd
.contents
;
5325 if (contents
== NULL
)
5327 if (!bfd_malloc_and_get_section (opd_bfd
, opd_sec
, &contents
))
5328 return (bfd_vma
) -1;
5329 ppc64_elf_tdata (opd_bfd
)->opd
.contents
= contents
;
5332 /* PR 17512: file: 64b9dfbb. */
5333 if (offset
+ 7 >= opd_sec
->size
|| offset
+ 7 < offset
)
5334 return (bfd_vma
) -1;
5336 val
= bfd_get_64 (opd_bfd
, contents
+ offset
);
5337 if (code_sec
!= NULL
)
5339 asection
*sec
, *likely
= NULL
;
5345 && val
< sec
->vma
+ sec
->size
)
5351 for (sec
= opd_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5353 && (sec
->flags
& SEC_LOAD
) != 0
5354 && (sec
->flags
& SEC_ALLOC
) != 0)
5359 if (code_off
!= NULL
)
5360 *code_off
= val
- likely
->vma
;
5366 BFD_ASSERT (is_ppc64_elf (opd_bfd
));
5368 relocs
= ppc64_elf_tdata (opd_bfd
)->opd
.relocs
;
5370 relocs
= _bfd_elf_link_read_relocs (opd_bfd
, opd_sec
, NULL
, NULL
, TRUE
);
5371 /* PR 17512: file: df8e1fd6. */
5373 return (bfd_vma
) -1;
5375 /* Go find the opd reloc at the sym address. */
5377 hi
= lo
+ opd_sec
->reloc_count
- 1; /* ignore last reloc */
5381 look
= lo
+ (hi
- lo
) / 2;
5382 if (look
->r_offset
< offset
)
5384 else if (look
->r_offset
> offset
)
5388 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (opd_bfd
);
5390 if (ELF64_R_TYPE (look
->r_info
) == R_PPC64_ADDR64
5391 && ELF64_R_TYPE ((look
+ 1)->r_info
) == R_PPC64_TOC
)
5393 unsigned long symndx
= ELF64_R_SYM (look
->r_info
);
5394 asection
*sec
= NULL
;
5396 if (symndx
>= symtab_hdr
->sh_info
5397 && elf_sym_hashes (opd_bfd
) != NULL
)
5399 struct elf_link_hash_entry
**sym_hashes
;
5400 struct elf_link_hash_entry
*rh
;
5402 sym_hashes
= elf_sym_hashes (opd_bfd
);
5403 rh
= sym_hashes
[symndx
- symtab_hdr
->sh_info
];
5406 rh
= elf_follow_link (rh
);
5407 if (rh
->root
.type
!= bfd_link_hash_defined
5408 && rh
->root
.type
!= bfd_link_hash_defweak
)
5410 if (rh
->root
.u
.def
.section
->owner
== opd_bfd
)
5412 val
= rh
->root
.u
.def
.value
;
5413 sec
= rh
->root
.u
.def
.section
;
5420 Elf_Internal_Sym
*sym
;
5422 if (symndx
< symtab_hdr
->sh_info
)
5424 sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5427 size_t symcnt
= symtab_hdr
->sh_info
;
5428 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5433 symtab_hdr
->contents
= (bfd_byte
*) sym
;
5439 sym
= bfd_elf_get_elf_syms (opd_bfd
, symtab_hdr
,
5445 sec
= bfd_section_from_elf_index (opd_bfd
, sym
->st_shndx
);
5448 BFD_ASSERT ((sec
->flags
& SEC_MERGE
) == 0);
5449 val
= sym
->st_value
;
5452 val
+= look
->r_addend
;
5453 if (code_off
!= NULL
)
5455 if (code_sec
!= NULL
)
5457 if (in_code_sec
&& *code_sec
!= sec
)
5462 if (sec
->output_section
!= NULL
)
5463 val
+= sec
->output_section
->vma
+ sec
->output_offset
;
5472 /* If the ELF symbol SYM might be a function in SEC, return the
5473 function size and set *CODE_OFF to the function's entry point,
5474 otherwise return zero. */
5476 static bfd_size_type
5477 ppc64_elf_maybe_function_sym (const asymbol
*sym
, asection
*sec
,
5482 if ((sym
->flags
& (BSF_SECTION_SYM
| BSF_FILE
| BSF_OBJECT
5483 | BSF_THREAD_LOCAL
| BSF_RELC
| BSF_SRELC
)) != 0)
5487 if (!(sym
->flags
& BSF_SYNTHETIC
))
5488 size
= ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_size
;
5490 if (strcmp (sym
->section
->name
, ".opd") == 0)
5492 struct _opd_sec_data
*opd
= get_opd_info (sym
->section
);
5493 bfd_vma symval
= sym
->value
;
5496 && opd
->adjust
!= NULL
5497 && elf_section_data (sym
->section
)->relocs
!= NULL
)
5499 /* opd_entry_value will use cached relocs that have been
5500 adjusted, but with raw symbols. That means both local
5501 and global symbols need adjusting. */
5502 long adjust
= opd
->adjust
[OPD_NDX (symval
)];
5508 if (opd_entry_value (sym
->section
, symval
,
5509 &sec
, code_off
, TRUE
) == (bfd_vma
) -1)
5511 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5512 symbol. This size has nothing to do with the code size of the
5513 function, which is what we're supposed to return, but the
5514 code size isn't available without looking up the dot-sym.
5515 However, doing that would be a waste of time particularly
5516 since elf_find_function will look at the dot-sym anyway.
5517 Now, elf_find_function will keep the largest size of any
5518 function sym found at the code address of interest, so return
5519 1 here to avoid it incorrectly caching a larger function size
5520 for a small function. This does mean we return the wrong
5521 size for a new-ABI function of size 24, but all that does is
5522 disable caching for such functions. */
5528 if (sym
->section
!= sec
)
5530 *code_off
= sym
->value
;
5537 /* Return true if symbol is a strong function defined in an ELFv2
5538 object with st_other localentry bits of zero, ie. its local entry
5539 point coincides with its global entry point. */
5542 is_elfv2_localentry0 (struct elf_link_hash_entry
*h
)
5545 && h
->type
== STT_FUNC
5546 && h
->root
.type
== bfd_link_hash_defined
5547 && (STO_PPC64_LOCAL_MASK
& h
->other
) == 0
5548 && !ppc_elf_hash_entry (h
)->non_zero_localentry
5549 && is_ppc64_elf (h
->root
.u
.def
.section
->owner
)
5550 && abiversion (h
->root
.u
.def
.section
->owner
) >= 2);
5553 /* Return true if symbol is defined in a regular object file. */
5556 is_static_defined (struct elf_link_hash_entry
*h
)
5558 return ((h
->root
.type
== bfd_link_hash_defined
5559 || h
->root
.type
== bfd_link_hash_defweak
)
5560 && h
->root
.u
.def
.section
!= NULL
5561 && h
->root
.u
.def
.section
->output_section
!= NULL
);
5564 /* If FDH is a function descriptor symbol, return the associated code
5565 entry symbol if it is defined. Return NULL otherwise. */
5567 static struct ppc_link_hash_entry
*
5568 defined_code_entry (struct ppc_link_hash_entry
*fdh
)
5570 if (fdh
->is_func_descriptor
)
5572 struct ppc_link_hash_entry
*fh
= ppc_follow_link (fdh
->oh
);
5573 if (fh
->elf
.root
.type
== bfd_link_hash_defined
5574 || fh
->elf
.root
.type
== bfd_link_hash_defweak
)
5580 /* If FH is a function code entry symbol, return the associated
5581 function descriptor symbol if it is defined. Return NULL otherwise. */
5583 static struct ppc_link_hash_entry
*
5584 defined_func_desc (struct ppc_link_hash_entry
*fh
)
5587 && fh
->oh
->is_func_descriptor
)
5589 struct ppc_link_hash_entry
*fdh
= ppc_follow_link (fh
->oh
);
5590 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
5591 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
5597 /* Given H is a symbol that satisfies is_static_defined, return the
5598 value in the output file. */
5601 defined_sym_val (struct elf_link_hash_entry
*h
)
5603 return (h
->root
.u
.def
.section
->output_section
->vma
5604 + h
->root
.u
.def
.section
->output_offset
5605 + h
->root
.u
.def
.value
);
5608 /* Return true if H matches __tls_get_addr or one of its variants. */
5611 is_tls_get_addr (struct elf_link_hash_entry
*h
,
5612 struct ppc_link_hash_table
*htab
)
5614 return (h
== &htab
->tls_get_addr_fd
->elf
|| h
== &htab
->tga_desc_fd
->elf
5615 || h
== &htab
->tls_get_addr
->elf
|| h
== &htab
->tga_desc
->elf
);
5618 static bfd_boolean
func_desc_adjust (struct elf_link_hash_entry
*, void *);
5620 /* Garbage collect sections, after first dealing with dot-symbols. */
5623 ppc64_elf_gc_sections (bfd
*abfd
, struct bfd_link_info
*info
)
5625 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5627 if (htab
!= NULL
&& htab
->need_func_desc_adj
)
5629 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
5630 htab
->need_func_desc_adj
= 0;
5632 return bfd_elf_gc_sections (abfd
, info
);
5635 /* Mark all our entry sym sections, both opd and code section. */
5638 ppc64_elf_gc_keep (struct bfd_link_info
*info
)
5640 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5641 struct bfd_sym_chain
*sym
;
5646 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
5648 struct ppc_link_hash_entry
*eh
, *fh
;
5651 eh
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
->name
,
5652 FALSE
, FALSE
, TRUE
));
5655 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
5656 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
5659 fh
= defined_code_entry (eh
);
5662 sec
= fh
->elf
.root
.u
.def
.section
;
5663 sec
->flags
|= SEC_KEEP
;
5665 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5666 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5667 eh
->elf
.root
.u
.def
.value
,
5668 &sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5669 sec
->flags
|= SEC_KEEP
;
5671 sec
= eh
->elf
.root
.u
.def
.section
;
5672 sec
->flags
|= SEC_KEEP
;
5676 /* Mark sections containing dynamically referenced symbols. When
5677 building shared libraries, we must assume that any visible symbol is
5681 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry
*h
, void *inf
)
5683 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5684 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
5685 struct ppc_link_hash_entry
*fdh
;
5686 struct bfd_elf_dynamic_list
*d
= info
->dynamic_list
;
5688 /* Dynamic linking info is on the func descriptor sym. */
5689 fdh
= defined_func_desc (eh
);
5693 if ((eh
->elf
.root
.type
== bfd_link_hash_defined
5694 || eh
->elf
.root
.type
== bfd_link_hash_defweak
)
5695 && ((eh
->elf
.ref_dynamic
&& !eh
->elf
.forced_local
)
5696 || ((eh
->elf
.def_regular
|| ELF_COMMON_DEF_P (&eh
->elf
))
5697 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_INTERNAL
5698 && ELF_ST_VISIBILITY (eh
->elf
.other
) != STV_HIDDEN
5699 && (!bfd_link_executable (info
)
5700 || info
->gc_keep_exported
5701 || info
->export_dynamic
5704 && (*d
->match
) (&d
->head
, NULL
,
5705 eh
->elf
.root
.root
.string
)))
5706 && (eh
->elf
.versioned
>= versioned
5707 || !bfd_hide_sym_by_version (info
->version_info
,
5708 eh
->elf
.root
.root
.string
)))))
5711 struct ppc_link_hash_entry
*fh
;
5713 eh
->elf
.root
.u
.def
.section
->flags
|= SEC_KEEP
;
5715 /* Function descriptor syms cause the associated
5716 function code sym section to be marked. */
5717 fh
= defined_code_entry (eh
);
5720 code_sec
= fh
->elf
.root
.u
.def
.section
;
5721 code_sec
->flags
|= SEC_KEEP
;
5723 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5724 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5725 eh
->elf
.root
.u
.def
.value
,
5726 &code_sec
, NULL
, FALSE
) != (bfd_vma
) -1)
5727 code_sec
->flags
|= SEC_KEEP
;
5733 /* Return the section that should be marked against GC for a given
5737 ppc64_elf_gc_mark_hook (asection
*sec
,
5738 struct bfd_link_info
*info
,
5739 Elf_Internal_Rela
*rel
,
5740 struct elf_link_hash_entry
*h
,
5741 Elf_Internal_Sym
*sym
)
5745 /* Syms return NULL if we're marking .opd, so we avoid marking all
5746 function sections, as all functions are referenced in .opd. */
5748 if (get_opd_info (sec
) != NULL
)
5753 enum elf_ppc64_reloc_type r_type
;
5754 struct ppc_link_hash_entry
*eh
, *fh
, *fdh
;
5756 r_type
= ELF64_R_TYPE (rel
->r_info
);
5759 case R_PPC64_GNU_VTINHERIT
:
5760 case R_PPC64_GNU_VTENTRY
:
5764 switch (h
->root
.type
)
5766 case bfd_link_hash_defined
:
5767 case bfd_link_hash_defweak
:
5768 eh
= ppc_elf_hash_entry (h
);
5769 fdh
= defined_func_desc (eh
);
5772 /* -mcall-aixdesc code references the dot-symbol on
5773 a call reloc. Mark the function descriptor too
5774 against garbage collection. */
5776 if (fdh
->elf
.is_weakalias
)
5777 weakdef (&fdh
->elf
)->mark
= 1;
5781 /* Function descriptor syms cause the associated
5782 function code sym section to be marked. */
5783 fh
= defined_code_entry (eh
);
5786 /* They also mark their opd section. */
5787 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5789 rsec
= fh
->elf
.root
.u
.def
.section
;
5791 else if (get_opd_info (eh
->elf
.root
.u
.def
.section
) != NULL
5792 && opd_entry_value (eh
->elf
.root
.u
.def
.section
,
5793 eh
->elf
.root
.u
.def
.value
,
5794 &rsec
, NULL
, FALSE
) != (bfd_vma
) -1)
5795 eh
->elf
.root
.u
.def
.section
->gc_mark
= 1;
5797 rsec
= h
->root
.u
.def
.section
;
5800 case bfd_link_hash_common
:
5801 rsec
= h
->root
.u
.c
.p
->section
;
5805 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
5811 struct _opd_sec_data
*opd
;
5813 rsec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
5814 opd
= get_opd_info (rsec
);
5815 if (opd
!= NULL
&& opd
->func_sec
!= NULL
)
5819 rsec
= opd
->func_sec
[OPD_NDX (sym
->st_value
+ rel
->r_addend
)];
5826 /* The maximum size of .sfpr. */
5827 #define SFPR_MAX (218*4)
5829 struct sfpr_def_parms
5831 const char name
[12];
5832 unsigned char lo
, hi
;
5833 bfd_byte
*(*write_ent
) (bfd
*, bfd_byte
*, int);
5834 bfd_byte
*(*write_tail
) (bfd
*, bfd_byte
*, int);
5837 /* Auto-generate _save*, _rest* functions in .sfpr.
5838 If STUB_SEC is non-null, define alias symbols in STUB_SEC
5842 sfpr_define (struct bfd_link_info
*info
,
5843 const struct sfpr_def_parms
*parm
,
5846 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
5848 size_t len
= strlen (parm
->name
);
5849 bfd_boolean writing
= FALSE
;
5855 memcpy (sym
, parm
->name
, len
);
5858 for (i
= parm
->lo
; i
<= parm
->hi
; i
++)
5860 struct ppc_link_hash_entry
*h
;
5862 sym
[len
+ 0] = i
/ 10 + '0';
5863 sym
[len
+ 1] = i
% 10 + '0';
5864 h
= ppc_elf_hash_entry (elf_link_hash_lookup (&htab
->elf
, sym
,
5865 writing
, TRUE
, TRUE
));
5866 if (stub_sec
!= NULL
)
5869 && h
->elf
.root
.type
== bfd_link_hash_defined
5870 && h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
5872 struct elf_link_hash_entry
*s
;
5874 sprintf (buf
, "%08x.%s", stub_sec
->id
& 0xffffffff, sym
);
5875 s
= elf_link_hash_lookup (&htab
->elf
, buf
, TRUE
, TRUE
, FALSE
);
5878 if (s
->root
.type
== bfd_link_hash_new
)
5880 s
->root
.type
= bfd_link_hash_defined
;
5881 s
->root
.u
.def
.section
= stub_sec
;
5882 s
->root
.u
.def
.value
= (stub_sec
->size
- htab
->sfpr
->size
5883 + h
->elf
.root
.u
.def
.value
);
5886 s
->ref_regular_nonweak
= 1;
5887 s
->forced_local
= 1;
5889 s
->root
.linker_def
= 1;
5897 if (!h
->elf
.def_regular
)
5899 h
->elf
.root
.type
= bfd_link_hash_defined
;
5900 h
->elf
.root
.u
.def
.section
= htab
->sfpr
;
5901 h
->elf
.root
.u
.def
.value
= htab
->sfpr
->size
;
5902 h
->elf
.type
= STT_FUNC
;
5903 h
->elf
.def_regular
= 1;
5905 _bfd_elf_link_hash_hide_symbol (info
, &h
->elf
, TRUE
);
5907 if (htab
->sfpr
->contents
== NULL
)
5909 htab
->sfpr
->contents
5910 = bfd_alloc (htab
->elf
.dynobj
, SFPR_MAX
);
5911 if (htab
->sfpr
->contents
== NULL
)
5918 bfd_byte
*p
= htab
->sfpr
->contents
+ htab
->sfpr
->size
;
5920 p
= (*parm
->write_ent
) (htab
->elf
.dynobj
, p
, i
);
5922 p
= (*parm
->write_tail
) (htab
->elf
.dynobj
, p
, i
);
5923 htab
->sfpr
->size
= p
- htab
->sfpr
->contents
;
5931 savegpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5933 bfd_put_32 (abfd
, STD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5938 savegpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5940 p
= savegpr0 (abfd
, p
, r
);
5941 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
5943 bfd_put_32 (abfd
, BLR
, p
);
5948 restgpr0 (bfd
*abfd
, bfd_byte
*p
, int r
)
5950 bfd_put_32 (abfd
, LD_R0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5955 restgpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5957 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
5959 p
= restgpr0 (abfd
, p
, r
);
5960 bfd_put_32 (abfd
, MTLR_R0
, p
);
5964 p
= restgpr0 (abfd
, p
, 30);
5965 p
= restgpr0 (abfd
, p
, 31);
5967 bfd_put_32 (abfd
, BLR
, p
);
5972 savegpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5974 bfd_put_32 (abfd
, STD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5979 savegpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5981 p
= savegpr1 (abfd
, p
, r
);
5982 bfd_put_32 (abfd
, BLR
, p
);
5987 restgpr1 (bfd
*abfd
, bfd_byte
*p
, int r
)
5989 bfd_put_32 (abfd
, LD_R0_0R12
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
5994 restgpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
5996 p
= restgpr1 (abfd
, p
, r
);
5997 bfd_put_32 (abfd
, BLR
, p
);
6002 savefpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6004 bfd_put_32 (abfd
, STFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6009 savefpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6011 p
= savefpr (abfd
, p
, r
);
6012 bfd_put_32 (abfd
, STD_R0_0R1
+ STK_LR
, p
);
6014 bfd_put_32 (abfd
, BLR
, p
);
6019 restfpr (bfd
*abfd
, bfd_byte
*p
, int r
)
6021 bfd_put_32 (abfd
, LFD_FR0_0R1
+ (r
<< 21) + (1 << 16) - (32 - r
) * 8, p
);
6026 restfpr0_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6028 bfd_put_32 (abfd
, LD_R0_0R1
+ STK_LR
, p
);
6030 p
= restfpr (abfd
, p
, r
);
6031 bfd_put_32 (abfd
, MTLR_R0
, p
);
6035 p
= restfpr (abfd
, p
, 30);
6036 p
= restfpr (abfd
, p
, 31);
6038 bfd_put_32 (abfd
, BLR
, p
);
6043 savefpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6045 p
= savefpr (abfd
, p
, r
);
6046 bfd_put_32 (abfd
, BLR
, p
);
6051 restfpr1_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6053 p
= restfpr (abfd
, p
, r
);
6054 bfd_put_32 (abfd
, BLR
, p
);
6059 savevr (bfd
*abfd
, bfd_byte
*p
, int r
)
6061 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6063 bfd_put_32 (abfd
, STVX_VR0_R12_R0
+ (r
<< 21), p
);
6068 savevr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6070 p
= savevr (abfd
, p
, r
);
6071 bfd_put_32 (abfd
, BLR
, p
);
6076 restvr (bfd
*abfd
, bfd_byte
*p
, int r
)
6078 bfd_put_32 (abfd
, LI_R12_0
+ (1 << 16) - (32 - r
) * 16, p
);
6080 bfd_put_32 (abfd
, LVX_VR0_R12_R0
+ (r
<< 21), p
);
6085 restvr_tail (bfd
*abfd
, bfd_byte
*p
, int r
)
6087 p
= restvr (abfd
, p
, r
);
6088 bfd_put_32 (abfd
, BLR
, p
);
6092 #define STDU_R1_0R1 0xf8210001
6093 #define ADDI_R1_R1 0x38210000
6095 /* Emit prologue of wrapper preserving regs around a call to
6096 __tls_get_addr_opt. */
6099 tls_get_addr_prologue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6103 bfd_put_32 (obfd
, MFLR_R0
, p
);
6105 bfd_put_32 (obfd
, STD_R0_0R1
+ 16, p
);
6110 for (i
= 4; i
< 12; i
++)
6113 STD_R0_0R1
| i
<< 21 | (-(13 - i
) * 8 & 0xffff), p
);
6116 bfd_put_32 (obfd
, STDU_R1_0R1
| (-128 & 0xffff), p
);
6121 for (i
= 4; i
< 12; i
++)
6124 STD_R0_0R1
| i
<< 21 | (-(12 - i
) * 8 & 0xffff), p
);
6127 bfd_put_32 (obfd
, STDU_R1_0R1
| (-96 & 0xffff), p
);
6133 /* Emit epilogue of wrapper preserving regs around a call to
6134 __tls_get_addr_opt. */
6137 tls_get_addr_epilogue (bfd
*obfd
, bfd_byte
*p
, struct ppc_link_hash_table
*htab
)
6143 for (i
= 4; i
< 12; i
++)
6145 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (128 - (13 - i
) * 8), p
);
6148 bfd_put_32 (obfd
, ADDI_R1_R1
| 128, p
);
6153 for (i
= 4; i
< 12; i
++)
6155 bfd_put_32 (obfd
, LD_R0_0R1
| i
<< 21 | (96 - (12 - i
) * 8), p
);
6158 bfd_put_32 (obfd
, ADDI_R1_R1
| 96, p
);
6161 bfd_put_32 (obfd
, LD_R0_0R1
| 16, p
);
6163 bfd_put_32 (obfd
, MTLR_R0
, p
);
6165 bfd_put_32 (obfd
, BLR
, p
);
6170 /* Called via elf_link_hash_traverse to transfer dynamic linking
6171 information on function code symbol entries to their corresponding
6172 function descriptor symbol entries. */
6175 func_desc_adjust (struct elf_link_hash_entry
*h
, void *inf
)
6177 struct bfd_link_info
*info
;
6178 struct ppc_link_hash_table
*htab
;
6179 struct ppc_link_hash_entry
*fh
;
6180 struct ppc_link_hash_entry
*fdh
;
6181 bfd_boolean force_local
;
6183 fh
= ppc_elf_hash_entry (h
);
6184 if (fh
->elf
.root
.type
== bfd_link_hash_indirect
)
6190 if (fh
->elf
.root
.root
.string
[0] != '.'
6191 || fh
->elf
.root
.root
.string
[1] == '\0')
6195 htab
= ppc_hash_table (info
);
6199 /* Find the corresponding function descriptor symbol. */
6200 fdh
= lookup_fdh (fh
, htab
);
6202 /* Resolve undefined references to dot-symbols as the value
6203 in the function descriptor, if we have one in a regular object.
6204 This is to satisfy cases like ".quad .foo". Calls to functions
6205 in dynamic objects are handled elsewhere. */
6206 if ((fh
->elf
.root
.type
== bfd_link_hash_undefined
6207 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
)
6208 && (fdh
->elf
.root
.type
== bfd_link_hash_defined
6209 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
6210 && get_opd_info (fdh
->elf
.root
.u
.def
.section
) != NULL
6211 && opd_entry_value (fdh
->elf
.root
.u
.def
.section
,
6212 fdh
->elf
.root
.u
.def
.value
,
6213 &fh
->elf
.root
.u
.def
.section
,
6214 &fh
->elf
.root
.u
.def
.value
, FALSE
) != (bfd_vma
) -1)
6216 fh
->elf
.root
.type
= fdh
->elf
.root
.type
;
6217 fh
->elf
.forced_local
= 1;
6218 fh
->elf
.def_regular
= fdh
->elf
.def_regular
;
6219 fh
->elf
.def_dynamic
= fdh
->elf
.def_dynamic
;
6222 if (!fh
->elf
.dynamic
)
6224 struct plt_entry
*ent
;
6226 for (ent
= fh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6227 if (ent
->plt
.refcount
> 0)
6233 /* Create a descriptor as undefined if necessary. */
6235 && !bfd_link_executable (info
)
6236 && (fh
->elf
.root
.type
== bfd_link_hash_undefined
6237 || fh
->elf
.root
.type
== bfd_link_hash_undefweak
))
6239 fdh
= make_fdh (info
, fh
);
6244 /* We can't support overriding of symbols on a fake descriptor. */
6247 && (fh
->elf
.root
.type
== bfd_link_hash_defined
6248 || fh
->elf
.root
.type
== bfd_link_hash_defweak
))
6249 _bfd_elf_link_hash_hide_symbol (info
, &fdh
->elf
, TRUE
);
6251 /* Transfer dynamic linking information to the function descriptor. */
6254 fdh
->elf
.ref_regular
|= fh
->elf
.ref_regular
;
6255 fdh
->elf
.ref_dynamic
|= fh
->elf
.ref_dynamic
;
6256 fdh
->elf
.ref_regular_nonweak
|= fh
->elf
.ref_regular_nonweak
;
6257 fdh
->elf
.non_got_ref
|= fh
->elf
.non_got_ref
;
6258 fdh
->elf
.dynamic
|= fh
->elf
.dynamic
;
6259 fdh
->elf
.needs_plt
|= (fh
->elf
.needs_plt
6260 || fh
->elf
.type
== STT_FUNC
6261 || fh
->elf
.type
== STT_GNU_IFUNC
);
6262 move_plt_plist (fh
, fdh
);
6264 if (!fdh
->elf
.forced_local
6265 && fh
->elf
.dynindx
!= -1)
6266 if (!bfd_elf_link_record_dynamic_symbol (info
, &fdh
->elf
))
6270 /* Now that the info is on the function descriptor, clear the
6271 function code sym info. Any function code syms for which we
6272 don't have a definition in a regular file, we force local.
6273 This prevents a shared library from exporting syms that have
6274 been imported from another library. Function code syms that
6275 are really in the library we must leave global to prevent the
6276 linker dragging in a definition from a static library. */
6277 force_local
= (!fh
->elf
.def_regular
6279 || !fdh
->elf
.def_regular
6280 || fdh
->elf
.forced_local
);
6281 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6286 static const struct sfpr_def_parms save_res_funcs
[] =
6288 { "_savegpr0_", 14, 31, savegpr0
, savegpr0_tail
},
6289 { "_restgpr0_", 14, 29, restgpr0
, restgpr0_tail
},
6290 { "_restgpr0_", 30, 31, restgpr0
, restgpr0_tail
},
6291 { "_savegpr1_", 14, 31, savegpr1
, savegpr1_tail
},
6292 { "_restgpr1_", 14, 31, restgpr1
, restgpr1_tail
},
6293 { "_savefpr_", 14, 31, savefpr
, savefpr0_tail
},
6294 { "_restfpr_", 14, 29, restfpr
, restfpr0_tail
},
6295 { "_restfpr_", 30, 31, restfpr
, restfpr0_tail
},
6296 { "._savef", 14, 31, savefpr
, savefpr1_tail
},
6297 { "._restf", 14, 31, restfpr
, restfpr1_tail
},
6298 { "_savevr_", 20, 31, savevr
, savevr_tail
},
6299 { "_restvr_", 20, 31, restvr
, restvr_tail
}
6302 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6303 this hook to a) provide some gcc support functions, and b) transfer
6304 dynamic linking information gathered so far on function code symbol
6305 entries, to their corresponding function descriptor symbol entries. */
6308 ppc64_elf_func_desc_adjust (bfd
*obfd ATTRIBUTE_UNUSED
,
6309 struct bfd_link_info
*info
)
6311 struct ppc_link_hash_table
*htab
;
6313 htab
= ppc_hash_table (info
);
6317 /* Provide any missing _save* and _rest* functions. */
6318 if (htab
->sfpr
!= NULL
)
6322 htab
->sfpr
->size
= 0;
6323 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
6324 if (!sfpr_define (info
, &save_res_funcs
[i
], NULL
))
6326 if (htab
->sfpr
->size
== 0)
6327 htab
->sfpr
->flags
|= SEC_EXCLUDE
;
6330 if (bfd_link_relocatable (info
))
6333 if (htab
->elf
.hgot
!= NULL
)
6335 _bfd_elf_link_hash_hide_symbol (info
, htab
->elf
.hgot
, TRUE
);
6336 /* Make .TOC. defined so as to prevent it being made dynamic.
6337 The wrong value here is fixed later in ppc64_elf_set_toc. */
6338 if (!htab
->elf
.hgot
->def_regular
6339 || htab
->elf
.hgot
->root
.type
!= bfd_link_hash_defined
)
6341 htab
->elf
.hgot
->root
.type
= bfd_link_hash_defined
;
6342 htab
->elf
.hgot
->root
.u
.def
.value
= 0;
6343 htab
->elf
.hgot
->root
.u
.def
.section
= bfd_abs_section_ptr
;
6344 htab
->elf
.hgot
->def_regular
= 1;
6345 htab
->elf
.hgot
->root
.linker_def
= 1;
6347 htab
->elf
.hgot
->type
= STT_OBJECT
;
6348 htab
->elf
.hgot
->other
6349 = (htab
->elf
.hgot
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
6352 if (htab
->need_func_desc_adj
)
6354 elf_link_hash_traverse (&htab
->elf
, func_desc_adjust
, info
);
6355 htab
->need_func_desc_adj
= 0;
6361 /* Return true if we have dynamic relocs against H or any of its weak
6362 aliases, that apply to read-only sections. Cannot be used after
6363 size_dynamic_sections. */
6366 alias_readonly_dynrelocs (struct elf_link_hash_entry
*h
)
6368 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
6371 if (_bfd_elf_readonly_dynrelocs (&eh
->elf
))
6373 eh
= ppc_elf_hash_entry (eh
->elf
.u
.alias
);
6375 while (eh
!= NULL
&& &eh
->elf
!= h
);
6380 /* Return whether EH has pc-relative dynamic relocs. */
6383 pc_dynrelocs (struct ppc_link_hash_entry
*eh
)
6385 struct elf_dyn_relocs
*p
;
6387 for (p
= eh
->elf
.dyn_relocs
; p
!= NULL
; p
= p
->next
)
6388 if (p
->pc_count
!= 0)
6393 /* Return true if a global entry stub will be created for H. Valid
6394 for ELFv2 before plt entries have been allocated. */
6397 global_entry_stub (struct elf_link_hash_entry
*h
)
6399 struct plt_entry
*pent
;
6401 if (!h
->pointer_equality_needed
6405 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
6406 if (pent
->plt
.refcount
> 0
6407 && pent
->addend
== 0)
6413 /* Adjust a symbol defined by a dynamic object and referenced by a
6414 regular object. The current definition is in some section of the
6415 dynamic object, but we're not including those sections. We have to
6416 change the definition to something the rest of the link can
6420 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
6421 struct elf_link_hash_entry
*h
)
6423 struct ppc_link_hash_table
*htab
;
6426 htab
= ppc_hash_table (info
);
6430 /* Deal with function syms. */
6431 if (h
->type
== STT_FUNC
6432 || h
->type
== STT_GNU_IFUNC
6435 bfd_boolean local
= (ppc_elf_hash_entry (h
)->save_res
6436 || SYMBOL_CALLS_LOCAL (info
, h
)
6437 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
6438 /* Discard dyn_relocs when non-pic if we've decided that a
6439 function symbol is local and not an ifunc. We keep dynamic
6440 relocs for ifuncs when local rather than always emitting a
6441 plt call stub for them and defining the symbol on the call
6442 stub. We can't do that for ELFv1 anyway (a function symbol
6443 is defined on a descriptor, not code) and it can be faster at
6444 run-time due to not needing to bounce through a stub. The
6445 dyn_relocs for ifuncs will be applied even in a static
6447 if (!bfd_link_pic (info
)
6448 && h
->type
!= STT_GNU_IFUNC
6450 h
->dyn_relocs
= NULL
;
6452 /* Clear procedure linkage table information for any symbol that
6453 won't need a .plt entry. */
6454 struct plt_entry
*ent
;
6455 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
6456 if (ent
->plt
.refcount
> 0)
6459 || (h
->type
!= STT_GNU_IFUNC
6461 && (htab
->can_convert_all_inline_plt
6462 || (ppc_elf_hash_entry (h
)->tls_mask
6463 & (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)))
6465 h
->plt
.plist
= NULL
;
6467 h
->pointer_equality_needed
= 0;
6469 else if (abiversion (info
->output_bfd
) >= 2)
6471 /* Taking a function's address in a read/write section
6472 doesn't require us to define the function symbol in the
6473 executable on a global entry stub. A dynamic reloc can
6474 be used instead. The reason we prefer a few more dynamic
6475 relocs is that calling via a global entry stub costs a
6476 few more instructions, and pointer_equality_needed causes
6477 extra work in ld.so when resolving these symbols. */
6478 if (global_entry_stub (h
))
6480 if (!_bfd_elf_readonly_dynrelocs (h
))
6482 h
->pointer_equality_needed
= 0;
6483 /* If we haven't seen a branch reloc and the symbol
6484 isn't an ifunc then we don't need a plt entry. */
6486 h
->plt
.plist
= NULL
;
6488 else if (!bfd_link_pic (info
))
6489 /* We are going to be defining the function symbol on the
6490 plt stub, so no dyn_relocs needed when non-pic. */
6491 h
->dyn_relocs
= NULL
;
6494 /* ELFv2 function symbols can't have copy relocs. */
6497 else if (!h
->needs_plt
6498 && !_bfd_elf_readonly_dynrelocs (h
))
6500 /* If we haven't seen a branch reloc and the symbol isn't an
6501 ifunc then we don't need a plt entry. */
6502 h
->plt
.plist
= NULL
;
6503 h
->pointer_equality_needed
= 0;
6508 h
->plt
.plist
= NULL
;
6510 /* If this is a weak symbol, and there is a real definition, the
6511 processor independent code will have arranged for us to see the
6512 real definition first, and we can just use the same value. */
6513 if (h
->is_weakalias
)
6515 struct elf_link_hash_entry
*def
= weakdef (h
);
6516 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
6517 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
6518 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
6519 if (def
->root
.u
.def
.section
== htab
->elf
.sdynbss
6520 || def
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
6521 h
->dyn_relocs
= NULL
;
6525 /* If we are creating a shared library, we must presume that the
6526 only references to the symbol are via the global offset table.
6527 For such cases we need not do anything here; the relocations will
6528 be handled correctly by relocate_section. */
6529 if (!bfd_link_executable (info
))
6532 /* If there are no references to this symbol that do not use the
6533 GOT, we don't need to generate a copy reloc. */
6534 if (!h
->non_got_ref
)
6537 /* Don't generate a copy reloc for symbols defined in the executable. */
6538 if (!h
->def_dynamic
|| !h
->ref_regular
|| h
->def_regular
6540 /* If -z nocopyreloc was given, don't generate them either. */
6541 || info
->nocopyreloc
6543 /* If we don't find any dynamic relocs in read-only sections, then
6544 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6545 || (ELIMINATE_COPY_RELOCS
6547 && !alias_readonly_dynrelocs (h
))
6549 /* Protected variables do not work with .dynbss. The copy in
6550 .dynbss won't be used by the shared library with the protected
6551 definition for the variable. Text relocations are preferable
6552 to an incorrect program. */
6553 || h
->protected_def
)
6556 if (h
->type
== STT_FUNC
6557 || h
->type
== STT_GNU_IFUNC
)
6559 /* .dynbss copies of function symbols only work if we have
6560 ELFv1 dot-symbols. ELFv1 compilers since 2004 default to not
6561 use dot-symbols and set the function symbol size to the text
6562 size of the function rather than the size of the descriptor.
6563 That's wrong for copying a descriptor. */
6564 if (ppc_elf_hash_entry (h
)->oh
== NULL
6565 || !(h
->size
== 24 || h
->size
== 16))
6568 /* We should never get here, but unfortunately there are old
6569 versions of gcc (circa gcc-3.2) that improperly for the
6570 ELFv1 ABI put initialized function pointers, vtable refs and
6571 suchlike in read-only sections. Allow them to proceed, but
6572 warn that this might break at runtime. */
6573 info
->callbacks
->einfo
6574 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
6575 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6576 h
->root
.root
.string
);
6579 /* This is a reference to a symbol defined by a dynamic object which
6580 is not a function. */
6582 /* We must allocate the symbol in our .dynbss section, which will
6583 become part of the .bss section of the executable. There will be
6584 an entry for this symbol in the .dynsym section. The dynamic
6585 object will contain position independent code, so all references
6586 from the dynamic object to this symbol will go through the global
6587 offset table. The dynamic linker will use the .dynsym entry to
6588 determine the address it must put in the global offset table, so
6589 both the dynamic object and the regular object will refer to the
6590 same memory location for the variable. */
6591 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
6593 s
= htab
->elf
.sdynrelro
;
6594 srel
= htab
->elf
.sreldynrelro
;
6598 s
= htab
->elf
.sdynbss
;
6599 srel
= htab
->elf
.srelbss
;
6601 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
6603 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
6604 linker to copy the initial value out of the dynamic object
6605 and into the runtime process image. */
6606 srel
->size
+= sizeof (Elf64_External_Rela
);
6610 /* We no longer want dyn_relocs. */
6611 h
->dyn_relocs
= NULL
;
6612 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
6615 /* If given a function descriptor symbol, hide both the function code
6616 sym and the descriptor. */
6618 ppc64_elf_hide_symbol (struct bfd_link_info
*info
,
6619 struct elf_link_hash_entry
*h
,
6620 bfd_boolean force_local
)
6622 struct ppc_link_hash_entry
*eh
;
6623 _bfd_elf_link_hash_hide_symbol (info
, h
, force_local
);
6625 if (ppc_hash_table (info
) == NULL
)
6628 eh
= ppc_elf_hash_entry (h
);
6629 if (eh
->is_func_descriptor
)
6631 struct ppc_link_hash_entry
*fh
= eh
->oh
;
6636 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
6639 /* We aren't supposed to use alloca in BFD because on
6640 systems which do not have alloca the version in libiberty
6641 calls xmalloc, which might cause the program to crash
6642 when it runs out of memory. This function doesn't have a
6643 return status, so there's no way to gracefully return an
6644 error. So cheat. We know that string[-1] can be safely
6645 accessed; It's either a string in an ELF string table,
6646 or allocated in an objalloc structure. */
6648 p
= eh
->elf
.root
.root
.string
- 1;
6651 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6655 /* Unfortunately, if it so happens that the string we were
6656 looking for was allocated immediately before this string,
6657 then we overwrote the string terminator. That's the only
6658 reason the lookup should fail. */
6661 q
= eh
->elf
.root
.root
.string
+ strlen (eh
->elf
.root
.root
.string
);
6662 while (q
>= eh
->elf
.root
.root
.string
&& *q
== *p
)
6664 if (q
< eh
->elf
.root
.root
.string
&& *p
== '.')
6665 fh
= ppc_elf_hash_entry (elf_link_hash_lookup (htab
, p
, FALSE
,
6675 _bfd_elf_link_hash_hide_symbol (info
, &fh
->elf
, force_local
);
6680 get_sym_h (struct elf_link_hash_entry
**hp
,
6681 Elf_Internal_Sym
**symp
,
6683 unsigned char **tls_maskp
,
6684 Elf_Internal_Sym
**locsymsp
,
6685 unsigned long r_symndx
,
6688 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
6690 if (r_symndx
>= symtab_hdr
->sh_info
)
6692 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
6693 struct elf_link_hash_entry
*h
;
6695 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6696 h
= elf_follow_link (h
);
6704 if (symsecp
!= NULL
)
6706 asection
*symsec
= NULL
;
6707 if (h
->root
.type
== bfd_link_hash_defined
6708 || h
->root
.type
== bfd_link_hash_defweak
)
6709 symsec
= h
->root
.u
.def
.section
;
6713 if (tls_maskp
!= NULL
)
6714 *tls_maskp
= &ppc_elf_hash_entry (h
)->tls_mask
;
6718 Elf_Internal_Sym
*sym
;
6719 Elf_Internal_Sym
*locsyms
= *locsymsp
;
6721 if (locsyms
== NULL
)
6723 locsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
6724 if (locsyms
== NULL
)
6725 locsyms
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
6726 symtab_hdr
->sh_info
,
6727 0, NULL
, NULL
, NULL
);
6728 if (locsyms
== NULL
)
6730 *locsymsp
= locsyms
;
6732 sym
= locsyms
+ r_symndx
;
6740 if (symsecp
!= NULL
)
6741 *symsecp
= bfd_section_from_elf_index (ibfd
, sym
->st_shndx
);
6743 if (tls_maskp
!= NULL
)
6745 struct got_entry
**lgot_ents
;
6746 unsigned char *tls_mask
;
6749 lgot_ents
= elf_local_got_ents (ibfd
);
6750 if (lgot_ents
!= NULL
)
6752 struct plt_entry
**local_plt
= (struct plt_entry
**)
6753 (lgot_ents
+ symtab_hdr
->sh_info
);
6754 unsigned char *lgot_masks
= (unsigned char *)
6755 (local_plt
+ symtab_hdr
->sh_info
);
6756 tls_mask
= &lgot_masks
[r_symndx
];
6758 *tls_maskp
= tls_mask
;
6764 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6765 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6766 type suitable for optimization, and 1 otherwise. */
6769 get_tls_mask (unsigned char **tls_maskp
,
6770 unsigned long *toc_symndx
,
6771 bfd_vma
*toc_addend
,
6772 Elf_Internal_Sym
**locsymsp
,
6773 const Elf_Internal_Rela
*rel
,
6776 unsigned long r_symndx
;
6778 struct elf_link_hash_entry
*h
;
6779 Elf_Internal_Sym
*sym
;
6783 r_symndx
= ELF64_R_SYM (rel
->r_info
);
6784 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6787 if ((*tls_maskp
!= NULL
6788 && (**tls_maskp
& TLS_TLS
) != 0
6789 && **tls_maskp
!= (TLS_TLS
| TLS_MARK
))
6791 || ppc64_elf_section_data (sec
) == NULL
6792 || ppc64_elf_section_data (sec
)->sec_type
!= sec_toc
)
6795 /* Look inside a TOC section too. */
6798 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
6799 off
= h
->root
.u
.def
.value
;
6802 off
= sym
->st_value
;
6803 off
+= rel
->r_addend
;
6804 BFD_ASSERT (off
% 8 == 0);
6805 r_symndx
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8];
6806 next_r
= ppc64_elf_section_data (sec
)->u
.toc
.symndx
[off
/ 8 + 1];
6807 if (toc_symndx
!= NULL
)
6808 *toc_symndx
= r_symndx
;
6809 if (toc_addend
!= NULL
)
6810 *toc_addend
= ppc64_elf_section_data (sec
)->u
.toc
.add
[off
/ 8];
6811 if (!get_sym_h (&h
, &sym
, &sec
, tls_maskp
, locsymsp
, r_symndx
, ibfd
))
6813 if ((h
== NULL
|| is_static_defined (h
))
6814 && (next_r
== -1 || next_r
== -2))
6819 /* Find (or create) an entry in the tocsave hash table. */
6821 static struct tocsave_entry
*
6822 tocsave_find (struct ppc_link_hash_table
*htab
,
6823 enum insert_option insert
,
6824 Elf_Internal_Sym
**local_syms
,
6825 const Elf_Internal_Rela
*irela
,
6828 unsigned long r_indx
;
6829 struct elf_link_hash_entry
*h
;
6830 Elf_Internal_Sym
*sym
;
6831 struct tocsave_entry ent
, *p
;
6833 struct tocsave_entry
**slot
;
6835 r_indx
= ELF64_R_SYM (irela
->r_info
);
6836 if (!get_sym_h (&h
, &sym
, &ent
.sec
, NULL
, local_syms
, r_indx
, ibfd
))
6838 if (ent
.sec
== NULL
|| ent
.sec
->output_section
== NULL
)
6841 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd
);
6846 ent
.offset
= h
->root
.u
.def
.value
;
6848 ent
.offset
= sym
->st_value
;
6849 ent
.offset
+= irela
->r_addend
;
6851 hash
= tocsave_htab_hash (&ent
);
6852 slot
= ((struct tocsave_entry
**)
6853 htab_find_slot_with_hash (htab
->tocsave_htab
, &ent
, hash
, insert
));
6859 p
= (struct tocsave_entry
*) bfd_alloc (ibfd
, sizeof (*p
));
6868 /* Adjust all global syms defined in opd sections. In gcc generated
6869 code for the old ABI, these will already have been done. */
6872 adjust_opd_syms (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
6874 struct ppc_link_hash_entry
*eh
;
6876 struct _opd_sec_data
*opd
;
6878 if (h
->root
.type
== bfd_link_hash_indirect
)
6881 if (h
->root
.type
!= bfd_link_hash_defined
6882 && h
->root
.type
!= bfd_link_hash_defweak
)
6885 eh
= ppc_elf_hash_entry (h
);
6886 if (eh
->adjust_done
)
6889 sym_sec
= eh
->elf
.root
.u
.def
.section
;
6890 opd
= get_opd_info (sym_sec
);
6891 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
6893 long adjust
= opd
->adjust
[OPD_NDX (eh
->elf
.root
.u
.def
.value
)];
6896 /* This entry has been deleted. */
6897 asection
*dsec
= ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
;
6900 for (dsec
= sym_sec
->owner
->sections
; dsec
; dsec
= dsec
->next
)
6901 if (discarded_section (dsec
))
6903 ppc64_elf_tdata (sym_sec
->owner
)->deleted_section
= dsec
;
6907 eh
->elf
.root
.u
.def
.value
= 0;
6908 eh
->elf
.root
.u
.def
.section
= dsec
;
6911 eh
->elf
.root
.u
.def
.value
+= adjust
;
6912 eh
->adjust_done
= 1;
6917 /* Handles decrementing dynamic reloc counts for the reloc specified by
6918 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6919 have already been determined. */
6922 dec_dynrel_count (bfd_vma r_info
,
6924 struct bfd_link_info
*info
,
6925 Elf_Internal_Sym
**local_syms
,
6926 struct elf_link_hash_entry
*h
,
6927 Elf_Internal_Sym
*sym
)
6929 enum elf_ppc64_reloc_type r_type
;
6930 asection
*sym_sec
= NULL
;
6932 /* Can this reloc be dynamic? This switch, and later tests here
6933 should be kept in sync with the code in check_relocs. */
6934 r_type
= ELF64_R_TYPE (r_info
);
6941 case R_PPC64_TOC16_DS
:
6942 case R_PPC64_TOC16_LO
:
6943 case R_PPC64_TOC16_HI
:
6944 case R_PPC64_TOC16_HA
:
6945 case R_PPC64_TOC16_LO_DS
:
6950 case R_PPC64_TPREL16
:
6951 case R_PPC64_TPREL16_LO
:
6952 case R_PPC64_TPREL16_HI
:
6953 case R_PPC64_TPREL16_HA
:
6954 case R_PPC64_TPREL16_DS
:
6955 case R_PPC64_TPREL16_LO_DS
:
6956 case R_PPC64_TPREL16_HIGH
:
6957 case R_PPC64_TPREL16_HIGHA
:
6958 case R_PPC64_TPREL16_HIGHER
:
6959 case R_PPC64_TPREL16_HIGHERA
:
6960 case R_PPC64_TPREL16_HIGHEST
:
6961 case R_PPC64_TPREL16_HIGHESTA
:
6962 case R_PPC64_TPREL64
:
6963 case R_PPC64_TPREL34
:
6964 case R_PPC64_DTPMOD64
:
6965 case R_PPC64_DTPREL64
:
6966 case R_PPC64_ADDR64
:
6970 case R_PPC64_ADDR14
:
6971 case R_PPC64_ADDR14_BRNTAKEN
:
6972 case R_PPC64_ADDR14_BRTAKEN
:
6973 case R_PPC64_ADDR16
:
6974 case R_PPC64_ADDR16_DS
:
6975 case R_PPC64_ADDR16_HA
:
6976 case R_PPC64_ADDR16_HI
:
6977 case R_PPC64_ADDR16_HIGH
:
6978 case R_PPC64_ADDR16_HIGHA
:
6979 case R_PPC64_ADDR16_HIGHER
:
6980 case R_PPC64_ADDR16_HIGHERA
:
6981 case R_PPC64_ADDR16_HIGHEST
:
6982 case R_PPC64_ADDR16_HIGHESTA
:
6983 case R_PPC64_ADDR16_LO
:
6984 case R_PPC64_ADDR16_LO_DS
:
6985 case R_PPC64_ADDR24
:
6986 case R_PPC64_ADDR32
:
6987 case R_PPC64_UADDR16
:
6988 case R_PPC64_UADDR32
:
6989 case R_PPC64_UADDR64
:
6992 case R_PPC64_D34_LO
:
6993 case R_PPC64_D34_HI30
:
6994 case R_PPC64_D34_HA30
:
6995 case R_PPC64_ADDR16_HIGHER34
:
6996 case R_PPC64_ADDR16_HIGHERA34
:
6997 case R_PPC64_ADDR16_HIGHEST34
:
6998 case R_PPC64_ADDR16_HIGHESTA34
:
7003 if (local_syms
!= NULL
)
7005 unsigned long r_symndx
;
7006 bfd
*ibfd
= sec
->owner
;
7008 r_symndx
= ELF64_R_SYM (r_info
);
7009 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, local_syms
, r_symndx
, ibfd
))
7014 && (h
->root
.type
== bfd_link_hash_defweak
7015 || !h
->def_regular
))
7017 && !bfd_link_executable (info
)
7018 && !SYMBOLIC_BIND (info
, h
))
7019 || (bfd_link_pic (info
)
7020 && must_be_dyn_reloc (info
, r_type
))
7021 || (!bfd_link_pic (info
)
7023 ? h
->type
== STT_GNU_IFUNC
7024 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)))
7031 struct elf_dyn_relocs
*p
;
7032 struct elf_dyn_relocs
**pp
;
7033 pp
= &h
->dyn_relocs
;
7035 /* elf_gc_sweep may have already removed all dyn relocs associated
7036 with local syms for a given section. Also, symbol flags are
7037 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7038 report a dynreloc miscount. */
7039 if (*pp
== NULL
&& info
->gc_sections
)
7042 while ((p
= *pp
) != NULL
)
7046 if (!must_be_dyn_reloc (info
, r_type
))
7058 struct ppc_dyn_relocs
*p
;
7059 struct ppc_dyn_relocs
**pp
;
7061 bfd_boolean is_ifunc
;
7063 if (local_syms
== NULL
)
7064 sym_sec
= bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
7065 if (sym_sec
== NULL
)
7068 vpp
= &elf_section_data (sym_sec
)->local_dynrel
;
7069 pp
= (struct ppc_dyn_relocs
**) vpp
;
7071 if (*pp
== NULL
&& info
->gc_sections
)
7074 is_ifunc
= ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
;
7075 while ((p
= *pp
) != NULL
)
7077 if (p
->sec
== sec
&& p
->ifunc
== is_ifunc
)
7088 /* xgettext:c-format */
7089 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
7091 bfd_set_error (bfd_error_bad_value
);
7095 /* Remove unused Official Procedure Descriptor entries. Currently we
7096 only remove those associated with functions in discarded link-once
7097 sections, or weakly defined functions that have been overridden. It
7098 would be possible to remove many more entries for statically linked
7102 ppc64_elf_edit_opd (struct bfd_link_info
*info
)
7105 bfd_boolean some_edited
= FALSE
;
7106 asection
*need_pad
= NULL
;
7107 struct ppc_link_hash_table
*htab
;
7109 htab
= ppc_hash_table (info
);
7113 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7116 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7117 Elf_Internal_Shdr
*symtab_hdr
;
7118 Elf_Internal_Sym
*local_syms
;
7119 struct _opd_sec_data
*opd
;
7120 bfd_boolean need_edit
, add_aux_fields
, broken
;
7121 bfd_size_type cnt_16b
= 0;
7123 if (!is_ppc64_elf (ibfd
))
7126 sec
= bfd_get_section_by_name (ibfd
, ".opd");
7127 if (sec
== NULL
|| sec
->size
== 0)
7130 if (sec
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
7133 if (sec
->output_section
== bfd_abs_section_ptr
)
7136 /* Look through the section relocs. */
7137 if ((sec
->flags
& SEC_RELOC
) == 0 || sec
->reloc_count
== 0)
7141 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7143 /* Read the relocations. */
7144 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7146 if (relstart
== NULL
)
7149 /* First run through the relocs to check they are sane, and to
7150 determine whether we need to edit this opd section. */
7154 relend
= relstart
+ sec
->reloc_count
;
7155 for (rel
= relstart
; rel
< relend
; )
7157 enum elf_ppc64_reloc_type r_type
;
7158 unsigned long r_symndx
;
7160 struct elf_link_hash_entry
*h
;
7161 Elf_Internal_Sym
*sym
;
7164 /* .opd contains an array of 16 or 24 byte entries. We're
7165 only interested in the reloc pointing to a function entry
7167 offset
= rel
->r_offset
;
7168 if (rel
+ 1 == relend
7169 || rel
[1].r_offset
!= offset
+ 8)
7171 /* If someone messes with .opd alignment then after a
7172 "ld -r" we might have padding in the middle of .opd.
7173 Also, there's nothing to prevent someone putting
7174 something silly in .opd with the assembler. No .opd
7175 optimization for them! */
7178 (_("%pB: .opd is not a regular array of opd entries"), ibfd
);
7183 if ((r_type
= ELF64_R_TYPE (rel
->r_info
)) != R_PPC64_ADDR64
7184 || (r_type
= ELF64_R_TYPE ((rel
+ 1)->r_info
)) != R_PPC64_TOC
)
7187 /* xgettext:c-format */
7188 (_("%pB: unexpected reloc type %u in .opd section"),
7194 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7195 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7199 if (sym_sec
== NULL
|| sym_sec
->owner
== NULL
)
7201 const char *sym_name
;
7203 sym_name
= h
->root
.root
.string
;
7205 sym_name
= bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
,
7209 /* xgettext:c-format */
7210 (_("%pB: undefined sym `%s' in .opd section"),
7216 /* opd entries are always for functions defined in the
7217 current input bfd. If the symbol isn't defined in the
7218 input bfd, then we won't be using the function in this
7219 bfd; It must be defined in a linkonce section in another
7220 bfd, or is weak. It's also possible that we are
7221 discarding the function due to a linker script /DISCARD/,
7222 which we test for via the output_section. */
7223 if (sym_sec
->owner
!= ibfd
7224 || sym_sec
->output_section
== bfd_abs_section_ptr
)
7228 if (rel
+ 1 == relend
7229 || (rel
+ 2 < relend
7230 && ELF64_R_TYPE (rel
[2].r_info
) == R_PPC64_TOC
))
7235 if (sec
->size
== offset
+ 24)
7240 if (sec
->size
== offset
+ 16)
7247 else if (rel
+ 1 < relend
7248 && ELF64_R_TYPE (rel
[0].r_info
) == R_PPC64_ADDR64
7249 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOC
)
7251 if (rel
[0].r_offset
== offset
+ 16)
7253 else if (rel
[0].r_offset
!= offset
+ 24)
7260 add_aux_fields
= htab
->params
->non_overlapping_opd
&& cnt_16b
> 0;
7262 if (!broken
&& (need_edit
|| add_aux_fields
))
7264 Elf_Internal_Rela
*write_rel
;
7265 Elf_Internal_Shdr
*rel_hdr
;
7266 bfd_byte
*rptr
, *wptr
;
7267 bfd_byte
*new_contents
;
7270 new_contents
= NULL
;
7271 amt
= OPD_NDX (sec
->size
) * sizeof (long);
7272 opd
= &ppc64_elf_section_data (sec
)->u
.opd
;
7273 opd
->adjust
= bfd_zalloc (sec
->owner
, amt
);
7274 if (opd
->adjust
== NULL
)
7277 /* This seems a waste of time as input .opd sections are all
7278 zeros as generated by gcc, but I suppose there's no reason
7279 this will always be so. We might start putting something in
7280 the third word of .opd entries. */
7281 if ((sec
->flags
& SEC_IN_MEMORY
) == 0)
7284 if (!bfd_malloc_and_get_section (ibfd
, sec
, &loc
))
7288 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7290 if (elf_section_data (sec
)->relocs
!= relstart
)
7294 sec
->contents
= loc
;
7295 sec
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7298 elf_section_data (sec
)->relocs
= relstart
;
7300 new_contents
= sec
->contents
;
7303 new_contents
= bfd_malloc (sec
->size
+ cnt_16b
* 8);
7304 if (new_contents
== NULL
)
7308 wptr
= new_contents
;
7309 rptr
= sec
->contents
;
7310 write_rel
= relstart
;
7311 for (rel
= relstart
; rel
< relend
; )
7313 unsigned long r_symndx
;
7315 struct elf_link_hash_entry
*h
;
7316 struct ppc_link_hash_entry
*fdh
= NULL
;
7317 Elf_Internal_Sym
*sym
;
7319 Elf_Internal_Rela
*next_rel
;
7322 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7323 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7328 if (next_rel
+ 1 == relend
7329 || (next_rel
+ 2 < relend
7330 && ELF64_R_TYPE (next_rel
[2].r_info
) == R_PPC64_TOC
))
7333 /* See if the .opd entry is full 24 byte or
7334 16 byte (with fd_aux entry overlapped with next
7337 if (next_rel
== relend
)
7339 if (sec
->size
== rel
->r_offset
+ 16)
7342 else if (next_rel
->r_offset
== rel
->r_offset
+ 16)
7346 && h
->root
.root
.string
[0] == '.')
7348 fdh
= ppc_elf_hash_entry (h
)->oh
;
7351 fdh
= ppc_follow_link (fdh
);
7352 if (fdh
->elf
.root
.type
!= bfd_link_hash_defined
7353 && fdh
->elf
.root
.type
!= bfd_link_hash_defweak
)
7358 skip
= (sym_sec
->owner
!= ibfd
7359 || sym_sec
->output_section
== bfd_abs_section_ptr
);
7362 if (fdh
!= NULL
&& sym_sec
->owner
== ibfd
)
7364 /* Arrange for the function descriptor sym
7366 fdh
->elf
.root
.u
.def
.value
= 0;
7367 fdh
->elf
.root
.u
.def
.section
= sym_sec
;
7369 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = -1;
7371 if (NO_OPD_RELOCS
|| bfd_link_relocatable (info
))
7376 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
7380 if (++rel
== next_rel
)
7383 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7384 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
7391 /* We'll be keeping this opd entry. */
7396 /* Redefine the function descriptor symbol to
7397 this location in the opd section. It is
7398 necessary to update the value here rather
7399 than using an array of adjustments as we do
7400 for local symbols, because various places
7401 in the generic ELF code use the value
7402 stored in u.def.value. */
7403 fdh
->elf
.root
.u
.def
.value
= wptr
- new_contents
;
7404 fdh
->adjust_done
= 1;
7407 /* Local syms are a bit tricky. We could
7408 tweak them as they can be cached, but
7409 we'd need to look through the local syms
7410 for the function descriptor sym which we
7411 don't have at the moment. So keep an
7412 array of adjustments. */
7413 adjust
= (wptr
- new_contents
) - (rptr
- sec
->contents
);
7414 opd
->adjust
[OPD_NDX (rel
->r_offset
)] = adjust
;
7417 memcpy (wptr
, rptr
, opd_ent_size
);
7418 wptr
+= opd_ent_size
;
7419 if (add_aux_fields
&& opd_ent_size
== 16)
7421 memset (wptr
, '\0', 8);
7425 /* We need to adjust any reloc offsets to point to the
7427 for ( ; rel
!= next_rel
; ++rel
)
7429 rel
->r_offset
+= adjust
;
7430 if (write_rel
!= rel
)
7431 memcpy (write_rel
, rel
, sizeof (*rel
));
7436 rptr
+= opd_ent_size
;
7439 sec
->size
= wptr
- new_contents
;
7440 sec
->reloc_count
= write_rel
- relstart
;
7443 free (sec
->contents
);
7444 sec
->contents
= new_contents
;
7447 /* Fudge the header size too, as this is used later in
7448 elf_bfd_final_link if we are emitting relocs. */
7449 rel_hdr
= _bfd_elf_single_rel_hdr (sec
);
7450 rel_hdr
->sh_size
= sec
->reloc_count
* rel_hdr
->sh_entsize
;
7453 else if (elf_section_data (sec
)->relocs
!= relstart
)
7456 if (local_syms
!= NULL
7457 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7459 if (!info
->keep_memory
)
7462 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7467 elf_link_hash_traverse (elf_hash_table (info
), adjust_opd_syms
, NULL
);
7469 /* If we are doing a final link and the last .opd entry is just 16 byte
7470 long, add a 8 byte padding after it. */
7471 if (need_pad
!= NULL
&& !bfd_link_relocatable (info
))
7475 if ((need_pad
->flags
& SEC_IN_MEMORY
) == 0)
7477 BFD_ASSERT (need_pad
->size
> 0);
7479 p
= bfd_malloc (need_pad
->size
+ 8);
7483 if (!bfd_get_section_contents (need_pad
->owner
, need_pad
,
7484 p
, 0, need_pad
->size
))
7487 need_pad
->contents
= p
;
7488 need_pad
->flags
|= (SEC_IN_MEMORY
| SEC_HAS_CONTENTS
);
7492 p
= bfd_realloc (need_pad
->contents
, need_pad
->size
+ 8);
7496 need_pad
->contents
= p
;
7499 memset (need_pad
->contents
+ need_pad
->size
, 0, 8);
7500 need_pad
->size
+= 8;
7506 /* Analyze inline PLT call relocations to see whether calls to locally
7507 defined functions can be converted to direct calls. */
7510 ppc64_elf_inline_plt (struct bfd_link_info
*info
)
7512 struct ppc_link_hash_table
*htab
;
7515 bfd_vma low_vma
, high_vma
, limit
;
7517 htab
= ppc_hash_table (info
);
7521 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
7522 reduced somewhat to cater for possible stubs that might be added
7523 between the call and its destination. */
7524 if (htab
->params
->group_size
< 0)
7526 limit
= -htab
->params
->group_size
;
7532 limit
= htab
->params
->group_size
;
7539 for (sec
= info
->output_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7540 if ((sec
->flags
& (SEC_ALLOC
| SEC_CODE
)) == (SEC_ALLOC
| SEC_CODE
))
7542 if (low_vma
> sec
->vma
)
7544 if (high_vma
< sec
->vma
+ sec
->size
)
7545 high_vma
= sec
->vma
+ sec
->size
;
7548 /* If a "bl" can reach anywhere in local code sections, then we can
7549 convert all inline PLT sequences to direct calls when the symbol
7551 if (high_vma
- low_vma
< limit
)
7553 htab
->can_convert_all_inline_plt
= 1;
7557 /* Otherwise, go looking through relocs for cases where a direct
7558 call won't reach. Mark the symbol on any such reloc to disable
7559 the optimization and keep the PLT entry as it seems likely that
7560 this will be better than creating trampolines. Note that this
7561 will disable the optimization for all inline PLT calls to a
7562 particular symbol, not just those that won't reach. The
7563 difficulty in doing a more precise optimization is that the
7564 linker needs to make a decision depending on whether a
7565 particular R_PPC64_PLTCALL insn can be turned into a direct
7566 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
7567 the sequence, and there is nothing that ties those relocs
7568 together except their symbol. */
7570 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7572 Elf_Internal_Shdr
*symtab_hdr
;
7573 Elf_Internal_Sym
*local_syms
;
7575 if (!is_ppc64_elf (ibfd
))
7579 symtab_hdr
= &elf_symtab_hdr (ibfd
);
7581 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7582 if (ppc64_elf_section_data (sec
)->has_pltcall
7583 && !bfd_is_abs_section (sec
->output_section
))
7585 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7587 /* Read the relocations. */
7588 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7590 if (relstart
== NULL
)
7593 relend
= relstart
+ sec
->reloc_count
;
7594 for (rel
= relstart
; rel
< relend
; rel
++)
7596 enum elf_ppc64_reloc_type r_type
;
7597 unsigned long r_symndx
;
7599 struct elf_link_hash_entry
*h
;
7600 Elf_Internal_Sym
*sym
;
7601 unsigned char *tls_maskp
;
7603 r_type
= ELF64_R_TYPE (rel
->r_info
);
7604 if (r_type
!= R_PPC64_PLTCALL
7605 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
7608 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7609 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_maskp
, &local_syms
,
7612 if (elf_section_data (sec
)->relocs
!= relstart
)
7614 if (symtab_hdr
->contents
!= (bfd_byte
*) local_syms
)
7619 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
7623 to
= h
->root
.u
.def
.value
;
7626 to
+= (rel
->r_addend
7627 + sym_sec
->output_offset
7628 + sym_sec
->output_section
->vma
);
7629 from
= (rel
->r_offset
7630 + sec
->output_offset
7631 + sec
->output_section
->vma
);
7632 if (to
- from
+ limit
< 2 * limit
7633 && !(r_type
== R_PPC64_PLTCALL_NOTOC
7634 && (((h
? h
->other
: sym
->st_other
)
7635 & STO_PPC64_LOCAL_MASK
)
7636 > 1 << STO_PPC64_LOCAL_BIT
)))
7637 *tls_maskp
&= ~PLT_KEEP
;
7640 if (elf_section_data (sec
)->relocs
!= relstart
)
7644 if (local_syms
!= NULL
7645 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
7647 if (!info
->keep_memory
)
7650 symtab_hdr
->contents
= (unsigned char *) local_syms
;
7657 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7660 ppc64_elf_tls_setup (struct bfd_link_info
*info
)
7662 struct ppc_link_hash_table
*htab
;
7663 struct elf_link_hash_entry
*tga
, *tga_fd
, *desc
, *desc_fd
;
7665 htab
= ppc_hash_table (info
);
7669 if (abiversion (info
->output_bfd
) == 1)
7672 if (htab
->params
->no_multi_toc
)
7673 htab
->do_multi_toc
= 0;
7674 else if (!htab
->do_multi_toc
)
7675 htab
->params
->no_multi_toc
= 1;
7677 /* Default to --no-plt-localentry, as this option can cause problems
7678 with symbol interposition. For example, glibc libpthread.so and
7679 libc.so duplicate many pthread symbols, with a fallback
7680 implementation in libc.so. In some cases the fallback does more
7681 work than the pthread implementation. __pthread_condattr_destroy
7682 is one such symbol: the libpthread.so implementation is
7683 localentry:0 while the libc.so implementation is localentry:8.
7684 An app that "cleverly" uses dlopen to only load necessary
7685 libraries at runtime may omit loading libpthread.so when not
7686 running multi-threaded, which then results in the libc.so
7687 fallback symbols being used and ld.so complaining. Now there
7688 are workarounds in ld (see non_zero_localentry) to detect the
7689 pthread situation, but that may not be the only case where
7690 --plt-localentry can cause trouble. */
7691 if (htab
->params
->plt_localentry0
< 0)
7692 htab
->params
->plt_localentry0
= 0;
7693 if (htab
->params
->plt_localentry0
7694 && elf_link_hash_lookup (&htab
->elf
, "GLIBC_2.26",
7695 FALSE
, FALSE
, FALSE
) == NULL
)
7697 (_("warning: --plt-localentry is especially dangerous without "
7698 "ld.so support to detect ABI violations"));
7700 tga
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr",
7701 FALSE
, FALSE
, TRUE
);
7702 htab
->tls_get_addr
= ppc_elf_hash_entry (tga
);
7704 /* Move dynamic linking info to the function descriptor sym. */
7706 func_desc_adjust (tga
, info
);
7707 tga_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr",
7708 FALSE
, FALSE
, TRUE
);
7709 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (tga_fd
);
7711 desc
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_desc",
7712 FALSE
, FALSE
, TRUE
);
7713 htab
->tga_desc
= ppc_elf_hash_entry (desc
);
7715 func_desc_adjust (desc
, info
);
7716 desc_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_desc",
7717 FALSE
, FALSE
, TRUE
);
7718 htab
->tga_desc_fd
= ppc_elf_hash_entry (desc_fd
);
7720 if (htab
->params
->tls_get_addr_opt
)
7722 struct elf_link_hash_entry
*opt
, *opt_fd
;
7724 opt
= elf_link_hash_lookup (&htab
->elf
, ".__tls_get_addr_opt",
7725 FALSE
, FALSE
, TRUE
);
7727 func_desc_adjust (opt
, info
);
7728 opt_fd
= elf_link_hash_lookup (&htab
->elf
, "__tls_get_addr_opt",
7729 FALSE
, FALSE
, TRUE
);
7731 && (opt_fd
->root
.type
== bfd_link_hash_defined
7732 || opt_fd
->root
.type
== bfd_link_hash_defweak
))
7734 /* If glibc supports an optimized __tls_get_addr call stub,
7735 signalled by the presence of __tls_get_addr_opt, and we'll
7736 be calling __tls_get_addr via a plt call stub, then
7737 make __tls_get_addr point to __tls_get_addr_opt. */
7738 if (!(htab
->elf
.dynamic_sections_created
7740 && (tga_fd
->type
== STT_FUNC
7741 || tga_fd
->needs_plt
)
7742 && !(SYMBOL_CALLS_LOCAL (info
, tga_fd
)
7743 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, tga_fd
))))
7745 if (!(htab
->elf
.dynamic_sections_created
7747 && (desc_fd
->type
== STT_FUNC
7748 || desc_fd
->needs_plt
)
7749 && !(SYMBOL_CALLS_LOCAL (info
, desc_fd
)
7750 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, desc_fd
))))
7753 if (tga_fd
!= NULL
|| desc_fd
!= NULL
)
7755 struct plt_entry
*ent
= NULL
;
7758 for (ent
= tga_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7759 if (ent
->plt
.refcount
> 0)
7761 if (ent
== NULL
&& desc_fd
!= NULL
)
7762 for (ent
= desc_fd
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
7763 if (ent
->plt
.refcount
> 0)
7769 tga_fd
->root
.type
= bfd_link_hash_indirect
;
7770 tga_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7771 tga_fd
->root
.u
.i
.warning
= NULL
;
7772 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, tga_fd
);
7774 if (desc_fd
!= NULL
)
7776 desc_fd
->root
.type
= bfd_link_hash_indirect
;
7777 desc_fd
->root
.u
.i
.link
= &opt_fd
->root
;
7778 desc_fd
->root
.u
.i
.warning
= NULL
;
7779 ppc64_elf_copy_indirect_symbol (info
, opt_fd
, desc_fd
);
7782 if (opt_fd
->dynindx
!= -1)
7784 /* Use __tls_get_addr_opt in dynamic relocations. */
7785 opt_fd
->dynindx
= -1;
7786 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
7787 opt_fd
->dynstr_index
);
7788 if (!bfd_elf_link_record_dynamic_symbol (info
, opt_fd
))
7793 htab
->tls_get_addr_fd
= ppc_elf_hash_entry (opt_fd
);
7794 tga
= &htab
->tls_get_addr
->elf
;
7795 if (opt
!= NULL
&& tga
!= NULL
)
7797 tga
->root
.type
= bfd_link_hash_indirect
;
7798 tga
->root
.u
.i
.link
= &opt
->root
;
7799 tga
->root
.u
.i
.warning
= NULL
;
7800 ppc64_elf_copy_indirect_symbol (info
, opt
, tga
);
7802 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7804 htab
->tls_get_addr
= ppc_elf_hash_entry (opt
);
7806 htab
->tls_get_addr_fd
->oh
= htab
->tls_get_addr
;
7807 htab
->tls_get_addr_fd
->is_func_descriptor
= 1;
7808 if (htab
->tls_get_addr
!= NULL
)
7810 htab
->tls_get_addr
->oh
= htab
->tls_get_addr_fd
;
7811 htab
->tls_get_addr
->is_func
= 1;
7814 if (desc_fd
!= NULL
)
7816 htab
->tga_desc_fd
= ppc_elf_hash_entry (opt_fd
);
7817 if (opt
!= NULL
&& desc
!= NULL
)
7819 desc
->root
.type
= bfd_link_hash_indirect
;
7820 desc
->root
.u
.i
.link
= &opt
->root
;
7821 desc
->root
.u
.i
.warning
= NULL
;
7822 ppc64_elf_copy_indirect_symbol (info
, opt
, desc
);
7824 _bfd_elf_link_hash_hide_symbol (info
, opt
,
7825 desc
->forced_local
);
7826 htab
->tga_desc
= ppc_elf_hash_entry (opt
);
7828 htab
->tga_desc_fd
->oh
= htab
->tga_desc
;
7829 htab
->tga_desc_fd
->is_func_descriptor
= 1;
7830 if (htab
->tga_desc
!= NULL
)
7832 htab
->tga_desc
->oh
= htab
->tga_desc_fd
;
7833 htab
->tga_desc
->is_func
= 1;
7839 else if (htab
->params
->tls_get_addr_opt
< 0)
7840 htab
->params
->tls_get_addr_opt
= 0;
7843 if (htab
->tga_desc_fd
!= NULL
7844 && htab
->params
->tls_get_addr_opt
7845 && htab
->params
->no_tls_get_addr_regsave
== -1)
7846 htab
->params
->no_tls_get_addr_regsave
= 0;
7848 return _bfd_elf_tls_setup (info
->output_bfd
, info
);
7851 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7852 any of HASH1, HASH2, HASH3, or HASH4. */
7855 branch_reloc_hash_match (const bfd
*ibfd
,
7856 const Elf_Internal_Rela
*rel
,
7857 const struct ppc_link_hash_entry
*hash1
,
7858 const struct ppc_link_hash_entry
*hash2
,
7859 const struct ppc_link_hash_entry
*hash3
,
7860 const struct ppc_link_hash_entry
*hash4
)
7862 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (ibfd
);
7863 enum elf_ppc64_reloc_type r_type
= ELF64_R_TYPE (rel
->r_info
);
7864 unsigned int r_symndx
= ELF64_R_SYM (rel
->r_info
);
7866 if (r_symndx
>= symtab_hdr
->sh_info
&& is_branch_reloc (r_type
))
7868 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (ibfd
);
7869 struct elf_link_hash_entry
*h
;
7871 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
7872 h
= elf_follow_link (h
);
7873 if (h
== &hash1
->elf
|| h
== &hash2
->elf
7874 || h
== &hash3
->elf
|| h
== &hash4
->elf
)
7880 /* Run through all the TLS relocs looking for optimization
7881 opportunities. The linker has been hacked (see ppc64elf.em) to do
7882 a preliminary section layout so that we know the TLS segment
7883 offsets. We can't optimize earlier because some optimizations need
7884 to know the tp offset, and we need to optimize before allocating
7885 dynamic relocations. */
7888 ppc64_elf_tls_optimize (struct bfd_link_info
*info
)
7892 struct ppc_link_hash_table
*htab
;
7893 unsigned char *toc_ref
;
7896 if (!bfd_link_executable (info
))
7899 htab
= ppc_hash_table (info
);
7903 /* Make two passes over the relocs. On the first pass, mark toc
7904 entries involved with tls relocs, and check that tls relocs
7905 involved in setting up a tls_get_addr call are indeed followed by
7906 such a call. If they are not, we can't do any tls optimization.
7907 On the second pass twiddle tls_mask flags to notify
7908 relocate_section that optimization can be done, and adjust got
7909 and plt refcounts. */
7911 for (pass
= 0; pass
< 2; ++pass
)
7912 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
7914 Elf_Internal_Sym
*locsyms
= NULL
;
7915 asection
*toc
= bfd_get_section_by_name (ibfd
, ".toc");
7917 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7918 if (sec
->has_tls_reloc
&& !bfd_is_abs_section (sec
->output_section
))
7920 Elf_Internal_Rela
*relstart
, *rel
, *relend
;
7921 bfd_boolean found_tls_get_addr_arg
= 0;
7923 /* Read the relocations. */
7924 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
7926 if (relstart
== NULL
)
7932 relend
= relstart
+ sec
->reloc_count
;
7933 for (rel
= relstart
; rel
< relend
; rel
++)
7935 enum elf_ppc64_reloc_type r_type
;
7936 unsigned long r_symndx
;
7937 struct elf_link_hash_entry
*h
;
7938 Elf_Internal_Sym
*sym
;
7940 unsigned char *tls_mask
;
7941 unsigned int tls_set
, tls_clear
, tls_type
= 0;
7943 bfd_boolean ok_tprel
, is_local
;
7944 long toc_ref_index
= 0;
7945 int expecting_tls_get_addr
= 0;
7946 bfd_boolean ret
= FALSE
;
7948 r_symndx
= ELF64_R_SYM (rel
->r_info
);
7949 if (!get_sym_h (&h
, &sym
, &sym_sec
, &tls_mask
, &locsyms
,
7953 if (elf_section_data (sec
)->relocs
!= relstart
)
7956 if (elf_symtab_hdr (ibfd
).contents
7957 != (unsigned char *) locsyms
)
7964 if (h
->root
.type
== bfd_link_hash_defined
7965 || h
->root
.type
== bfd_link_hash_defweak
)
7966 value
= h
->root
.u
.def
.value
;
7967 else if (h
->root
.type
== bfd_link_hash_undefweak
)
7971 found_tls_get_addr_arg
= 0;
7976 /* Symbols referenced by TLS relocs must be of type
7977 STT_TLS. So no need for .opd local sym adjust. */
7978 value
= sym
->st_value
;
7981 is_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
7985 && h
->root
.type
== bfd_link_hash_undefweak
)
7987 else if (sym_sec
!= NULL
7988 && sym_sec
->output_section
!= NULL
)
7990 value
+= sym_sec
->output_offset
;
7991 value
+= sym_sec
->output_section
->vma
;
7992 value
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
7993 /* Note that even though the prefix insns
7994 allow a 1<<33 offset we use the same test
7995 as for addis;addi. There may be a mix of
7996 pcrel and non-pcrel code and the decision
7997 to optimise is per symbol, not per TLS
7999 ok_tprel
= value
+ 0x80008000ULL
< 1ULL << 32;
8003 r_type
= ELF64_R_TYPE (rel
->r_info
);
8004 /* If this section has old-style __tls_get_addr calls
8005 without marker relocs, then check that each
8006 __tls_get_addr call reloc is preceded by a reloc
8007 that conceivably belongs to the __tls_get_addr arg
8008 setup insn. If we don't find matching arg setup
8009 relocs, don't do any tls optimization. */
8011 && sec
->nomark_tls_get_addr
8013 && is_tls_get_addr (h
, htab
)
8014 && !found_tls_get_addr_arg
8015 && is_branch_reloc (r_type
))
8017 info
->callbacks
->minfo (_("%H __tls_get_addr lost arg, "
8018 "TLS optimization disabled\n"),
8019 ibfd
, sec
, rel
->r_offset
);
8024 found_tls_get_addr_arg
= 0;
8027 case R_PPC64_GOT_TLSLD16
:
8028 case R_PPC64_GOT_TLSLD16_LO
:
8029 case R_PPC64_GOT_TLSLD_PCREL34
:
8030 expecting_tls_get_addr
= 1;
8031 found_tls_get_addr_arg
= 1;
8034 case R_PPC64_GOT_TLSLD16_HI
:
8035 case R_PPC64_GOT_TLSLD16_HA
:
8036 /* These relocs should never be against a symbol
8037 defined in a shared lib. Leave them alone if
8038 that turns out to be the case. */
8045 tls_type
= TLS_TLS
| TLS_LD
;
8048 case R_PPC64_GOT_TLSGD16
:
8049 case R_PPC64_GOT_TLSGD16_LO
:
8050 case R_PPC64_GOT_TLSGD_PCREL34
:
8051 expecting_tls_get_addr
= 1;
8052 found_tls_get_addr_arg
= 1;
8055 case R_PPC64_GOT_TLSGD16_HI
:
8056 case R_PPC64_GOT_TLSGD16_HA
:
8062 tls_set
= TLS_TLS
| TLS_GDIE
;
8064 tls_type
= TLS_TLS
| TLS_GD
;
8067 case R_PPC64_GOT_TPREL_PCREL34
:
8068 case R_PPC64_GOT_TPREL16_DS
:
8069 case R_PPC64_GOT_TPREL16_LO_DS
:
8070 case R_PPC64_GOT_TPREL16_HI
:
8071 case R_PPC64_GOT_TPREL16_HA
:
8076 tls_clear
= TLS_TPREL
;
8077 tls_type
= TLS_TLS
| TLS_TPREL
;
8087 if (rel
+ 1 < relend
8088 && is_plt_seq_reloc (ELF64_R_TYPE (rel
[1].r_info
)))
8091 && (ELF64_R_TYPE (rel
[1].r_info
)
8093 && (ELF64_R_TYPE (rel
[1].r_info
)
8094 != R_PPC64_PLTSEQ_NOTOC
))
8096 r_symndx
= ELF64_R_SYM (rel
[1].r_info
);
8097 if (!get_sym_h (&h
, NULL
, NULL
, NULL
, &locsyms
,
8102 struct plt_entry
*ent
= NULL
;
8104 for (ent
= h
->plt
.plist
;
8107 if (ent
->addend
== rel
[1].r_addend
)
8111 && ent
->plt
.refcount
> 0)
8112 ent
->plt
.refcount
-= 1;
8117 found_tls_get_addr_arg
= 1;
8122 case R_PPC64_TOC16_LO
:
8123 if (sym_sec
== NULL
|| sym_sec
!= toc
)
8126 /* Mark this toc entry as referenced by a TLS
8127 code sequence. We can do that now in the
8128 case of R_PPC64_TLS, and after checking for
8129 tls_get_addr for the TOC16 relocs. */
8130 if (toc_ref
== NULL
)
8132 = bfd_zmalloc (toc
->output_section
->rawsize
/ 8);
8133 if (toc_ref
== NULL
)
8137 value
= h
->root
.u
.def
.value
;
8139 value
= sym
->st_value
;
8140 value
+= rel
->r_addend
;
8143 BFD_ASSERT (value
< toc
->size
8144 && toc
->output_offset
% 8 == 0);
8145 toc_ref_index
= (value
+ toc
->output_offset
) / 8;
8146 if (r_type
== R_PPC64_TLS
8147 || r_type
== R_PPC64_TLSGD
8148 || r_type
== R_PPC64_TLSLD
)
8150 toc_ref
[toc_ref_index
] = 1;
8154 if (pass
!= 0 && toc_ref
[toc_ref_index
] == 0)
8159 expecting_tls_get_addr
= 2;
8162 case R_PPC64_TPREL64
:
8166 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8171 tls_set
= TLS_EXPLICIT
;
8172 tls_clear
= TLS_TPREL
;
8177 case R_PPC64_DTPMOD64
:
8181 || !toc_ref
[(rel
->r_offset
+ toc
->output_offset
) / 8])
8183 if (rel
+ 1 < relend
8185 == ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
))
8186 && rel
[1].r_offset
== rel
->r_offset
+ 8)
8190 tls_set
= TLS_EXPLICIT
| TLS_GD
;
8193 tls_set
= TLS_EXPLICIT
| TLS_GD
| TLS_GDIE
;
8202 tls_set
= TLS_EXPLICIT
;
8213 if (!expecting_tls_get_addr
8214 || !sec
->nomark_tls_get_addr
)
8217 if (rel
+ 1 < relend
8218 && branch_reloc_hash_match (ibfd
, rel
+ 1,
8219 htab
->tls_get_addr_fd
,
8224 if (expecting_tls_get_addr
== 2)
8226 /* Check for toc tls entries. */
8227 unsigned char *toc_tls
;
8230 retval
= get_tls_mask (&toc_tls
, NULL
, NULL
,
8235 if (toc_tls
!= NULL
)
8237 if ((*toc_tls
& TLS_TLS
) != 0
8238 && ((*toc_tls
& (TLS_GD
| TLS_LD
)) != 0))
8239 found_tls_get_addr_arg
= 1;
8241 toc_ref
[toc_ref_index
] = 1;
8247 /* Uh oh, we didn't find the expected call. We
8248 could just mark this symbol to exclude it
8249 from tls optimization but it's safer to skip
8250 the entire optimization. */
8251 /* xgettext:c-format */
8252 info
->callbacks
->minfo (_("%H arg lost __tls_get_addr, "
8253 "TLS optimization disabled\n"),
8254 ibfd
, sec
, rel
->r_offset
);
8259 /* If we don't have old-style __tls_get_addr calls
8260 without TLSGD/TLSLD marker relocs, and we haven't
8261 found a new-style __tls_get_addr call with a
8262 marker for this symbol, then we either have a
8263 broken object file or an -mlongcall style
8264 indirect call to __tls_get_addr without a marker.
8265 Disable optimization in this case. */
8266 if ((tls_clear
& (TLS_GD
| TLS_LD
)) != 0
8267 && (tls_set
& TLS_EXPLICIT
) == 0
8268 && !sec
->nomark_tls_get_addr
8269 && ((*tls_mask
& (TLS_TLS
| TLS_MARK
))
8270 != (TLS_TLS
| TLS_MARK
)))
8273 if (expecting_tls_get_addr
== 1 + !sec
->nomark_tls_get_addr
)
8275 struct plt_entry
*ent
= NULL
;
8277 if (htab
->tls_get_addr_fd
!= NULL
)
8278 for (ent
= htab
->tls_get_addr_fd
->elf
.plt
.plist
;
8281 if (ent
->addend
== 0)
8284 if (ent
== NULL
&& htab
->tga_desc_fd
!= NULL
)
8285 for (ent
= htab
->tga_desc_fd
->elf
.plt
.plist
;
8288 if (ent
->addend
== 0)
8291 if (ent
== NULL
&& htab
->tls_get_addr
!= NULL
)
8292 for (ent
= htab
->tls_get_addr
->elf
.plt
.plist
;
8295 if (ent
->addend
== 0)
8298 if (ent
== NULL
&& htab
->tga_desc
!= NULL
)
8299 for (ent
= htab
->tga_desc
->elf
.plt
.plist
;
8302 if (ent
->addend
== 0)
8306 && ent
->plt
.refcount
> 0)
8307 ent
->plt
.refcount
-= 1;
8313 if ((tls_set
& TLS_EXPLICIT
) == 0)
8315 struct got_entry
*ent
;
8317 /* Adjust got entry for this reloc. */
8321 ent
= elf_local_got_ents (ibfd
)[r_symndx
];
8323 for (; ent
!= NULL
; ent
= ent
->next
)
8324 if (ent
->addend
== rel
->r_addend
8325 && ent
->owner
== ibfd
8326 && ent
->tls_type
== tls_type
)
8333 /* We managed to get rid of a got entry. */
8334 if (ent
->got
.refcount
> 0)
8335 ent
->got
.refcount
-= 1;
8340 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8341 we'll lose one or two dyn relocs. */
8342 if (!dec_dynrel_count (rel
->r_info
, sec
, info
,
8346 if (tls_set
== (TLS_EXPLICIT
| TLS_GD
))
8348 if (!dec_dynrel_count ((rel
+ 1)->r_info
, sec
, info
,
8354 *tls_mask
|= tls_set
& 0xff;
8355 *tls_mask
&= ~tls_clear
;
8358 if (elf_section_data (sec
)->relocs
!= relstart
)
8363 && (elf_symtab_hdr (ibfd
).contents
!= (unsigned char *) locsyms
))
8365 if (!info
->keep_memory
)
8368 elf_symtab_hdr (ibfd
).contents
= (unsigned char *) locsyms
;
8373 htab
->do_tls_opt
= 1;
8377 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8378 the values of any global symbols in a toc section that has been
8379 edited. Globals in toc sections should be a rarity, so this function
8380 sets a flag if any are found in toc sections other than the one just
8381 edited, so that further hash table traversals can be avoided. */
8383 struct adjust_toc_info
8386 unsigned long *skip
;
8387 bfd_boolean global_toc_syms
;
8390 enum toc_skip_enum
{ ref_from_discarded
= 1, can_optimize
= 2 };
8393 adjust_toc_syms (struct elf_link_hash_entry
*h
, void *inf
)
8395 struct ppc_link_hash_entry
*eh
;
8396 struct adjust_toc_info
*toc_inf
= (struct adjust_toc_info
*) inf
;
8399 if (h
->root
.type
!= bfd_link_hash_defined
8400 && h
->root
.type
!= bfd_link_hash_defweak
)
8403 eh
= ppc_elf_hash_entry (h
);
8404 if (eh
->adjust_done
)
8407 if (eh
->elf
.root
.u
.def
.section
== toc_inf
->toc
)
8409 if (eh
->elf
.root
.u
.def
.value
> toc_inf
->toc
->rawsize
)
8410 i
= toc_inf
->toc
->rawsize
>> 3;
8412 i
= eh
->elf
.root
.u
.def
.value
>> 3;
8414 if ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
8417 (_("%s defined on removed toc entry"), eh
->elf
.root
.root
.string
);
8420 while ((toc_inf
->skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0);
8421 eh
->elf
.root
.u
.def
.value
= (bfd_vma
) i
<< 3;
8424 eh
->elf
.root
.u
.def
.value
-= toc_inf
->skip
[i
];
8425 eh
->adjust_done
= 1;
8427 else if (strcmp (eh
->elf
.root
.u
.def
.section
->name
, ".toc") == 0)
8428 toc_inf
->global_toc_syms
= TRUE
;
8433 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8434 on a _LO variety toc/got reloc. */
8437 ok_lo_toc_insn (unsigned int insn
, enum elf_ppc64_reloc_type r_type
)
8439 return ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */
8440 || (insn
& (0x3fu
<< 26)) == 14u << 26 /* addi */
8441 || (insn
& (0x3fu
<< 26)) == 32u << 26 /* lwz */
8442 || (insn
& (0x3fu
<< 26)) == 34u << 26 /* lbz */
8443 || (insn
& (0x3fu
<< 26)) == 36u << 26 /* stw */
8444 || (insn
& (0x3fu
<< 26)) == 38u << 26 /* stb */
8445 || (insn
& (0x3fu
<< 26)) == 40u << 26 /* lhz */
8446 || (insn
& (0x3fu
<< 26)) == 42u << 26 /* lha */
8447 || (insn
& (0x3fu
<< 26)) == 44u << 26 /* sth */
8448 || (insn
& (0x3fu
<< 26)) == 46u << 26 /* lmw */
8449 || (insn
& (0x3fu
<< 26)) == 47u << 26 /* stmw */
8450 || (insn
& (0x3fu
<< 26)) == 48u << 26 /* lfs */
8451 || (insn
& (0x3fu
<< 26)) == 50u << 26 /* lfd */
8452 || (insn
& (0x3fu
<< 26)) == 52u << 26 /* stfs */
8453 || (insn
& (0x3fu
<< 26)) == 54u << 26 /* stfd */
8454 || (insn
& (0x3fu
<< 26)) == 56u << 26 /* lq,lfq */
8455 || ((insn
& (0x3fu
<< 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8456 /* Exclude lfqu by testing reloc. If relocs are ever
8457 defined for the reduced D field in psq_lu then those
8458 will need testing too. */
8459 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8460 || ((insn
& (0x3fu
<< 26)) == 58u << 26 /* ld,lwa */
8462 || (insn
& (0x3fu
<< 26)) == 60u << 26 /* stfq */
8463 || ((insn
& (0x3fu
<< 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8464 /* Exclude stfqu. psq_stu as above for psq_lu. */
8465 && r_type
!= R_PPC64_TOC16_LO
&& r_type
!= R_PPC64_GOT16_LO
)
8466 || ((insn
& (0x3fu
<< 26)) == 62u << 26 /* std,stq */
8467 && (insn
& 1) == 0));
8470 /* PCREL_OPT in one instance flags to the linker that a pair of insns:
8471 pld ra,symbol@got@pcrel
8472 load/store rt,off(ra)
8475 load/store rt,off(ra)
8476 may be translated to
8477 pload/pstore rt,symbol+off@pcrel
8479 This function returns true if the optimization is possible, placing
8480 the prefix insn in *PINSN1, a NOP in *PINSN2 and the offset in *POFF.
8482 On entry to this function, the linker has already determined that
8483 the pld can be replaced with pla: *PINSN1 is that pla insn,
8484 while *PINSN2 is the second instruction. */
8487 xlate_pcrel_opt (uint64_t *pinsn1
, uint64_t *pinsn2
, bfd_signed_vma
*poff
)
8489 uint64_t insn1
= *pinsn1
;
8490 uint64_t insn2
= *pinsn2
;
8493 if ((insn2
& (63ULL << 58)) == 1ULL << 58)
8495 /* Check that regs match. */
8496 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8499 /* P8LS or PMLS form, non-pcrel. */
8500 if ((insn2
& (-1ULL << 50) & ~(1ULL << 56)) != (1ULL << 58))
8503 *pinsn1
= (insn2
& ~(31 << 16) & ~0x3ffff0000ffffULL
) | (1ULL << 52);
8505 off
= ((insn2
>> 16) & 0x3ffff0000ULL
) | (insn2
& 0xffff);
8506 *poff
= (off
^ 0x200000000ULL
) - 0x200000000ULL
;
8512 /* Check that regs match. */
8513 if (((insn2
>> 16) & 31) != ((insn1
>> 21) & 31))
8516 switch ((insn2
>> 26) & 63)
8532 /* These are the PMLS cases, where we just need to tack a prefix
8534 insn1
= ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
8535 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8536 off
= insn2
& 0xffff;
8539 case 58: /* lwa, ld */
8540 if ((insn2
& 1) != 0)
8542 insn1
= ((1ULL << 58) | (1ULL << 52)
8543 | (insn2
& 2 ? 41ULL << 26 : 57ULL << 26)
8544 | (insn2
& (31ULL << 21)));
8545 off
= insn2
& 0xfffc;
8548 case 57: /* lxsd, lxssp */
8549 if ((insn2
& 3) < 2)
8551 insn1
= ((1ULL << 58) | (1ULL << 52)
8552 | ((40ULL | (insn2
& 3)) << 26)
8553 | (insn2
& (31ULL << 21)));
8554 off
= insn2
& 0xfffc;
8557 case 61: /* stxsd, stxssp, lxv, stxv */
8558 if ((insn2
& 3) == 0)
8560 else if ((insn2
& 3) >= 2)
8562 insn1
= ((1ULL << 58) | (1ULL << 52)
8563 | ((44ULL | (insn2
& 3)) << 26)
8564 | (insn2
& (31ULL << 21)));
8565 off
= insn2
& 0xfffc;
8569 insn1
= ((1ULL << 58) | (1ULL << 52)
8570 | ((50ULL | (insn2
& 4) | ((insn2
& 8) >> 3)) << 26)
8571 | (insn2
& (31ULL << 21)));
8572 off
= insn2
& 0xfff0;
8577 insn1
= ((1ULL << 58) | (1ULL << 52)
8578 | (insn2
& ((63ULL << 26) | (31ULL << 21))));
8579 off
= insn2
& 0xffff;
8582 case 6: /* lxvp, stxvp */
8583 if ((insn2
& 0xe) != 0)
8585 insn1
= ((1ULL << 58) | (1ULL << 52)
8586 | ((insn2
& 1) == 0 ? 58ULL << 26 : 62ULL << 26)
8587 | (insn2
& (31ULL << 21)));
8588 off
= insn2
& 0xfff0;
8591 case 62: /* std, stq */
8592 if ((insn2
& 1) != 0)
8594 insn1
= ((1ULL << 58) | (1ULL << 52)
8595 | ((insn2
& 2) == 0 ? 61ULL << 26 : 60ULL << 26)
8596 | (insn2
& (31ULL << 21)));
8597 off
= insn2
& 0xfffc;
8602 *pinsn2
= (uint64_t) NOP
<< 32;
8603 *poff
= (off
^ 0x8000) - 0x8000;
8607 /* Examine all relocs referencing .toc sections in order to remove
8608 unused .toc entries. */
8611 ppc64_elf_edit_toc (struct bfd_link_info
*info
)
8614 struct adjust_toc_info toc_inf
;
8615 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
8617 htab
->do_toc_opt
= 1;
8618 toc_inf
.global_toc_syms
= TRUE
;
8619 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
8621 asection
*toc
, *sec
;
8622 Elf_Internal_Shdr
*symtab_hdr
;
8623 Elf_Internal_Sym
*local_syms
;
8624 Elf_Internal_Rela
*relstart
, *rel
, *toc_relocs
;
8625 unsigned long *skip
, *drop
;
8626 unsigned char *used
;
8627 unsigned char *keep
, last
, some_unused
;
8629 if (!is_ppc64_elf (ibfd
))
8632 toc
= bfd_get_section_by_name (ibfd
, ".toc");
8635 || toc
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
8636 || discarded_section (toc
))
8641 symtab_hdr
= &elf_symtab_hdr (ibfd
);
8643 /* Look at sections dropped from the final link. */
8646 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
8648 if (sec
->reloc_count
== 0
8649 || !discarded_section (sec
)
8650 || get_opd_info (sec
)
8651 || (sec
->flags
& SEC_ALLOC
) == 0
8652 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8655 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
, FALSE
);
8656 if (relstart
== NULL
)
8659 /* Run through the relocs to see which toc entries might be
8661 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8663 enum elf_ppc64_reloc_type r_type
;
8664 unsigned long r_symndx
;
8666 struct elf_link_hash_entry
*h
;
8667 Elf_Internal_Sym
*sym
;
8670 r_type
= ELF64_R_TYPE (rel
->r_info
);
8677 case R_PPC64_TOC16_LO
:
8678 case R_PPC64_TOC16_HI
:
8679 case R_PPC64_TOC16_HA
:
8680 case R_PPC64_TOC16_DS
:
8681 case R_PPC64_TOC16_LO_DS
:
8685 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8686 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8694 val
= h
->root
.u
.def
.value
;
8696 val
= sym
->st_value
;
8697 val
+= rel
->r_addend
;
8699 if (val
>= toc
->size
)
8702 /* Anything in the toc ought to be aligned to 8 bytes.
8703 If not, don't mark as unused. */
8709 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8714 skip
[val
>> 3] = ref_from_discarded
;
8717 if (elf_section_data (sec
)->relocs
!= relstart
)
8721 /* For largetoc loads of address constants, we can convert
8722 . addis rx,2,addr@got@ha
8723 . ld ry,addr@got@l(rx)
8725 . addis rx,2,addr@toc@ha
8726 . addi ry,rx,addr@toc@l
8727 when addr is within 2G of the toc pointer. This then means
8728 that the word storing "addr" in the toc is no longer needed. */
8730 if (!ppc64_elf_tdata (ibfd
)->has_small_toc_reloc
8731 && toc
->output_section
->rawsize
< (bfd_vma
) 1 << 31
8732 && toc
->reloc_count
!= 0)
8734 /* Read toc relocs. */
8735 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
8737 if (toc_relocs
== NULL
)
8740 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
8742 enum elf_ppc64_reloc_type r_type
;
8743 unsigned long r_symndx
;
8745 struct elf_link_hash_entry
*h
;
8746 Elf_Internal_Sym
*sym
;
8749 r_type
= ELF64_R_TYPE (rel
->r_info
);
8750 if (r_type
!= R_PPC64_ADDR64
)
8753 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8754 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8759 || sym_sec
->output_section
== NULL
8760 || discarded_section (sym_sec
))
8763 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
8768 if (h
->type
== STT_GNU_IFUNC
)
8770 val
= h
->root
.u
.def
.value
;
8774 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
8776 val
= sym
->st_value
;
8778 val
+= rel
->r_addend
;
8779 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
8781 /* We don't yet know the exact toc pointer value, but we
8782 know it will be somewhere in the toc section. Don't
8783 optimize if the difference from any possible toc
8784 pointer is outside [ff..f80008000, 7fff7fff]. */
8785 addr
= toc
->output_section
->vma
+ TOC_BASE_OFF
;
8786 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8789 addr
= toc
->output_section
->vma
+ toc
->output_section
->rawsize
;
8790 if (val
- addr
+ (bfd_vma
) 0x80008000 >= (bfd_vma
) 1 << 32)
8795 skip
= bfd_zmalloc (sizeof (*skip
) * (toc
->size
+ 15) / 8);
8800 skip
[rel
->r_offset
>> 3]
8801 |= can_optimize
| ((rel
- toc_relocs
) << 2);
8808 used
= bfd_zmalloc (sizeof (*used
) * (toc
->size
+ 7) / 8);
8812 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
8815 && elf_section_data (sec
)->relocs
!= relstart
)
8817 if (elf_section_data (toc
)->relocs
!= toc_relocs
)
8823 /* Now check all kept sections that might reference the toc.
8824 Check the toc itself last. */
8825 for (sec
= (ibfd
->sections
== toc
&& toc
->next
? toc
->next
8828 sec
= (sec
== toc
? NULL
8829 : sec
->next
== NULL
? toc
8830 : sec
->next
== toc
&& toc
->next
? toc
->next
8835 if (sec
->reloc_count
== 0
8836 || discarded_section (sec
)
8837 || get_opd_info (sec
)
8838 || (sec
->flags
& SEC_ALLOC
) == 0
8839 || (sec
->flags
& SEC_DEBUGGING
) != 0)
8842 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
8844 if (relstart
== NULL
)
8850 /* Mark toc entries referenced as used. */
8854 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
8856 enum elf_ppc64_reloc_type r_type
;
8857 unsigned long r_symndx
;
8859 struct elf_link_hash_entry
*h
;
8860 Elf_Internal_Sym
*sym
;
8863 r_type
= ELF64_R_TYPE (rel
->r_info
);
8867 case R_PPC64_TOC16_LO
:
8868 case R_PPC64_TOC16_HI
:
8869 case R_PPC64_TOC16_HA
:
8870 case R_PPC64_TOC16_DS
:
8871 case R_PPC64_TOC16_LO_DS
:
8872 /* In case we're taking addresses of toc entries. */
8873 case R_PPC64_ADDR64
:
8880 r_symndx
= ELF64_R_SYM (rel
->r_info
);
8881 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
8892 val
= h
->root
.u
.def
.value
;
8894 val
= sym
->st_value
;
8895 val
+= rel
->r_addend
;
8897 if (val
>= toc
->size
)
8900 if ((skip
[val
>> 3] & can_optimize
) != 0)
8907 case R_PPC64_TOC16_HA
:
8910 case R_PPC64_TOC16_LO_DS
:
8911 off
= rel
->r_offset
;
8912 off
+= (bfd_big_endian (ibfd
) ? -2 : 3);
8913 if (!bfd_get_section_contents (ibfd
, sec
, &opc
,
8919 if ((opc
& (0x3f << 2)) == (58u << 2))
8924 /* Wrong sort of reloc, or not a ld. We may
8925 as well clear ref_from_discarded too. */
8932 /* For the toc section, we only mark as used if this
8933 entry itself isn't unused. */
8934 else if ((used
[rel
->r_offset
>> 3]
8935 || !(skip
[rel
->r_offset
>> 3] & ref_from_discarded
))
8938 /* Do all the relocs again, to catch reference
8947 if (elf_section_data (sec
)->relocs
!= relstart
)
8951 /* Merge the used and skip arrays. Assume that TOC
8952 doublewords not appearing as either used or unused belong
8953 to an entry more than one doubleword in size. */
8954 for (drop
= skip
, keep
= used
, last
= 0, some_unused
= 0;
8955 drop
< skip
+ (toc
->size
+ 7) / 8;
8960 *drop
&= ~ref_from_discarded
;
8961 if ((*drop
& can_optimize
) != 0)
8965 else if ((*drop
& ref_from_discarded
) != 0)
8968 last
= ref_from_discarded
;
8978 bfd_byte
*contents
, *src
;
8980 Elf_Internal_Sym
*sym
;
8981 bfd_boolean local_toc_syms
= FALSE
;
8983 /* Shuffle the toc contents, and at the same time convert the
8984 skip array from booleans into offsets. */
8985 if (!bfd_malloc_and_get_section (ibfd
, toc
, &contents
))
8988 elf_section_data (toc
)->this_hdr
.contents
= contents
;
8990 for (src
= contents
, off
= 0, drop
= skip
;
8991 src
< contents
+ toc
->size
;
8994 if ((*drop
& (can_optimize
| ref_from_discarded
)) != 0)
8999 memcpy (src
- off
, src
, 8);
9003 toc
->rawsize
= toc
->size
;
9004 toc
->size
= src
- contents
- off
;
9006 /* Adjust addends for relocs against the toc section sym,
9007 and optimize any accesses we can. */
9008 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9010 if (sec
->reloc_count
== 0
9011 || discarded_section (sec
))
9014 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9016 if (relstart
== NULL
)
9019 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9021 enum elf_ppc64_reloc_type r_type
;
9022 unsigned long r_symndx
;
9024 struct elf_link_hash_entry
*h
;
9027 r_type
= ELF64_R_TYPE (rel
->r_info
);
9034 case R_PPC64_TOC16_LO
:
9035 case R_PPC64_TOC16_HI
:
9036 case R_PPC64_TOC16_HA
:
9037 case R_PPC64_TOC16_DS
:
9038 case R_PPC64_TOC16_LO_DS
:
9039 case R_PPC64_ADDR64
:
9043 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9044 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9052 val
= h
->root
.u
.def
.value
;
9055 val
= sym
->st_value
;
9057 local_toc_syms
= TRUE
;
9060 val
+= rel
->r_addend
;
9062 if (val
> toc
->rawsize
)
9064 else if ((skip
[val
>> 3] & ref_from_discarded
) != 0)
9066 else if ((skip
[val
>> 3] & can_optimize
) != 0)
9068 Elf_Internal_Rela
*tocrel
9069 = toc_relocs
+ (skip
[val
>> 3] >> 2);
9070 unsigned long tsym
= ELF64_R_SYM (tocrel
->r_info
);
9074 case R_PPC64_TOC16_HA
:
9075 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_TOC16_HA
);
9078 case R_PPC64_TOC16_LO_DS
:
9079 rel
->r_info
= ELF64_R_INFO (tsym
, R_PPC64_LO_DS_OPT
);
9083 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
9085 info
->callbacks
->einfo
9086 /* xgettext:c-format */
9087 (_("%H: %s references "
9088 "optimized away TOC entry\n"),
9089 ibfd
, sec
, rel
->r_offset
,
9090 ppc64_elf_howto_table
[r_type
]->name
);
9091 bfd_set_error (bfd_error_bad_value
);
9094 rel
->r_addend
= tocrel
->r_addend
;
9095 elf_section_data (sec
)->relocs
= relstart
;
9099 if (h
!= NULL
|| sym
->st_value
!= 0)
9102 rel
->r_addend
-= skip
[val
>> 3];
9103 elf_section_data (sec
)->relocs
= relstart
;
9106 if (elf_section_data (sec
)->relocs
!= relstart
)
9110 /* We shouldn't have local or global symbols defined in the TOC,
9111 but handle them anyway. */
9112 if (local_syms
!= NULL
)
9113 for (sym
= local_syms
;
9114 sym
< local_syms
+ symtab_hdr
->sh_info
;
9116 if (sym
->st_value
!= 0
9117 && bfd_section_from_elf_index (ibfd
, sym
->st_shndx
) == toc
)
9121 if (sym
->st_value
> toc
->rawsize
)
9122 i
= toc
->rawsize
>> 3;
9124 i
= sym
->st_value
>> 3;
9126 if ((skip
[i
] & (ref_from_discarded
| can_optimize
)) != 0)
9130 (_("%s defined on removed toc entry"),
9131 bfd_elf_sym_name (ibfd
, symtab_hdr
, sym
, NULL
));
9134 while ((skip
[i
] & (ref_from_discarded
| can_optimize
)));
9135 sym
->st_value
= (bfd_vma
) i
<< 3;
9138 sym
->st_value
-= skip
[i
];
9139 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9142 /* Adjust any global syms defined in this toc input section. */
9143 if (toc_inf
.global_toc_syms
)
9146 toc_inf
.skip
= skip
;
9147 toc_inf
.global_toc_syms
= FALSE
;
9148 elf_link_hash_traverse (elf_hash_table (info
), adjust_toc_syms
,
9152 if (toc
->reloc_count
!= 0)
9154 Elf_Internal_Shdr
*rel_hdr
;
9155 Elf_Internal_Rela
*wrel
;
9158 /* Remove unused toc relocs, and adjust those we keep. */
9159 if (toc_relocs
== NULL
)
9160 toc_relocs
= _bfd_elf_link_read_relocs (ibfd
, toc
, NULL
, NULL
,
9162 if (toc_relocs
== NULL
)
9166 for (rel
= toc_relocs
; rel
< toc_relocs
+ toc
->reloc_count
; ++rel
)
9167 if ((skip
[rel
->r_offset
>> 3]
9168 & (ref_from_discarded
| can_optimize
)) == 0)
9170 wrel
->r_offset
= rel
->r_offset
- skip
[rel
->r_offset
>> 3];
9171 wrel
->r_info
= rel
->r_info
;
9172 wrel
->r_addend
= rel
->r_addend
;
9175 else if (!dec_dynrel_count (rel
->r_info
, toc
, info
,
9176 &local_syms
, NULL
, NULL
))
9179 elf_section_data (toc
)->relocs
= toc_relocs
;
9180 toc
->reloc_count
= wrel
- toc_relocs
;
9181 rel_hdr
= _bfd_elf_single_rel_hdr (toc
);
9182 sz
= rel_hdr
->sh_entsize
;
9183 rel_hdr
->sh_size
= toc
->reloc_count
* sz
;
9186 else if (elf_section_data (toc
)->relocs
!= toc_relocs
)
9189 if (local_syms
!= NULL
9190 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9192 if (!info
->keep_memory
)
9195 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9200 /* Look for cases where we can change an indirect GOT access to
9201 a GOT relative or PC relative access, possibly reducing the
9202 number of GOT entries. */
9203 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9206 Elf_Internal_Shdr
*symtab_hdr
;
9207 Elf_Internal_Sym
*local_syms
;
9208 Elf_Internal_Rela
*relstart
, *rel
;
9211 if (!is_ppc64_elf (ibfd
))
9214 if (!ppc64_elf_tdata (ibfd
)->has_optrel
)
9217 sec
= ppc64_elf_tdata (ibfd
)->got
;
9220 got
= sec
->output_section
->vma
+ sec
->output_offset
+ 0x8000;
9223 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9225 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
9227 if (sec
->reloc_count
== 0
9228 || !ppc64_elf_section_data (sec
)->has_optrel
9229 || discarded_section (sec
))
9232 relstart
= _bfd_elf_link_read_relocs (ibfd
, sec
, NULL
, NULL
,
9234 if (relstart
== NULL
)
9237 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9240 && elf_section_data (sec
)->relocs
!= relstart
)
9245 for (rel
= relstart
; rel
< relstart
+ sec
->reloc_count
; ++rel
)
9247 enum elf_ppc64_reloc_type r_type
;
9248 unsigned long r_symndx
;
9249 Elf_Internal_Sym
*sym
;
9251 struct elf_link_hash_entry
*h
;
9252 struct got_entry
*ent
;
9254 unsigned char buf
[8];
9256 enum {no_check
, check_lo
, check_ha
} insn_check
;
9258 r_type
= ELF64_R_TYPE (rel
->r_info
);
9262 insn_check
= no_check
;
9265 case R_PPC64_PLT16_HA
:
9266 case R_PPC64_GOT_TLSLD16_HA
:
9267 case R_PPC64_GOT_TLSGD16_HA
:
9268 case R_PPC64_GOT_TPREL16_HA
:
9269 case R_PPC64_GOT_DTPREL16_HA
:
9270 case R_PPC64_GOT16_HA
:
9271 case R_PPC64_TOC16_HA
:
9272 insn_check
= check_ha
;
9275 case R_PPC64_PLT16_LO
:
9276 case R_PPC64_PLT16_LO_DS
:
9277 case R_PPC64_GOT_TLSLD16_LO
:
9278 case R_PPC64_GOT_TLSGD16_LO
:
9279 case R_PPC64_GOT_TPREL16_LO_DS
:
9280 case R_PPC64_GOT_DTPREL16_LO_DS
:
9281 case R_PPC64_GOT16_LO
:
9282 case R_PPC64_GOT16_LO_DS
:
9283 case R_PPC64_TOC16_LO
:
9284 case R_PPC64_TOC16_LO_DS
:
9285 insn_check
= check_lo
;
9289 if (insn_check
!= no_check
)
9291 bfd_vma off
= rel
->r_offset
& ~3;
9293 if (!bfd_get_section_contents (ibfd
, sec
, buf
, off
, 4))
9296 insn
= bfd_get_32 (ibfd
, buf
);
9297 if (insn_check
== check_lo
9298 ? !ok_lo_toc_insn (insn
, r_type
)
9299 : ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9300 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9304 ppc64_elf_tdata (ibfd
)->unexpected_toc_insn
= 1;
9305 sprintf (str
, "%#08x", insn
);
9306 info
->callbacks
->einfo
9307 /* xgettext:c-format */
9308 (_("%H: got/toc optimization is not supported for"
9309 " %s instruction\n"),
9310 ibfd
, sec
, rel
->r_offset
& ~3, str
);
9317 /* Note that we don't delete GOT entries for
9318 R_PPC64_GOT16_DS since we'd need a lot more
9319 analysis. For starters, the preliminary layout is
9320 before the GOT, PLT, dynamic sections and stubs are
9321 laid out. Then we'd need to allow for changes in
9322 distance between sections caused by alignment. */
9326 case R_PPC64_GOT16_HA
:
9327 case R_PPC64_GOT16_LO_DS
:
9328 case R_PPC64_GOT_PCREL34
:
9332 r_symndx
= ELF64_R_SYM (rel
->r_info
);
9333 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
9338 || sym_sec
->output_section
== NULL
9339 || discarded_section (sym_sec
))
9342 if ((h
? h
->type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
9345 if (!SYMBOL_REFERENCES_LOCAL (info
, h
))
9349 val
= h
->root
.u
.def
.value
;
9351 val
= sym
->st_value
;
9352 val
+= rel
->r_addend
;
9353 val
+= sym_sec
->output_section
->vma
+ sym_sec
->output_offset
;
9355 /* Fudge factor to allow for the fact that the preliminary layout
9356 isn't exact. Reduce limits by this factor. */
9357 #define LIMIT_ADJUST(LIMIT) ((LIMIT) - (LIMIT) / 16)
9364 case R_PPC64_GOT16_HA
:
9365 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9366 >= LIMIT_ADJUST (0x100000000ULL
))
9369 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9370 rel
->r_offset
& ~3, 4))
9372 insn
= bfd_get_32 (ibfd
, buf
);
9373 if (((insn
& ((0x3fu
<< 26) | 0x1f << 16))
9374 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9378 case R_PPC64_GOT16_LO_DS
:
9379 if (val
- got
+ LIMIT_ADJUST (0x80008000ULL
)
9380 >= LIMIT_ADJUST (0x100000000ULL
))
9382 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9383 rel
->r_offset
& ~3, 4))
9385 insn
= bfd_get_32 (ibfd
, buf
);
9386 if ((insn
& (0x3fu
<< 26 | 0x3)) != 58u << 26 /* ld */)
9390 case R_PPC64_GOT_PCREL34
:
9392 pc
+= sec
->output_section
->vma
+ sec
->output_offset
;
9393 if (val
- pc
+ LIMIT_ADJUST (1ULL << 33)
9394 >= LIMIT_ADJUST (1ULL << 34))
9396 if (!bfd_get_section_contents (ibfd
, sec
, buf
,
9397 rel
->r_offset
& ~3, 8))
9399 insn
= bfd_get_32 (ibfd
, buf
);
9400 if ((insn
& (-1u << 18)) != ((1u << 26) | (1u << 20)))
9402 insn
= bfd_get_32 (ibfd
, buf
+ 4);
9403 if ((insn
& (0x3fu
<< 26)) != 57u << 26)
9413 struct got_entry
**local_got_ents
= elf_local_got_ents (ibfd
);
9414 ent
= local_got_ents
[r_symndx
];
9416 for (; ent
!= NULL
; ent
= ent
->next
)
9417 if (ent
->addend
== rel
->r_addend
9418 && ent
->owner
== ibfd
9419 && ent
->tls_type
== 0)
9421 BFD_ASSERT (ent
&& ent
->got
.refcount
> 0);
9422 ent
->got
.refcount
-= 1;
9425 if (elf_section_data (sec
)->relocs
!= relstart
)
9429 if (local_syms
!= NULL
9430 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
9432 if (!info
->keep_memory
)
9435 symtab_hdr
->contents
= (unsigned char *) local_syms
;
9442 /* Return true iff input section I references the TOC using
9443 instructions limited to +/-32k offsets. */
9446 ppc64_elf_has_small_toc_reloc (asection
*i
)
9448 return (is_ppc64_elf (i
->owner
)
9449 && ppc64_elf_tdata (i
->owner
)->has_small_toc_reloc
);
9452 /* Allocate space for one GOT entry. */
9455 allocate_got (struct elf_link_hash_entry
*h
,
9456 struct bfd_link_info
*info
,
9457 struct got_entry
*gent
)
9459 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
9460 struct ppc_link_hash_entry
*eh
= ppc_elf_hash_entry (h
);
9461 int entsize
= (gent
->tls_type
& eh
->tls_mask
& (TLS_GD
| TLS_LD
)
9463 int rentsize
= (gent
->tls_type
& eh
->tls_mask
& TLS_GD
9464 ? 2 : 1) * sizeof (Elf64_External_Rela
);
9465 asection
*got
= ppc64_elf_tdata (gent
->owner
)->got
;
9467 gent
->got
.offset
= got
->size
;
9468 got
->size
+= entsize
;
9470 if (h
->type
== STT_GNU_IFUNC
)
9472 htab
->elf
.irelplt
->size
+= rentsize
;
9473 htab
->got_reli_size
+= rentsize
;
9475 else if (((bfd_link_pic (info
)
9476 && !(gent
->tls_type
!= 0
9477 && bfd_link_executable (info
)
9478 && SYMBOL_REFERENCES_LOCAL (info
, h
)))
9479 || (htab
->elf
.dynamic_sections_created
9481 && !SYMBOL_REFERENCES_LOCAL (info
, h
)))
9482 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9484 asection
*relgot
= ppc64_elf_tdata (gent
->owner
)->relgot
;
9485 relgot
->size
+= rentsize
;
9489 /* This function merges got entries in the same toc group. */
9492 merge_got_entries (struct got_entry
**pent
)
9494 struct got_entry
*ent
, *ent2
;
9496 for (ent
= *pent
; ent
!= NULL
; ent
= ent
->next
)
9497 if (!ent
->is_indirect
)
9498 for (ent2
= ent
->next
; ent2
!= NULL
; ent2
= ent2
->next
)
9499 if (!ent2
->is_indirect
9500 && ent2
->addend
== ent
->addend
9501 && ent2
->tls_type
== ent
->tls_type
9502 && elf_gp (ent2
->owner
) == elf_gp (ent
->owner
))
9504 ent2
->is_indirect
= TRUE
;
9505 ent2
->got
.ent
= ent
;
9509 /* If H is undefined, make it dynamic if that makes sense. */
9512 ensure_undef_dynamic (struct bfd_link_info
*info
,
9513 struct elf_link_hash_entry
*h
)
9515 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
9517 if (htab
->dynamic_sections_created
9518 && ((info
->dynamic_undefined_weak
!= 0
9519 && h
->root
.type
== bfd_link_hash_undefweak
)
9520 || h
->root
.type
== bfd_link_hash_undefined
)
9523 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
9524 return bfd_elf_link_record_dynamic_symbol (info
, h
);
9528 /* Allocate space in .plt, .got and associated reloc sections for
9532 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
9534 struct bfd_link_info
*info
;
9535 struct ppc_link_hash_table
*htab
;
9537 struct ppc_link_hash_entry
*eh
;
9538 struct got_entry
**pgent
, *gent
;
9540 if (h
->root
.type
== bfd_link_hash_indirect
)
9543 info
= (struct bfd_link_info
*) inf
;
9544 htab
= ppc_hash_table (info
);
9548 eh
= ppc_elf_hash_entry (h
);
9549 /* Run through the TLS GD got entries first if we're changing them
9551 if ((eh
->tls_mask
& (TLS_TLS
| TLS_GDIE
)) == (TLS_TLS
| TLS_GDIE
))
9552 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9553 if (gent
->got
.refcount
> 0
9554 && (gent
->tls_type
& TLS_GD
) != 0)
9556 /* This was a GD entry that has been converted to TPREL. If
9557 there happens to be a TPREL entry we can use that one. */
9558 struct got_entry
*ent
;
9559 for (ent
= h
->got
.glist
; ent
!= NULL
; ent
= ent
->next
)
9560 if (ent
->got
.refcount
> 0
9561 && (ent
->tls_type
& TLS_TPREL
) != 0
9562 && ent
->addend
== gent
->addend
9563 && ent
->owner
== gent
->owner
)
9565 gent
->got
.refcount
= 0;
9569 /* If not, then we'll be using our own TPREL entry. */
9570 if (gent
->got
.refcount
!= 0)
9571 gent
->tls_type
= TLS_TLS
| TLS_TPREL
;
9574 /* Remove any list entry that won't generate a word in the GOT before
9575 we call merge_got_entries. Otherwise we risk merging to empty
9577 pgent
= &h
->got
.glist
;
9578 while ((gent
= *pgent
) != NULL
)
9579 if (gent
->got
.refcount
> 0)
9581 if ((gent
->tls_type
& TLS_LD
) != 0
9582 && SYMBOL_REFERENCES_LOCAL (info
, h
))
9584 ppc64_tlsld_got (gent
->owner
)->got
.refcount
+= 1;
9585 *pgent
= gent
->next
;
9588 pgent
= &gent
->next
;
9591 *pgent
= gent
->next
;
9593 if (!htab
->do_multi_toc
)
9594 merge_got_entries (&h
->got
.glist
);
9596 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
9597 if (!gent
->is_indirect
)
9599 /* Ensure we catch all the cases where this symbol should
9601 if (!ensure_undef_dynamic (info
, h
))
9604 if (!is_ppc64_elf (gent
->owner
))
9607 allocate_got (h
, info
, gent
);
9610 /* If no dynamic sections we can't have dynamic relocs, except for
9611 IFUNCs which are handled even in static executables. */
9612 if (!htab
->elf
.dynamic_sections_created
9613 && h
->type
!= STT_GNU_IFUNC
)
9614 h
->dyn_relocs
= NULL
;
9616 /* Discard relocs on undefined symbols that must be local. */
9617 else if (h
->root
.type
== bfd_link_hash_undefined
9618 && ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
9619 h
->dyn_relocs
= NULL
;
9621 /* Also discard relocs on undefined weak syms with non-default
9622 visibility, or when dynamic_undefined_weak says so. */
9623 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
9624 h
->dyn_relocs
= NULL
;
9626 if (h
->dyn_relocs
!= NULL
)
9628 struct elf_dyn_relocs
*p
, **pp
;
9630 /* In the shared -Bsymbolic case, discard space allocated for
9631 dynamic pc-relative relocs against symbols which turn out to
9632 be defined in regular objects. For the normal shared case,
9633 discard space for relocs that have become local due to symbol
9634 visibility changes. */
9635 if (bfd_link_pic (info
))
9637 /* Relocs that use pc_count are those that appear on a call
9638 insn, or certain REL relocs (see must_be_dyn_reloc) that
9639 can be generated via assembly. We want calls to
9640 protected symbols to resolve directly to the function
9641 rather than going via the plt. If people want function
9642 pointer comparisons to work as expected then they should
9643 avoid writing weird assembly. */
9644 if (SYMBOL_CALLS_LOCAL (info
, h
))
9646 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
9648 p
->count
-= p
->pc_count
;
9657 if (h
->dyn_relocs
!= NULL
)
9659 /* Ensure we catch all the cases where this symbol
9660 should be made dynamic. */
9661 if (!ensure_undef_dynamic (info
, h
))
9666 /* For a fixed position executable, discard space for
9667 relocs against symbols which are not dynamic. */
9668 else if (h
->type
!= STT_GNU_IFUNC
)
9670 if (h
->dynamic_adjusted
9672 && !ELF_COMMON_DEF_P (h
))
9674 /* Ensure we catch all the cases where this symbol
9675 should be made dynamic. */
9676 if (!ensure_undef_dynamic (info
, h
))
9679 /* But if that didn't work out, discard dynamic relocs. */
9680 if (h
->dynindx
== -1)
9681 h
->dyn_relocs
= NULL
;
9684 h
->dyn_relocs
= NULL
;
9687 /* Finally, allocate space. */
9688 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
9690 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
9691 if (eh
->elf
.type
== STT_GNU_IFUNC
)
9692 sreloc
= htab
->elf
.irelplt
;
9693 sreloc
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9697 /* We might need a PLT entry when the symbol
9700 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
9701 d) has plt16 relocs and we are linking statically. */
9702 if ((htab
->elf
.dynamic_sections_created
&& h
->dynindx
!= -1)
9703 || h
->type
== STT_GNU_IFUNC
9704 || (h
->needs_plt
&& h
->dynamic_adjusted
)
9707 && !htab
->elf
.dynamic_sections_created
9708 && !htab
->can_convert_all_inline_plt
9709 && (ppc_elf_hash_entry (h
)->tls_mask
9710 & (TLS_TLS
| PLT_KEEP
)) == PLT_KEEP
))
9712 struct plt_entry
*pent
;
9713 bfd_boolean doneone
= FALSE
;
9714 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9715 if (pent
->plt
.refcount
> 0)
9717 if (!htab
->elf
.dynamic_sections_created
9718 || h
->dynindx
== -1)
9720 if (h
->type
== STT_GNU_IFUNC
)
9723 pent
->plt
.offset
= s
->size
;
9724 s
->size
+= PLT_ENTRY_SIZE (htab
);
9725 s
= htab
->elf
.irelplt
;
9730 pent
->plt
.offset
= s
->size
;
9731 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
9732 s
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
9737 /* If this is the first .plt entry, make room for the special
9741 s
->size
+= PLT_INITIAL_ENTRY_SIZE (htab
);
9743 pent
->plt
.offset
= s
->size
;
9745 /* Make room for this entry. */
9746 s
->size
+= PLT_ENTRY_SIZE (htab
);
9748 /* Make room for the .glink code. */
9751 s
->size
+= GLINK_PLTRESOLVE_SIZE (htab
);
9754 /* We need bigger stubs past index 32767. */
9755 if (s
->size
>= GLINK_PLTRESOLVE_SIZE (htab
) + 32768*2*4)
9762 /* We also need to make an entry in the .rela.plt section. */
9763 s
= htab
->elf
.srelplt
;
9766 s
->size
+= sizeof (Elf64_External_Rela
);
9770 pent
->plt
.offset
= (bfd_vma
) -1;
9773 h
->plt
.plist
= NULL
;
9779 h
->plt
.plist
= NULL
;
9786 #define PPC_LO(v) ((v) & 0xffff)
9787 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9788 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9790 ((((v) & 0x3ffff0000ULL) << 16) | (v & 0xffff))
9791 #define HA34(v) ((v + (1ULL << 33)) >> 34)
9793 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9794 to set up space for global entry stubs. These are put in glink,
9795 after the branch table. */
9798 size_global_entry_stubs (struct elf_link_hash_entry
*h
, void *inf
)
9800 struct bfd_link_info
*info
;
9801 struct ppc_link_hash_table
*htab
;
9802 struct plt_entry
*pent
;
9805 if (h
->root
.type
== bfd_link_hash_indirect
)
9808 if (!h
->pointer_equality_needed
)
9815 htab
= ppc_hash_table (info
);
9819 s
= htab
->global_entry
;
9820 plt
= htab
->elf
.splt
;
9821 for (pent
= h
->plt
.plist
; pent
!= NULL
; pent
= pent
->next
)
9822 if (pent
->plt
.offset
!= (bfd_vma
) -1
9823 && pent
->addend
== 0)
9825 /* For ELFv2, if this symbol is not defined in a regular file
9826 and we are not generating a shared library or pie, then we
9827 need to define the symbol in the executable on a call stub.
9828 This is to avoid text relocations. */
9829 bfd_vma off
, stub_align
, stub_off
, stub_size
;
9830 unsigned int align_power
;
9834 if (htab
->params
->plt_stub_align
>= 0)
9835 align_power
= htab
->params
->plt_stub_align
;
9837 align_power
= -htab
->params
->plt_stub_align
;
9838 /* Setting section alignment is delayed until we know it is
9839 non-empty. Otherwise the .text output section will be
9840 aligned at least to plt_stub_align even when no global
9841 entry stubs are needed. */
9842 if (s
->alignment_power
< align_power
)
9843 s
->alignment_power
= align_power
;
9844 stub_align
= (bfd_vma
) 1 << align_power
;
9845 if (htab
->params
->plt_stub_align
>= 0
9846 || ((((stub_off
+ stub_size
- 1) & -stub_align
)
9847 - (stub_off
& -stub_align
))
9848 > ((stub_size
- 1) & -stub_align
)))
9849 stub_off
= (stub_off
+ stub_align
- 1) & -stub_align
;
9850 off
= pent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
9851 off
-= stub_off
+ s
->output_offset
+ s
->output_section
->vma
;
9852 /* Note that for --plt-stub-align negative we have a possible
9853 dependency between stub offset and size. Break that
9854 dependency by assuming the max stub size when calculating
9856 if (PPC_HA (off
) == 0)
9858 h
->root
.type
= bfd_link_hash_defined
;
9859 h
->root
.u
.def
.section
= s
;
9860 h
->root
.u
.def
.value
= stub_off
;
9861 s
->size
= stub_off
+ stub_size
;
9867 /* Set the sizes of the dynamic sections. */
9870 ppc64_elf_size_dynamic_sections (bfd
*output_bfd
,
9871 struct bfd_link_info
*info
)
9873 struct ppc_link_hash_table
*htab
;
9878 struct got_entry
*first_tlsld
;
9880 htab
= ppc_hash_table (info
);
9884 dynobj
= htab
->elf
.dynobj
;
9888 if (htab
->elf
.dynamic_sections_created
)
9890 /* Set the contents of the .interp section to the interpreter. */
9891 if (bfd_link_executable (info
) && !info
->nointerp
)
9893 s
= bfd_get_linker_section (dynobj
, ".interp");
9896 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
9897 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
9901 /* Set up .got offsets for local syms, and space for local dynamic
9903 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
9905 struct got_entry
**lgot_ents
;
9906 struct got_entry
**end_lgot_ents
;
9907 struct plt_entry
**local_plt
;
9908 struct plt_entry
**end_local_plt
;
9909 unsigned char *lgot_masks
;
9910 bfd_size_type locsymcount
;
9911 Elf_Internal_Shdr
*symtab_hdr
;
9913 if (!is_ppc64_elf (ibfd
))
9916 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
9918 struct ppc_dyn_relocs
*p
;
9920 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
9922 if (!bfd_is_abs_section (p
->sec
)
9923 && bfd_is_abs_section (p
->sec
->output_section
))
9925 /* Input section has been discarded, either because
9926 it is a copy of a linkonce section or due to
9927 linker script /DISCARD/, so we'll be discarding
9930 else if (p
->count
!= 0)
9932 asection
*srel
= elf_section_data (p
->sec
)->sreloc
;
9934 srel
= htab
->elf
.irelplt
;
9935 srel
->size
+= p
->count
* sizeof (Elf64_External_Rela
);
9936 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
9937 info
->flags
|= DF_TEXTREL
;
9942 lgot_ents
= elf_local_got_ents (ibfd
);
9946 symtab_hdr
= &elf_symtab_hdr (ibfd
);
9947 locsymcount
= symtab_hdr
->sh_info
;
9948 end_lgot_ents
= lgot_ents
+ locsymcount
;
9949 local_plt
= (struct plt_entry
**) end_lgot_ents
;
9950 end_local_plt
= local_plt
+ locsymcount
;
9951 lgot_masks
= (unsigned char *) end_local_plt
;
9952 s
= ppc64_elf_tdata (ibfd
)->got
;
9953 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
9955 struct got_entry
**pent
, *ent
;
9958 while ((ent
= *pent
) != NULL
)
9959 if (ent
->got
.refcount
> 0)
9961 if ((ent
->tls_type
& *lgot_masks
& TLS_LD
) != 0)
9963 ppc64_tlsld_got (ibfd
)->got
.refcount
+= 1;
9968 unsigned int ent_size
= 8;
9969 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
9971 ent
->got
.offset
= s
->size
;
9972 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
9977 s
->size
+= ent_size
;
9978 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
9980 htab
->elf
.irelplt
->size
+= rel_size
;
9981 htab
->got_reli_size
+= rel_size
;
9983 else if (bfd_link_pic (info
)
9984 && !(ent
->tls_type
!= 0
9985 && bfd_link_executable (info
)))
9987 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
9988 srel
->size
+= rel_size
;
9997 /* Allocate space for plt calls to local syms. */
9998 lgot_masks
= (unsigned char *) end_local_plt
;
9999 for (; local_plt
< end_local_plt
; ++local_plt
, ++lgot_masks
)
10001 struct plt_entry
*ent
;
10003 for (ent
= *local_plt
; ent
!= NULL
; ent
= ent
->next
)
10004 if (ent
->plt
.refcount
> 0)
10006 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
10008 s
= htab
->elf
.iplt
;
10009 ent
->plt
.offset
= s
->size
;
10010 s
->size
+= PLT_ENTRY_SIZE (htab
);
10011 htab
->elf
.irelplt
->size
+= sizeof (Elf64_External_Rela
);
10013 else if (htab
->can_convert_all_inline_plt
10014 || (*lgot_masks
& (TLS_TLS
| PLT_KEEP
)) != PLT_KEEP
)
10015 ent
->plt
.offset
= (bfd_vma
) -1;
10018 s
= htab
->pltlocal
;
10019 ent
->plt
.offset
= s
->size
;
10020 s
->size
+= LOCAL_PLT_ENTRY_SIZE (htab
);
10021 if (bfd_link_pic (info
))
10022 htab
->relpltlocal
->size
+= sizeof (Elf64_External_Rela
);
10026 ent
->plt
.offset
= (bfd_vma
) -1;
10030 /* Allocate global sym .plt and .got entries, and space for global
10031 sym dynamic relocs. */
10032 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
10034 if (!htab
->opd_abi
&& !bfd_link_pic (info
))
10035 elf_link_hash_traverse (&htab
->elf
, size_global_entry_stubs
, info
);
10037 first_tlsld
= NULL
;
10038 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10040 struct got_entry
*ent
;
10042 if (!is_ppc64_elf (ibfd
))
10045 ent
= ppc64_tlsld_got (ibfd
);
10046 if (ent
->got
.refcount
> 0)
10048 if (!htab
->do_multi_toc
&& first_tlsld
!= NULL
)
10050 ent
->is_indirect
= TRUE
;
10051 ent
->got
.ent
= first_tlsld
;
10055 if (first_tlsld
== NULL
)
10057 s
= ppc64_elf_tdata (ibfd
)->got
;
10058 ent
->got
.offset
= s
->size
;
10061 if (bfd_link_dll (info
))
10063 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
10064 srel
->size
+= sizeof (Elf64_External_Rela
);
10069 ent
->got
.offset
= (bfd_vma
) -1;
10072 /* We now have determined the sizes of the various dynamic sections.
10073 Allocate memory for them. */
10075 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
10077 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
10080 if (s
== htab
->brlt
|| s
== htab
->relbrlt
)
10081 /* These haven't been allocated yet; don't strip. */
10083 else if (s
== htab
->elf
.sgot
10084 || s
== htab
->elf
.splt
10085 || s
== htab
->elf
.iplt
10086 || s
== htab
->pltlocal
10087 || s
== htab
->glink
10088 || s
== htab
->global_entry
10089 || s
== htab
->elf
.sdynbss
10090 || s
== htab
->elf
.sdynrelro
)
10092 /* Strip this section if we don't need it; see the
10095 else if (s
== htab
->glink_eh_frame
)
10097 if (!bfd_is_abs_section (s
->output_section
))
10098 /* Not sized yet. */
10101 else if (CONST_STRNEQ (s
->name
, ".rela"))
10105 if (s
!= htab
->elf
.srelplt
)
10108 /* We use the reloc_count field as a counter if we need
10109 to copy relocs into the output file. */
10110 s
->reloc_count
= 0;
10115 /* It's not one of our sections, so don't allocate space. */
10121 /* If we don't need this section, strip it from the
10122 output file. This is mostly to handle .rela.bss and
10123 .rela.plt. We must create both sections in
10124 create_dynamic_sections, because they must be created
10125 before the linker maps input sections to output
10126 sections. The linker does that before
10127 adjust_dynamic_symbol is called, and it is that
10128 function which decides whether anything needs to go
10129 into these sections. */
10130 s
->flags
|= SEC_EXCLUDE
;
10134 if (bfd_is_abs_section (s
->output_section
))
10135 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10138 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
10141 /* Allocate memory for the section contents. We use bfd_zalloc
10142 here in case unused entries are not reclaimed before the
10143 section's contents are written out. This should not happen,
10144 but this way if it does we get a R_PPC64_NONE reloc in .rela
10145 sections instead of garbage.
10146 We also rely on the section contents being zero when writing
10147 the GOT and .dynrelro. */
10148 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
10149 if (s
->contents
== NULL
)
10153 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
10155 if (!is_ppc64_elf (ibfd
))
10158 s
= ppc64_elf_tdata (ibfd
)->got
;
10159 if (s
!= NULL
&& s
!= htab
->elf
.sgot
)
10162 s
->flags
|= SEC_EXCLUDE
;
10165 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10166 if (s
->contents
== NULL
)
10170 s
= ppc64_elf_tdata (ibfd
)->relgot
;
10174 s
->flags
|= SEC_EXCLUDE
;
10177 s
->contents
= bfd_zalloc (ibfd
, s
->size
);
10178 if (s
->contents
== NULL
)
10181 s
->reloc_count
= 0;
10186 if (htab
->elf
.dynamic_sections_created
)
10188 bfd_boolean tls_opt
;
10190 /* Add some entries to the .dynamic section. We fill in the
10191 values later, in ppc64_elf_finish_dynamic_sections, but we
10192 must add the entries now so that we get the correct size for
10193 the .dynamic section. The DT_DEBUG entry is filled in by the
10194 dynamic linker and used by the debugger. */
10195 #define add_dynamic_entry(TAG, VAL) \
10196 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10198 if (bfd_link_executable (info
))
10200 if (!add_dynamic_entry (DT_DEBUG
, 0))
10204 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0)
10206 if (!add_dynamic_entry (DT_PLTGOT
, 0)
10207 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
10208 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
10209 || !add_dynamic_entry (DT_JMPREL
, 0)
10210 || !add_dynamic_entry (DT_PPC64_GLINK
, 0))
10214 if (NO_OPD_RELOCS
&& abiversion (output_bfd
) <= 1)
10216 if (!add_dynamic_entry (DT_PPC64_OPD
, 0)
10217 || !add_dynamic_entry (DT_PPC64_OPDSZ
, 0))
10221 tls_opt
= (htab
->params
->tls_get_addr_opt
10222 && ((htab
->tls_get_addr_fd
!= NULL
10223 && htab
->tls_get_addr_fd
->elf
.plt
.plist
!= NULL
)
10224 || (htab
->tga_desc_fd
!= NULL
10225 && htab
->tga_desc_fd
->elf
.plt
.plist
!= NULL
)));
10226 if (tls_opt
|| !htab
->opd_abi
)
10228 if (!add_dynamic_entry (DT_PPC64_OPT
, tls_opt
? PPC64_OPT_TLS
: 0))
10234 if (!add_dynamic_entry (DT_RELA
, 0)
10235 || !add_dynamic_entry (DT_RELASZ
, 0)
10236 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
10239 /* If any dynamic relocs apply to a read-only section,
10240 then we need a DT_TEXTREL entry. */
10241 if ((info
->flags
& DF_TEXTREL
) == 0)
10242 elf_link_hash_traverse (&htab
->elf
,
10243 _bfd_elf_maybe_set_textrel
, info
);
10245 if ((info
->flags
& DF_TEXTREL
) != 0)
10247 if (!add_dynamic_entry (DT_TEXTREL
, 0))
10252 #undef add_dynamic_entry
10257 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10260 ppc64_elf_hash_symbol (struct elf_link_hash_entry
*h
)
10262 if (h
->plt
.plist
!= NULL
10264 && !h
->pointer_equality_needed
)
10267 return _bfd_elf_hash_symbol (h
);
10270 /* Determine the type of stub needed, if any, for a call. */
10272 static inline enum ppc_stub_type
10273 ppc_type_of_stub (asection
*input_sec
,
10274 const Elf_Internal_Rela
*rel
,
10275 struct ppc_link_hash_entry
**hash
,
10276 struct plt_entry
**plt_ent
,
10277 bfd_vma destination
,
10278 unsigned long local_off
)
10280 struct ppc_link_hash_entry
*h
= *hash
;
10282 bfd_vma branch_offset
;
10283 bfd_vma max_branch_offset
;
10284 enum elf_ppc64_reloc_type r_type
;
10288 struct plt_entry
*ent
;
10289 struct ppc_link_hash_entry
*fdh
= h
;
10291 && h
->oh
->is_func_descriptor
)
10293 fdh
= ppc_follow_link (h
->oh
);
10297 for (ent
= fdh
->elf
.plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
10298 if (ent
->addend
== rel
->r_addend
10299 && ent
->plt
.offset
!= (bfd_vma
) -1)
10302 return ppc_stub_plt_call
;
10305 /* Here, we know we don't have a plt entry. If we don't have a
10306 either a defined function descriptor or a defined entry symbol
10307 in a regular object file, then it is pointless trying to make
10308 any other type of stub. */
10309 if (!is_static_defined (&fdh
->elf
)
10310 && !is_static_defined (&h
->elf
))
10311 return ppc_stub_none
;
10313 else if (elf_local_got_ents (input_sec
->owner
) != NULL
)
10315 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_sec
->owner
);
10316 struct plt_entry
**local_plt
= (struct plt_entry
**)
10317 elf_local_got_ents (input_sec
->owner
) + symtab_hdr
->sh_info
;
10318 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
10320 if (local_plt
[r_symndx
] != NULL
)
10322 struct plt_entry
*ent
;
10324 for (ent
= local_plt
[r_symndx
]; ent
!= NULL
; ent
= ent
->next
)
10325 if (ent
->addend
== rel
->r_addend
10326 && ent
->plt
.offset
!= (bfd_vma
) -1)
10329 return ppc_stub_plt_call
;
10334 /* Determine where the call point is. */
10335 location
= (input_sec
->output_offset
10336 + input_sec
->output_section
->vma
10339 branch_offset
= destination
- location
;
10340 r_type
= ELF64_R_TYPE (rel
->r_info
);
10342 /* Determine if a long branch stub is needed. */
10343 max_branch_offset
= 1 << 25;
10344 if (r_type
== R_PPC64_REL14
10345 || r_type
== R_PPC64_REL14_BRTAKEN
10346 || r_type
== R_PPC64_REL14_BRNTAKEN
)
10347 max_branch_offset
= 1 << 15;
10349 if (branch_offset
+ max_branch_offset
>= 2 * max_branch_offset
- local_off
)
10350 /* We need a stub. Figure out whether a long_branch or plt_branch
10351 is needed later. */
10352 return ppc_stub_long_branch
;
10354 return ppc_stub_none
;
10357 /* Gets the address of a label (1:) in r11 and builds an offset in r12,
10358 then adds it to r11 (LOAD false) or loads r12 from r11+r12 (LOAD true).
10363 . lis %r12,xxx-1b@highest
10364 . ori %r12,%r12,xxx-1b@higher
10365 . sldi %r12,%r12,32
10366 . oris %r12,%r12,xxx-1b@high
10367 . ori %r12,%r12,xxx-1b@l
10368 . add/ldx %r12,%r11,%r12 */
10371 build_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, bfd_boolean load
)
10373 bfd_put_32 (abfd
, MFLR_R12
, p
);
10375 bfd_put_32 (abfd
, BCL_20_31
, p
);
10377 bfd_put_32 (abfd
, MFLR_R11
, p
);
10379 bfd_put_32 (abfd
, MTLR_R12
, p
);
10381 if (off
+ 0x8000 < 0x10000)
10384 bfd_put_32 (abfd
, LD_R12_0R11
+ PPC_LO (off
), p
);
10386 bfd_put_32 (abfd
, ADDI_R12_R11
+ PPC_LO (off
), p
);
10389 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10391 bfd_put_32 (abfd
, ADDIS_R12_R11
+ PPC_HA (off
), p
);
10394 bfd_put_32 (abfd
, LD_R12_0R12
+ PPC_LO (off
), p
);
10396 bfd_put_32 (abfd
, ADDI_R12_R12
+ PPC_LO (off
), p
);
10401 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10403 bfd_put_32 (abfd
, LI_R12_0
+ ((off
>> 32) & 0xffff), p
);
10408 bfd_put_32 (abfd
, LIS_R12
+ ((off
>> 48) & 0xffff), p
);
10410 if (((off
>> 32) & 0xffff) != 0)
10412 bfd_put_32 (abfd
, ORI_R12_R12_0
+ ((off
>> 32) & 0xffff), p
);
10416 if (((off
>> 32) & 0xffffffffULL
) != 0)
10418 bfd_put_32 (abfd
, SLDI_R12_R12_32
, p
);
10421 if (PPC_HI (off
) != 0)
10423 bfd_put_32 (abfd
, ORIS_R12_R12_0
+ PPC_HI (off
), p
);
10426 if (PPC_LO (off
) != 0)
10428 bfd_put_32 (abfd
, ORI_R12_R12_0
+ PPC_LO (off
), p
);
10432 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10434 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10440 static unsigned int
10441 size_offset (bfd_vma off
)
10444 if (off
+ 0x8000 < 0x10000)
10446 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10450 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10455 if (((off
>> 32) & 0xffff) != 0)
10458 if (((off
>> 32) & 0xffffffffULL
) != 0)
10460 if (PPC_HI (off
) != 0)
10462 if (PPC_LO (off
) != 0)
10469 static unsigned int
10470 num_relocs_for_offset (bfd_vma off
)
10472 unsigned int num_rel
;
10473 if (off
+ 0x8000 < 0x10000)
10475 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10480 if (off
+ 0x800000000000ULL
>= 0x1000000000000ULL
10481 && ((off
>> 32) & 0xffff) != 0)
10483 if (PPC_HI (off
) != 0)
10485 if (PPC_LO (off
) != 0)
10491 static Elf_Internal_Rela
*
10492 emit_relocs_for_offset (struct bfd_link_info
*info
, Elf_Internal_Rela
*r
,
10493 bfd_vma roff
, bfd_vma targ
, bfd_vma off
)
10495 bfd_vma relative_targ
= targ
- (roff
- 8);
10496 if (bfd_big_endian (info
->output_bfd
))
10498 r
->r_offset
= roff
;
10499 r
->r_addend
= relative_targ
+ roff
;
10500 if (off
+ 0x8000 < 0x10000)
10501 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16
);
10502 else if (off
+ 0x80008000ULL
< 0x100000000ULL
)
10504 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HA
);
10507 r
->r_offset
= roff
;
10508 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10509 r
->r_addend
= relative_targ
+ roff
;
10513 if (off
+ 0x800000000000ULL
< 0x1000000000000ULL
)
10514 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10517 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHEST
);
10518 if (((off
>> 32) & 0xffff) != 0)
10522 r
->r_offset
= roff
;
10523 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHER
);
10524 r
->r_addend
= relative_targ
+ roff
;
10527 if (((off
>> 32) & 0xffffffffULL
) != 0)
10529 if (PPC_HI (off
) != 0)
10533 r
->r_offset
= roff
;
10534 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGH
);
10535 r
->r_addend
= relative_targ
+ roff
;
10537 if (PPC_LO (off
) != 0)
10541 r
->r_offset
= roff
;
10542 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_LO
);
10543 r
->r_addend
= relative_targ
+ roff
;
10550 build_power10_offset (bfd
*abfd
, bfd_byte
*p
, bfd_vma off
, int odd
,
10554 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10559 bfd_put_32 (abfd
, NOP
, p
);
10565 insn
= PADDI_R12_PC
;
10567 bfd_put_32 (abfd
, insn
>> 32, p
);
10569 bfd_put_32 (abfd
, insn
, p
);
10571 /* The minimum value for paddi is -0x200000000. The minimum value
10572 for li is -0x8000, which when shifted by 34 and added gives a
10573 minimum value of -0x2000200000000. The maximum value is
10574 0x1ffffffff+0x7fff<<34 which is 0x2000200000000-1. */
10575 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10578 bfd_put_32 (abfd
, LI_R11_0
| (HA34 (off
) & 0xffff), p
);
10582 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10585 insn
= PADDI_R12_PC
| D34 (off
);
10586 bfd_put_32 (abfd
, insn
>> 32, p
);
10588 bfd_put_32 (abfd
, insn
, p
);
10592 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10596 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10598 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10603 bfd_put_32 (abfd
, LIS_R11
| ((HA34 (off
) >> 16) & 0x3fff), p
);
10605 bfd_put_32 (abfd
, ORI_R11_R11_0
| (HA34 (off
) & 0xffff), p
);
10609 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10612 insn
= PADDI_R12_PC
| D34 (off
);
10613 bfd_put_32 (abfd
, insn
>> 32, p
);
10615 bfd_put_32 (abfd
, insn
, p
);
10619 bfd_put_32 (abfd
, SLDI_R11_R11_34
, p
);
10623 bfd_put_32 (abfd
, LDX_R12_R11_R12
, p
);
10625 bfd_put_32 (abfd
, ADD_R12_R11_R12
, p
);
10631 static unsigned int
10632 size_power10_offset (bfd_vma off
, int odd
)
10634 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10636 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10642 static unsigned int
10643 num_relocs_for_power10_offset (bfd_vma off
, int odd
)
10645 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10647 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10653 static Elf_Internal_Rela
*
10654 emit_relocs_for_power10_offset (struct bfd_link_info
*info
,
10655 Elf_Internal_Rela
*r
, bfd_vma roff
,
10656 bfd_vma targ
, bfd_vma off
, int odd
)
10658 if (off
- odd
+ (1ULL << 33) < 1ULL << 34)
10660 else if (off
- (8 - odd
) + (0x20002ULL
<< 32) < 0x40004ULL
<< 32)
10662 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10663 r
->r_offset
= roff
+ d_offset
;
10664 r
->r_addend
= targ
+ 8 - odd
- d_offset
;
10665 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10671 int d_offset
= bfd_big_endian (info
->output_bfd
) ? 2 : 0;
10672 r
->r_offset
= roff
+ d_offset
;
10673 r
->r_addend
= targ
+ 8 + odd
- d_offset
;
10674 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHESTA34
);
10677 r
->r_offset
= roff
+ d_offset
;
10678 r
->r_addend
= targ
+ 4 + odd
- d_offset
;
10679 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL16_HIGHERA34
);
10683 r
->r_offset
= roff
;
10684 r
->r_addend
= targ
;
10685 r
->r_info
= ELF64_R_INFO (0, R_PPC64_PCREL34
);
10689 /* Emit .eh_frame opcode to advance pc by DELTA. */
10692 eh_advance (bfd
*abfd
, bfd_byte
*eh
, unsigned int delta
)
10696 *eh
++ = DW_CFA_advance_loc
+ delta
;
10697 else if (delta
< 256)
10699 *eh
++ = DW_CFA_advance_loc1
;
10702 else if (delta
< 65536)
10704 *eh
++ = DW_CFA_advance_loc2
;
10705 bfd_put_16 (abfd
, delta
, eh
);
10710 *eh
++ = DW_CFA_advance_loc4
;
10711 bfd_put_32 (abfd
, delta
, eh
);
10717 /* Size of required .eh_frame opcode to advance pc by DELTA. */
10719 static unsigned int
10720 eh_advance_size (unsigned int delta
)
10722 if (delta
< 64 * 4)
10723 /* DW_CFA_advance_loc+[1..63]. */
10725 if (delta
< 256 * 4)
10726 /* DW_CFA_advance_loc1, byte. */
10728 if (delta
< 65536 * 4)
10729 /* DW_CFA_advance_loc2, 2 bytes. */
10731 /* DW_CFA_advance_loc4, 4 bytes. */
10735 /* With power7 weakly ordered memory model, it is possible for ld.so
10736 to update a plt entry in one thread and have another thread see a
10737 stale zero toc entry. To avoid this we need some sort of acquire
10738 barrier in the call stub. One solution is to make the load of the
10739 toc word seem to appear to depend on the load of the function entry
10740 word. Another solution is to test for r2 being zero, and branch to
10741 the appropriate glink entry if so.
10743 . fake dep barrier compare
10744 . ld 12,xxx(2) ld 12,xxx(2)
10745 . mtctr 12 mtctr 12
10746 . xor 11,12,12 ld 2,xxx+8(2)
10747 . add 2,2,11 cmpldi 2,0
10748 . ld 2,xxx+8(2) bnectr+
10749 . bctr b <glink_entry>
10751 The solution involving the compare turns out to be faster, so
10752 that's what we use unless the branch won't reach. */
10754 #define ALWAYS_USE_FAKE_DEP 0
10755 #define ALWAYS_EMIT_R2SAVE 0
10757 static inline unsigned int
10758 plt_stub_size (struct ppc_link_hash_table
*htab
,
10759 struct ppc_stub_hash_entry
*stub_entry
,
10764 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
10766 if (htab
->power10_stubs
)
10768 bfd_vma start
= (stub_entry
->stub_offset
10769 + stub_entry
->group
->stub_sec
->output_offset
10770 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10771 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10773 size
= 8 + size_power10_offset (off
, start
& 4);
10776 size
= 8 + size_offset (off
- 8);
10777 if (stub_entry
->stub_type
> ppc_stub_plt_call_notoc
)
10783 if (ALWAYS_EMIT_R2SAVE
10784 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10786 if (PPC_HA (off
) != 0)
10791 if (htab
->params
->plt_static_chain
)
10793 if (htab
->params
->plt_thread_safe
10794 && htab
->elf
.dynamic_sections_created
10795 && stub_entry
->h
!= NULL
10796 && stub_entry
->h
->elf
.dynindx
!= -1)
10798 if (PPC_HA (off
+ 8 + 8 * htab
->params
->plt_static_chain
) != PPC_HA (off
))
10801 if (stub_entry
->h
!= NULL
10802 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10803 && htab
->params
->tls_get_addr_opt
)
10805 if (htab
->params
->no_tls_get_addr_regsave
)
10808 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10814 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10821 /* Depending on the sign of plt_stub_align:
10822 If positive, return the padding to align to a 2**plt_stub_align
10824 If negative, if this stub would cross fewer 2**plt_stub_align
10825 boundaries if we align, then return the padding needed to do so. */
10827 static inline unsigned int
10828 plt_stub_pad (struct ppc_link_hash_table
*htab
,
10829 struct ppc_stub_hash_entry
*stub_entry
,
10833 unsigned stub_size
;
10834 bfd_vma stub_off
= stub_entry
->group
->stub_sec
->size
;
10836 if (htab
->params
->plt_stub_align
>= 0)
10838 stub_align
= 1 << htab
->params
->plt_stub_align
;
10839 if ((stub_off
& (stub_align
- 1)) != 0)
10840 return stub_align
- (stub_off
& (stub_align
- 1));
10844 stub_align
= 1 << -htab
->params
->plt_stub_align
;
10845 stub_size
= plt_stub_size (htab
, stub_entry
, plt_off
);
10846 if (((stub_off
+ stub_size
- 1) & -stub_align
) - (stub_off
& -stub_align
)
10847 > ((stub_size
- 1) & -stub_align
))
10848 return stub_align
- (stub_off
& (stub_align
- 1));
10852 /* Build a .plt call stub. */
10854 static inline bfd_byte
*
10855 build_plt_stub (struct ppc_link_hash_table
*htab
,
10856 struct ppc_stub_hash_entry
*stub_entry
,
10857 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
10859 bfd
*obfd
= htab
->params
->stub_bfd
;
10860 bfd_boolean plt_load_toc
= htab
->opd_abi
;
10861 bfd_boolean plt_static_chain
= htab
->params
->plt_static_chain
;
10862 bfd_boolean plt_thread_safe
= (htab
->params
->plt_thread_safe
10863 && htab
->elf
.dynamic_sections_created
10864 && stub_entry
->h
!= NULL
10865 && stub_entry
->h
->elf
.dynindx
!= -1);
10866 bfd_boolean use_fake_dep
= plt_thread_safe
;
10867 bfd_vma cmp_branch_off
= 0;
10869 if (!ALWAYS_USE_FAKE_DEP
10872 && !(is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
10873 && htab
->params
->tls_get_addr_opt
))
10875 bfd_vma pltoff
= stub_entry
->plt_ent
->plt
.offset
& ~1;
10876 bfd_vma pltindex
= ((pltoff
- PLT_INITIAL_ENTRY_SIZE (htab
))
10877 / PLT_ENTRY_SIZE (htab
));
10878 bfd_vma glinkoff
= GLINK_PLTRESOLVE_SIZE (htab
) + pltindex
* 8;
10881 if (pltindex
> 32768)
10882 glinkoff
+= (pltindex
- 32768) * 4;
10884 + htab
->glink
->output_offset
10885 + htab
->glink
->output_section
->vma
);
10886 from
= (p
- stub_entry
->group
->stub_sec
->contents
10887 + 4 * (ALWAYS_EMIT_R2SAVE
10888 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10889 + 4 * (PPC_HA (offset
) != 0)
10890 + 4 * (PPC_HA (offset
+ 8 + 8 * plt_static_chain
)
10891 != PPC_HA (offset
))
10892 + 4 * (plt_static_chain
!= 0)
10894 + stub_entry
->group
->stub_sec
->output_offset
10895 + stub_entry
->group
->stub_sec
->output_section
->vma
);
10896 cmp_branch_off
= to
- from
;
10897 use_fake_dep
= cmp_branch_off
+ (1 << 25) >= (1 << 26);
10900 if (PPC_HA (offset
) != 0)
10904 if (ALWAYS_EMIT_R2SAVE
10905 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10906 r
[0].r_offset
+= 4;
10907 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
10908 r
[1].r_offset
= r
[0].r_offset
+ 4;
10909 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10910 r
[1].r_addend
= r
[0].r_addend
;
10913 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10915 r
[2].r_offset
= r
[1].r_offset
+ 4;
10916 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO
);
10917 r
[2].r_addend
= r
[0].r_addend
;
10921 r
[2].r_offset
= r
[1].r_offset
+ 8 + 8 * use_fake_dep
;
10922 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10923 r
[2].r_addend
= r
[0].r_addend
+ 8;
10924 if (plt_static_chain
)
10926 r
[3].r_offset
= r
[2].r_offset
+ 4;
10927 r
[3].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
10928 r
[3].r_addend
= r
[0].r_addend
+ 16;
10933 if (ALWAYS_EMIT_R2SAVE
10934 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10935 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10938 bfd_put_32 (obfd
, ADDIS_R11_R2
| PPC_HA (offset
), p
), p
+= 4;
10939 bfd_put_32 (obfd
, LD_R12_0R11
| PPC_LO (offset
), p
), p
+= 4;
10943 bfd_put_32 (obfd
, ADDIS_R12_R2
| PPC_HA (offset
), p
), p
+= 4;
10944 bfd_put_32 (obfd
, LD_R12_0R12
| PPC_LO (offset
), p
), p
+= 4;
10947 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10949 bfd_put_32 (obfd
, ADDI_R11_R11
| PPC_LO (offset
), p
), p
+= 4;
10952 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
10957 bfd_put_32 (obfd
, XOR_R2_R12_R12
, p
), p
+= 4;
10958 bfd_put_32 (obfd
, ADD_R11_R11_R2
, p
), p
+= 4;
10960 bfd_put_32 (obfd
, LD_R2_0R11
| PPC_LO (offset
+ 8), p
), p
+= 4;
10961 if (plt_static_chain
)
10962 bfd_put_32 (obfd
, LD_R11_0R11
| PPC_LO (offset
+ 16), p
), p
+= 4;
10969 if (ALWAYS_EMIT_R2SAVE
10970 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10971 r
[0].r_offset
+= 4;
10972 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10975 if (PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
10977 r
[1].r_offset
= r
[0].r_offset
+ 4;
10978 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16
);
10979 r
[1].r_addend
= r
[0].r_addend
;
10983 r
[1].r_offset
= r
[0].r_offset
+ 8 + 8 * use_fake_dep
;
10984 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10985 r
[1].r_addend
= r
[0].r_addend
+ 8 + 8 * plt_static_chain
;
10986 if (plt_static_chain
)
10988 r
[2].r_offset
= r
[1].r_offset
+ 4;
10989 r
[2].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
10990 r
[2].r_addend
= r
[0].r_addend
+ 8;
10995 if (ALWAYS_EMIT_R2SAVE
10996 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
10997 bfd_put_32 (obfd
, STD_R2_0R1
+ STK_TOC (htab
), p
), p
+= 4;
10998 bfd_put_32 (obfd
, LD_R12_0R2
| PPC_LO (offset
), p
), p
+= 4;
11000 && PPC_HA (offset
+ 8 + 8 * plt_static_chain
) != PPC_HA (offset
))
11002 bfd_put_32 (obfd
, ADDI_R2_R2
| PPC_LO (offset
), p
), p
+= 4;
11005 bfd_put_32 (obfd
, MTCTR_R12
, p
), p
+= 4;
11010 bfd_put_32 (obfd
, XOR_R11_R12_R12
, p
), p
+= 4;
11011 bfd_put_32 (obfd
, ADD_R2_R2_R11
, p
), p
+= 4;
11013 if (plt_static_chain
)
11014 bfd_put_32 (obfd
, LD_R11_0R2
| PPC_LO (offset
+ 16), p
), p
+= 4;
11015 bfd_put_32 (obfd
, LD_R2_0R2
| PPC_LO (offset
+ 8), p
), p
+= 4;
11018 if (plt_load_toc
&& plt_thread_safe
&& !use_fake_dep
)
11020 bfd_put_32 (obfd
, CMPLDI_R2_0
, p
), p
+= 4;
11021 bfd_put_32 (obfd
, BNECTR_P4
, p
), p
+= 4;
11022 bfd_put_32 (obfd
, B_DOT
| (cmp_branch_off
& 0x3fffffc), p
), p
+= 4;
11025 bfd_put_32 (obfd
, BCTR
, p
), p
+= 4;
11029 /* Build a special .plt call stub for __tls_get_addr. */
11031 #define LD_R0_0R3 0xe8030000
11032 #define LD_R12_0R3 0xe9830000
11033 #define MR_R0_R3 0x7c601b78
11034 #define CMPDI_R0_0 0x2c200000
11035 #define ADD_R3_R12_R13 0x7c6c6a14
11036 #define BEQLR 0x4d820020
11037 #define MR_R3_R0 0x7c030378
11038 #define BCTRL 0x4e800421
11040 static inline bfd_byte
*
11041 build_tls_get_addr_stub (struct ppc_link_hash_table
*htab
,
11042 struct ppc_stub_hash_entry
*stub_entry
,
11043 bfd_byte
*p
, bfd_vma offset
, Elf_Internal_Rela
*r
)
11045 bfd
*obfd
= htab
->params
->stub_bfd
;
11049 bfd_put_32 (obfd
, LD_R0_0R3
+ 0, p
), p
+= 4;
11050 bfd_put_32 (obfd
, LD_R12_0R3
+ 8, p
), p
+= 4;
11051 bfd_put_32 (obfd
, CMPDI_R0_0
, p
), p
+= 4;
11052 bfd_put_32 (obfd
, MR_R0_R3
, p
), p
+= 4;
11053 bfd_put_32 (obfd
, ADD_R3_R12_R13
, p
), p
+= 4;
11054 bfd_put_32 (obfd
, BEQLR
, p
), p
+= 4;
11055 bfd_put_32 (obfd
, MR_R3_R0
, p
), p
+= 4;
11056 if (htab
->params
->no_tls_get_addr_regsave
)
11059 r
[0].r_offset
+= 7 * 4;
11060 if (stub_entry
->stub_type
!= ppc_stub_plt_call_r2save
)
11061 return build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11063 bfd_put_32 (obfd
, MFLR_R0
, p
);
11065 bfd_put_32 (obfd
, STD_R0_0R1
+ STK_LINKER (htab
), p
);
11069 r
[0].r_offset
+= 2 * 4;
11070 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11071 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11073 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11075 bfd_put_32 (obfd
, LD_R0_0R1
+ STK_LINKER (htab
), p
);
11077 bfd_put_32 (obfd
, MTLR_R0
, p
);
11079 bfd_put_32 (obfd
, BLR
, p
);
11084 p
= tls_get_addr_prologue (obfd
, p
, htab
);
11087 r
[0].r_offset
+= 18 * 4;
11089 p
= build_plt_stub (htab
, stub_entry
, p
, offset
, r
);
11090 bfd_put_32 (obfd
, BCTRL
, p
- 4);
11092 if (stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
11094 bfd_put_32 (obfd
, LD_R2_0R1
+ STK_TOC (htab
), p
);
11098 p
= tls_get_addr_epilogue (obfd
, p
, htab
);
11101 if (htab
->glink_eh_frame
!= NULL
11102 && htab
->glink_eh_frame
->size
!= 0)
11104 bfd_byte
*base
, *eh
;
11106 base
= htab
->glink_eh_frame
->contents
+ stub_entry
->group
->eh_base
+ 17;
11107 eh
= base
+ stub_entry
->group
->eh_size
;
11108 if (htab
->params
->no_tls_get_addr_regsave
)
11110 unsigned int lr_used
, delta
;
11111 lr_used
= stub_entry
->stub_offset
+ (p
- 20 - loc
);
11112 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11113 stub_entry
->group
->lr_restore
= lr_used
+ 16;
11114 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11115 *eh
++ = DW_CFA_offset_extended_sf
;
11117 *eh
++ = -(STK_LINKER (htab
) / 8) & 0x7f;
11118 *eh
++ = DW_CFA_advance_loc
+ 4;
11122 unsigned int cfa_updt
, delta
;
11123 /* After the bctrl, lr has been modified so we need to emit
11124 .eh_frame info saying the return address is on the stack. In
11125 fact we must put the EH info at or before the call rather
11126 than after it, because the EH info for a call needs to be
11127 specified by that point.
11128 See libgcc/unwind-dw2.c execute_cfa_program.
11129 Any stack pointer update must be described immediately after
11130 the instruction making the change, and since the stdu occurs
11131 after saving regs we put all the reg saves and the cfa
11133 cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
11134 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
11135 stub_entry
->group
->lr_restore
11136 = stub_entry
->stub_offset
+ (p
- loc
) - 4;
11137 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11138 *eh
++ = DW_CFA_def_cfa_offset
;
11146 *eh
++ = DW_CFA_offset_extended_sf
;
11148 *eh
++ = (-16 / 8) & 0x7f;
11149 for (i
= 4; i
< 12; i
++)
11151 *eh
++ = DW_CFA_offset
+ i
;
11152 *eh
++ = (htab
->opd_abi
? 13 : 12) - i
;
11154 *eh
++ = (DW_CFA_advance_loc
11155 + (stub_entry
->group
->lr_restore
- 8 - cfa_updt
) / 4);
11156 *eh
++ = DW_CFA_def_cfa_offset
;
11158 for (i
= 4; i
< 12; i
++)
11159 *eh
++ = DW_CFA_restore
+ i
;
11160 *eh
++ = DW_CFA_advance_loc
+ 2;
11162 *eh
++ = DW_CFA_restore_extended
;
11164 stub_entry
->group
->eh_size
= eh
- base
;
11169 static Elf_Internal_Rela
*
11170 get_relocs (asection
*sec
, int count
)
11172 Elf_Internal_Rela
*relocs
;
11173 struct bfd_elf_section_data
*elfsec_data
;
11175 elfsec_data
= elf_section_data (sec
);
11176 relocs
= elfsec_data
->relocs
;
11177 if (relocs
== NULL
)
11179 bfd_size_type relsize
;
11180 relsize
= sec
->reloc_count
* sizeof (*relocs
);
11181 relocs
= bfd_alloc (sec
->owner
, relsize
);
11182 if (relocs
== NULL
)
11184 elfsec_data
->relocs
= relocs
;
11185 elfsec_data
->rela
.hdr
= bfd_zalloc (sec
->owner
,
11186 sizeof (Elf_Internal_Shdr
));
11187 if (elfsec_data
->rela
.hdr
== NULL
)
11189 elfsec_data
->rela
.hdr
->sh_size
= (sec
->reloc_count
11190 * sizeof (Elf64_External_Rela
));
11191 elfsec_data
->rela
.hdr
->sh_entsize
= sizeof (Elf64_External_Rela
);
11192 sec
->reloc_count
= 0;
11194 relocs
+= sec
->reloc_count
;
11195 sec
->reloc_count
+= count
;
11199 /* Convert the relocs R[0] thru R[-NUM_REL+1], which are all no-symbol
11200 forms, to the equivalent relocs against the global symbol given by
11204 use_global_in_relocs (struct ppc_link_hash_table
*htab
,
11205 struct ppc_stub_hash_entry
*stub_entry
,
11206 Elf_Internal_Rela
*r
, unsigned int num_rel
)
11208 struct elf_link_hash_entry
**hashes
;
11209 unsigned long symndx
;
11210 struct ppc_link_hash_entry
*h
;
11213 /* Relocs are always against symbols in their own object file. Fake
11214 up global sym hashes for the stub bfd (which has no symbols). */
11215 hashes
= elf_sym_hashes (htab
->params
->stub_bfd
);
11216 if (hashes
== NULL
)
11218 bfd_size_type hsize
;
11220 /* When called the first time, stub_globals will contain the
11221 total number of symbols seen during stub sizing. After
11222 allocating, stub_globals is used as an index to fill the
11224 hsize
= (htab
->stub_globals
+ 1) * sizeof (*hashes
);
11225 hashes
= bfd_zalloc (htab
->params
->stub_bfd
, hsize
);
11226 if (hashes
== NULL
)
11228 elf_sym_hashes (htab
->params
->stub_bfd
) = hashes
;
11229 htab
->stub_globals
= 1;
11231 symndx
= htab
->stub_globals
++;
11233 hashes
[symndx
] = &h
->elf
;
11234 if (h
->oh
!= NULL
&& h
->oh
->is_func
)
11235 h
= ppc_follow_link (h
->oh
);
11236 BFD_ASSERT (h
->elf
.root
.type
== bfd_link_hash_defined
11237 || h
->elf
.root
.type
== bfd_link_hash_defweak
);
11238 symval
= defined_sym_val (&h
->elf
);
11239 while (num_rel
-- != 0)
11241 r
->r_info
= ELF64_R_INFO (symndx
, ELF64_R_TYPE (r
->r_info
));
11242 if (h
->elf
.root
.u
.def
.section
!= stub_entry
->target_section
)
11244 /* H is an opd symbol. The addend must be zero, and the
11245 branch reloc is the only one we can convert. */
11250 r
->r_addend
-= symval
;
11257 get_r2off (struct bfd_link_info
*info
,
11258 struct ppc_stub_hash_entry
*stub_entry
)
11260 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
11261 bfd_vma r2off
= htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
;
11265 /* Support linking -R objects. Get the toc pointer from the
11268 if (!htab
->opd_abi
)
11270 asection
*opd
= stub_entry
->h
->elf
.root
.u
.def
.section
;
11271 bfd_vma opd_off
= stub_entry
->h
->elf
.root
.u
.def
.value
;
11273 if (strcmp (opd
->name
, ".opd") != 0
11274 || opd
->reloc_count
!= 0)
11276 info
->callbacks
->einfo
11277 (_("%P: cannot find opd entry toc for `%pT'\n"),
11278 stub_entry
->h
->elf
.root
.root
.string
);
11279 bfd_set_error (bfd_error_bad_value
);
11280 return (bfd_vma
) -1;
11282 if (!bfd_get_section_contents (opd
->owner
, opd
, buf
, opd_off
+ 8, 8))
11283 return (bfd_vma
) -1;
11284 r2off
= bfd_get_64 (opd
->owner
, buf
);
11285 r2off
-= elf_gp (info
->output_bfd
);
11287 r2off
-= htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
;
11292 ppc_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11294 struct ppc_stub_hash_entry
*stub_entry
;
11295 struct ppc_branch_hash_entry
*br_entry
;
11296 struct bfd_link_info
*info
;
11297 struct ppc_link_hash_table
*htab
;
11299 bfd_byte
*p
, *relp
;
11301 Elf_Internal_Rela
*r
;
11306 /* Massage our args to the form they really have. */
11307 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11310 /* Fail if the target section could not be assigned to an output
11311 section. The user should fix his linker script. */
11312 if (stub_entry
->target_section
!= NULL
11313 && stub_entry
->target_section
->output_section
== NULL
11314 && info
->non_contiguous_regions
)
11315 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
11316 "Retry without --enable-non-contiguous-regions.\n"),
11317 stub_entry
->target_section
);
11319 /* Same for the group. */
11320 if (stub_entry
->group
->stub_sec
!= NULL
11321 && stub_entry
->group
->stub_sec
->output_section
== NULL
11322 && info
->non_contiguous_regions
)
11323 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11324 "output section. Retry without "
11325 "--enable-non-contiguous-regions.\n"),
11326 stub_entry
->group
->stub_sec
,
11327 stub_entry
->target_section
);
11329 htab
= ppc_hash_table (info
);
11333 BFD_ASSERT (stub_entry
->stub_offset
>= stub_entry
->group
->stub_sec
->size
);
11334 loc
= stub_entry
->group
->stub_sec
->contents
+ stub_entry
->stub_offset
;
11336 htab
->stub_count
[stub_entry
->stub_type
- 1] += 1;
11337 switch (stub_entry
->stub_type
)
11339 case ppc_stub_long_branch
:
11340 case ppc_stub_long_branch_r2off
:
11341 /* Branches are relative. This is where we are going to. */
11342 targ
= (stub_entry
->target_value
11343 + stub_entry
->target_section
->output_offset
11344 + stub_entry
->target_section
->output_section
->vma
);
11345 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11347 /* And this is where we are coming from. */
11348 off
= (stub_entry
->stub_offset
11349 + stub_entry
->group
->stub_sec
->output_offset
11350 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11354 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11356 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11358 if (r2off
== (bfd_vma
) -1)
11360 htab
->stub_error
= TRUE
;
11363 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11365 if (PPC_HA (r2off
) != 0)
11367 bfd_put_32 (htab
->params
->stub_bfd
,
11368 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11371 if (PPC_LO (r2off
) != 0)
11373 bfd_put_32 (htab
->params
->stub_bfd
,
11374 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11379 bfd_put_32 (htab
->params
->stub_bfd
, B_DOT
| (off
& 0x3fffffc), p
);
11382 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11385 (_("long branch stub `%s' offset overflow"),
11386 stub_entry
->root
.string
);
11387 htab
->stub_error
= TRUE
;
11391 if (info
->emitrelocations
)
11393 r
= get_relocs (stub_entry
->group
->stub_sec
, 1);
11396 r
->r_offset
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11397 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11398 r
->r_addend
= targ
;
11399 if (stub_entry
->h
!= NULL
11400 && !use_global_in_relocs (htab
, stub_entry
, r
, 1))
11405 case ppc_stub_plt_branch
:
11406 case ppc_stub_plt_branch_r2off
:
11407 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11408 stub_entry
->root
.string
+ 9,
11410 if (br_entry
== NULL
)
11412 _bfd_error_handler (_("can't find branch stub `%s'"),
11413 stub_entry
->root
.string
);
11414 htab
->stub_error
= TRUE
;
11418 targ
= (stub_entry
->target_value
11419 + stub_entry
->target_section
->output_offset
11420 + stub_entry
->target_section
->output_section
->vma
);
11421 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11422 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11424 bfd_put_64 (htab
->brlt
->owner
, targ
,
11425 htab
->brlt
->contents
+ br_entry
->offset
);
11427 if (br_entry
->iter
== htab
->stub_iteration
)
11429 br_entry
->iter
= 0;
11431 if (htab
->relbrlt
!= NULL
)
11433 /* Create a reloc for the branch lookup table entry. */
11434 Elf_Internal_Rela rela
;
11437 rela
.r_offset
= (br_entry
->offset
11438 + htab
->brlt
->output_offset
11439 + htab
->brlt
->output_section
->vma
);
11440 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11441 rela
.r_addend
= targ
;
11443 rl
= htab
->relbrlt
->contents
;
11444 rl
+= (htab
->relbrlt
->reloc_count
++
11445 * sizeof (Elf64_External_Rela
));
11446 bfd_elf64_swap_reloca_out (htab
->relbrlt
->owner
, &rela
, rl
);
11448 else if (info
->emitrelocations
)
11450 r
= get_relocs (htab
->brlt
, 1);
11453 /* brlt, being SEC_LINKER_CREATED does not go through the
11454 normal reloc processing. Symbols and offsets are not
11455 translated from input file to output file form, so
11456 set up the offset per the output file. */
11457 r
->r_offset
= (br_entry
->offset
11458 + htab
->brlt
->output_offset
11459 + htab
->brlt
->output_section
->vma
);
11460 r
->r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
11461 r
->r_addend
= targ
;
11465 targ
= (br_entry
->offset
11466 + htab
->brlt
->output_offset
11467 + htab
->brlt
->output_section
->vma
);
11469 off
= (elf_gp (info
->output_bfd
)
11470 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11473 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11475 info
->callbacks
->einfo
11476 (_("%P: linkage table error against `%pT'\n"),
11477 stub_entry
->root
.string
);
11478 bfd_set_error (bfd_error_bad_value
);
11479 htab
->stub_error
= TRUE
;
11483 if (info
->emitrelocations
)
11485 r
= get_relocs (stub_entry
->group
->stub_sec
, 1 + (PPC_HA (off
) != 0));
11488 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11489 if (bfd_big_endian (info
->output_bfd
))
11490 r
[0].r_offset
+= 2;
11491 if (stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
)
11492 r
[0].r_offset
+= 4;
11493 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_DS
);
11494 r
[0].r_addend
= targ
;
11495 if (PPC_HA (off
) != 0)
11497 r
[0].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_HA
);
11498 r
[1].r_offset
= r
[0].r_offset
+ 4;
11499 r
[1].r_info
= ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS
);
11500 r
[1].r_addend
= r
[0].r_addend
;
11505 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11507 if (PPC_HA (off
) != 0)
11509 bfd_put_32 (htab
->params
->stub_bfd
,
11510 ADDIS_R12_R2
| PPC_HA (off
), p
);
11512 bfd_put_32 (htab
->params
->stub_bfd
,
11513 LD_R12_0R12
| PPC_LO (off
), p
);
11516 bfd_put_32 (htab
->params
->stub_bfd
,
11517 LD_R12_0R2
| PPC_LO (off
), p
);
11521 bfd_vma r2off
= get_r2off (info
, stub_entry
);
11523 if (r2off
== (bfd_vma
) -1)
11525 htab
->stub_error
= TRUE
;
11529 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11531 if (PPC_HA (off
) != 0)
11533 bfd_put_32 (htab
->params
->stub_bfd
,
11534 ADDIS_R12_R2
| PPC_HA (off
), p
);
11536 bfd_put_32 (htab
->params
->stub_bfd
,
11537 LD_R12_0R12
| PPC_LO (off
), p
);
11540 bfd_put_32 (htab
->params
->stub_bfd
, LD_R12_0R2
| PPC_LO (off
), p
);
11542 if (PPC_HA (r2off
) != 0)
11545 bfd_put_32 (htab
->params
->stub_bfd
,
11546 ADDIS_R2_R2
| PPC_HA (r2off
), p
);
11548 if (PPC_LO (r2off
) != 0)
11551 bfd_put_32 (htab
->params
->stub_bfd
,
11552 ADDI_R2_R2
| PPC_LO (r2off
), p
);
11556 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11558 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11562 case ppc_stub_long_branch_notoc
:
11563 case ppc_stub_long_branch_both
:
11564 case ppc_stub_plt_branch_notoc
:
11565 case ppc_stub_plt_branch_both
:
11566 case ppc_stub_plt_call_notoc
:
11567 case ppc_stub_plt_call_both
:
11569 off
= (stub_entry
->stub_offset
11570 + stub_entry
->group
->stub_sec
->output_offset
11571 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11572 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11573 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11574 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11577 bfd_put_32 (htab
->params
->stub_bfd
, STD_R2_0R1
+ STK_TOC (htab
), p
);
11580 if (stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
)
11582 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11583 if (targ
>= (bfd_vma
) -2)
11586 plt
= htab
->elf
.splt
;
11587 if (!htab
->elf
.dynamic_sections_created
11588 || stub_entry
->h
== NULL
11589 || stub_entry
->h
->elf
.dynindx
== -1)
11591 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11592 plt
= htab
->elf
.iplt
;
11594 plt
= htab
->pltlocal
;
11596 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11599 targ
= (stub_entry
->target_value
11600 + stub_entry
->target_section
->output_offset
11601 + stub_entry
->target_section
->output_section
->vma
);
11607 if (htab
->power10_stubs
)
11609 bfd_boolean load
= stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
;
11610 p
= build_power10_offset (htab
->params
->stub_bfd
, p
, off
, odd
, load
);
11614 /* The notoc stubs calculate their target (either a PLT entry or
11615 the global entry point of a function) relative to the PC
11616 returned by the "bcl" two instructions past the start of the
11617 sequence emitted by build_offset. The offset is therefore 8
11618 less than calculated from the start of the sequence. */
11620 p
= build_offset (htab
->params
->stub_bfd
, p
, off
,
11621 stub_entry
->stub_type
>= ppc_stub_plt_call_notoc
);
11624 if (stub_entry
->stub_type
<= ppc_stub_long_branch_both
)
11628 from
= (stub_entry
->stub_offset
11629 + stub_entry
->group
->stub_sec
->output_offset
11630 + stub_entry
->group
->stub_sec
->output_section
->vma
11632 bfd_put_32 (htab
->params
->stub_bfd
,
11633 B_DOT
| ((targ
- from
) & 0x3fffffc), p
);
11637 bfd_put_32 (htab
->params
->stub_bfd
, MTCTR_R12
, p
);
11639 bfd_put_32 (htab
->params
->stub_bfd
, BCTR
, p
);
11643 if (info
->emitrelocations
)
11645 bfd_vma roff
= relp
- stub_entry
->group
->stub_sec
->contents
;
11646 if (htab
->power10_stubs
)
11647 num_rel
+= num_relocs_for_power10_offset (off
, odd
);
11650 num_rel
+= num_relocs_for_offset (off
);
11653 r
= get_relocs (stub_entry
->group
->stub_sec
, num_rel
);
11656 if (htab
->power10_stubs
)
11657 r
= emit_relocs_for_power10_offset (info
, r
, roff
, targ
, off
, odd
);
11659 r
= emit_relocs_for_offset (info
, r
, roff
, targ
, off
);
11660 if (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
11661 || stub_entry
->stub_type
== ppc_stub_long_branch_both
)
11664 roff
= p
- 4 - stub_entry
->group
->stub_sec
->contents
;
11665 r
->r_offset
= roff
;
11666 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL24
);
11667 r
->r_addend
= targ
;
11668 if (stub_entry
->h
!= NULL
11669 && !use_global_in_relocs (htab
, stub_entry
, r
, num_rel
))
11674 if (!htab
->power10_stubs
11675 && htab
->glink_eh_frame
!= NULL
11676 && htab
->glink_eh_frame
->size
!= 0)
11678 bfd_byte
*base
, *eh
;
11679 unsigned int lr_used
, delta
;
11681 base
= (htab
->glink_eh_frame
->contents
11682 + stub_entry
->group
->eh_base
+ 17);
11683 eh
= base
+ stub_entry
->group
->eh_size
;
11684 lr_used
= stub_entry
->stub_offset
+ 8;
11685 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
11686 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
11687 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
11689 delta
= lr_used
- stub_entry
->group
->lr_restore
;
11690 stub_entry
->group
->lr_restore
= lr_used
+ 8;
11691 eh
= eh_advance (htab
->elf
.dynobj
, eh
, delta
);
11692 *eh
++ = DW_CFA_register
;
11695 *eh
++ = DW_CFA_advance_loc
+ 2;
11696 *eh
++ = DW_CFA_restore_extended
;
11698 stub_entry
->group
->eh_size
= eh
- base
;
11702 case ppc_stub_plt_call
:
11703 case ppc_stub_plt_call_r2save
:
11704 if (stub_entry
->h
!= NULL
11705 && stub_entry
->h
->is_func_descriptor
11706 && stub_entry
->h
->oh
!= NULL
)
11708 struct ppc_link_hash_entry
*fh
= ppc_follow_link (stub_entry
->h
->oh
);
11710 /* If the old-ABI "dot-symbol" is undefined make it weak so
11711 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11712 if (fh
->elf
.root
.type
== bfd_link_hash_undefined
11713 && (stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11714 || stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defweak
))
11715 fh
->elf
.root
.type
= bfd_link_hash_undefweak
;
11718 /* Now build the stub. */
11719 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
11720 if (targ
>= (bfd_vma
) -2)
11723 plt
= htab
->elf
.splt
;
11724 if (!htab
->elf
.dynamic_sections_created
11725 || stub_entry
->h
== NULL
11726 || stub_entry
->h
->elf
.dynindx
== -1)
11728 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
11729 plt
= htab
->elf
.iplt
;
11731 plt
= htab
->pltlocal
;
11733 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
11735 off
= (elf_gp (info
->output_bfd
)
11736 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11739 if (off
+ 0x80008000 > 0xffffffff || (off
& 7) != 0)
11741 info
->callbacks
->einfo
11742 /* xgettext:c-format */
11743 (_("%P: linkage table error against `%pT'\n"),
11744 stub_entry
->h
!= NULL
11745 ? stub_entry
->h
->elf
.root
.root
.string
11747 bfd_set_error (bfd_error_bad_value
);
11748 htab
->stub_error
= TRUE
;
11753 if (info
->emitrelocations
)
11755 r
= get_relocs (stub_entry
->group
->stub_sec
,
11756 ((PPC_HA (off
) != 0)
11758 ? 2 + (htab
->params
->plt_static_chain
11759 && PPC_HA (off
+ 16) == PPC_HA (off
))
11763 r
[0].r_offset
= loc
- stub_entry
->group
->stub_sec
->contents
;
11764 if (bfd_big_endian (info
->output_bfd
))
11765 r
[0].r_offset
+= 2;
11766 r
[0].r_addend
= targ
;
11768 if (stub_entry
->h
!= NULL
11769 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
11770 && htab
->params
->tls_get_addr_opt
)
11771 p
= build_tls_get_addr_stub (htab
, stub_entry
, loc
, off
, r
);
11773 p
= build_plt_stub (htab
, stub_entry
, loc
, off
, r
);
11776 case ppc_stub_save_res
:
11784 stub_entry
->group
->stub_sec
->size
= stub_entry
->stub_offset
+ (p
- loc
);
11786 if (htab
->params
->emit_stub_syms
)
11788 struct elf_link_hash_entry
*h
;
11791 const char *const stub_str
[] = { "long_branch",
11804 len1
= strlen (stub_str
[stub_entry
->stub_type
- 1]);
11805 len2
= strlen (stub_entry
->root
.string
);
11806 name
= bfd_malloc (len1
+ len2
+ 2);
11809 memcpy (name
, stub_entry
->root
.string
, 9);
11810 memcpy (name
+ 9, stub_str
[stub_entry
->stub_type
- 1], len1
);
11811 memcpy (name
+ len1
+ 9, stub_entry
->root
.string
+ 8, len2
- 8 + 1);
11812 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
11815 if (h
->root
.type
== bfd_link_hash_new
)
11817 h
->root
.type
= bfd_link_hash_defined
;
11818 h
->root
.u
.def
.section
= stub_entry
->group
->stub_sec
;
11819 h
->root
.u
.def
.value
= stub_entry
->stub_offset
;
11820 h
->ref_regular
= 1;
11821 h
->def_regular
= 1;
11822 h
->ref_regular_nonweak
= 1;
11823 h
->forced_local
= 1;
11825 h
->root
.linker_def
= 1;
11832 /* As above, but don't actually build the stub. Just bump offset so
11833 we know stub section sizes, and select plt_branch stubs where
11834 long_branch stubs won't do. */
11837 ppc_size_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
11839 struct ppc_stub_hash_entry
*stub_entry
;
11840 struct bfd_link_info
*info
;
11841 struct ppc_link_hash_table
*htab
;
11843 bfd_vma targ
, off
, r2off
;
11844 unsigned int size
, extra
, lr_used
, delta
, odd
;
11846 /* Massage our args to the form they really have. */
11847 stub_entry
= (struct ppc_stub_hash_entry
*) gen_entry
;
11850 htab
= ppc_hash_table (info
);
11854 /* Fail if the target section could not be assigned to an output
11855 section. The user should fix his linker script. */
11856 if (stub_entry
->target_section
!= NULL
11857 && stub_entry
->target_section
->output_section
== NULL
11858 && info
->non_contiguous_regions
)
11859 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output section. "
11860 "Retry without --enable-non-contiguous-regions.\n"),
11861 stub_entry
->target_section
);
11863 /* Same for the group. */
11864 if (stub_entry
->group
->stub_sec
!= NULL
11865 && stub_entry
->group
->stub_sec
->output_section
== NULL
11866 && info
->non_contiguous_regions
)
11867 info
->callbacks
->einfo (_("%F%P: Could not assign group %pA target %pA to an "
11868 "output section. Retry without "
11869 "--enable-non-contiguous-regions.\n"),
11870 stub_entry
->group
->stub_sec
,
11871 stub_entry
->target_section
);
11873 /* Make a note of the offset within the stubs for this entry. */
11874 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
11876 if (stub_entry
->h
!= NULL
11877 && stub_entry
->h
->save_res
11878 && stub_entry
->h
->elf
.root
.type
== bfd_link_hash_defined
11879 && stub_entry
->h
->elf
.root
.u
.def
.section
== htab
->sfpr
)
11881 /* Don't make stubs to out-of-line register save/restore
11882 functions. Instead, emit copies of the functions. */
11883 stub_entry
->group
->needs_save_res
= 1;
11884 stub_entry
->stub_type
= ppc_stub_save_res
;
11888 switch (stub_entry
->stub_type
)
11890 case ppc_stub_plt_branch
:
11891 case ppc_stub_plt_branch_r2off
:
11892 /* Reset the stub type from the plt branch variant in case we now
11893 can reach with a shorter stub. */
11894 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
11895 /* Fall through. */
11896 case ppc_stub_long_branch
:
11897 case ppc_stub_long_branch_r2off
:
11898 targ
= (stub_entry
->target_value
11899 + stub_entry
->target_section
->output_offset
11900 + stub_entry
->target_section
->output_section
->vma
);
11901 targ
+= PPC64_LOCAL_ENTRY_OFFSET (stub_entry
->other
);
11902 off
= (stub_entry
->stub_offset
11903 + stub_entry
->group
->stub_sec
->output_offset
11904 + stub_entry
->group
->stub_sec
->output_section
->vma
);
11908 if (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
)
11910 r2off
= get_r2off (info
, stub_entry
);
11911 if (r2off
== (bfd_vma
) -1)
11913 htab
->stub_error
= TRUE
;
11917 if (PPC_HA (r2off
) != 0)
11919 if (PPC_LO (r2off
) != 0)
11925 /* If the branch offset is too big, use a ppc_stub_plt_branch.
11926 Do the same for -R objects without function descriptors. */
11927 if ((stub_entry
->stub_type
== ppc_stub_long_branch_r2off
11929 && htab
->sec_info
[stub_entry
->target_section
->id
].toc_off
== 0)
11930 || off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
11932 struct ppc_branch_hash_entry
*br_entry
;
11934 br_entry
= ppc_branch_hash_lookup (&htab
->branch_hash_table
,
11935 stub_entry
->root
.string
+ 9,
11937 if (br_entry
== NULL
)
11939 _bfd_error_handler (_("can't build branch stub `%s'"),
11940 stub_entry
->root
.string
);
11941 htab
->stub_error
= TRUE
;
11945 if (br_entry
->iter
!= htab
->stub_iteration
)
11947 br_entry
->iter
= htab
->stub_iteration
;
11948 br_entry
->offset
= htab
->brlt
->size
;
11949 htab
->brlt
->size
+= 8;
11951 if (htab
->relbrlt
!= NULL
)
11952 htab
->relbrlt
->size
+= sizeof (Elf64_External_Rela
);
11953 else if (info
->emitrelocations
)
11955 htab
->brlt
->reloc_count
+= 1;
11956 htab
->brlt
->flags
|= SEC_RELOC
;
11960 targ
= (br_entry
->offset
11961 + htab
->brlt
->output_offset
11962 + htab
->brlt
->output_section
->vma
);
11963 off
= (elf_gp (info
->output_bfd
)
11964 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
11967 if (info
->emitrelocations
)
11969 stub_entry
->group
->stub_sec
->reloc_count
11970 += 1 + (PPC_HA (off
) != 0);
11971 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
11974 stub_entry
->stub_type
+= ppc_stub_plt_branch
- ppc_stub_long_branch
;
11975 if (stub_entry
->stub_type
!= ppc_stub_plt_branch_r2off
)
11978 if (PPC_HA (off
) != 0)
11984 if (PPC_HA (off
) != 0)
11987 if (PPC_HA (r2off
) != 0)
11989 if (PPC_LO (r2off
) != 0)
11993 else if (info
->emitrelocations
)
11995 stub_entry
->group
->stub_sec
->reloc_count
+= 1;
11996 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12000 case ppc_stub_plt_branch_notoc
:
12001 case ppc_stub_plt_branch_both
:
12002 stub_entry
->stub_type
+= ppc_stub_long_branch
- ppc_stub_plt_branch
;
12003 /* Fall through. */
12004 case ppc_stub_long_branch_notoc
:
12005 case ppc_stub_long_branch_both
:
12006 off
= (stub_entry
->stub_offset
12007 + stub_entry
->group
->stub_sec
->output_offset
12008 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12010 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12013 targ
= (stub_entry
->target_value
12014 + stub_entry
->target_section
->output_offset
12015 + stub_entry
->target_section
->output_section
->vma
);
12019 if (info
->emitrelocations
)
12021 unsigned int num_rel
;
12022 if (htab
->power10_stubs
)
12023 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12025 num_rel
= num_relocs_for_offset (off
- 8);
12026 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12027 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12030 if (htab
->power10_stubs
)
12031 extra
= size_power10_offset (off
, odd
);
12033 extra
= size_offset (off
- 8);
12034 /* Include branch insn plus those in the offset sequence. */
12036 /* The branch insn is at the end, or "extra" bytes along. So
12037 its offset will be "extra" bytes less that that already
12041 if (!htab
->power10_stubs
)
12043 /* After the bcl, lr has been modified so we need to emit
12044 .eh_frame info saying the return address is in r12. */
12045 lr_used
= stub_entry
->stub_offset
+ 8;
12046 if (stub_entry
->stub_type
== ppc_stub_long_branch_both
)
12048 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12049 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12050 DW_CFA_restore_extended 65. */
12051 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12052 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12053 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12056 /* If the branch can't reach, use a plt_branch. */
12057 if (off
+ (1 << 25) >= (bfd_vma
) (1 << 26))
12059 stub_entry
->stub_type
+= (ppc_stub_plt_branch_notoc
12060 - ppc_stub_long_branch_notoc
);
12063 else if (info
->emitrelocations
)
12064 stub_entry
->group
->stub_sec
->reloc_count
+=1;
12067 case ppc_stub_plt_call_notoc
:
12068 case ppc_stub_plt_call_both
:
12069 off
= (stub_entry
->stub_offset
12070 + stub_entry
->group
->stub_sec
->output_offset
12071 + stub_entry
->group
->stub_sec
->output_section
->vma
);
12072 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12074 targ
= stub_entry
->plt_ent
->plt
.offset
& ~1;
12075 if (targ
>= (bfd_vma
) -2)
12078 plt
= htab
->elf
.splt
;
12079 if (!htab
->elf
.dynamic_sections_created
12080 || stub_entry
->h
== NULL
12081 || stub_entry
->h
->elf
.dynindx
== -1)
12083 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12084 plt
= htab
->elf
.iplt
;
12086 plt
= htab
->pltlocal
;
12088 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12092 if (htab
->params
->plt_stub_align
!= 0)
12094 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12096 stub_entry
->group
->stub_sec
->size
+= pad
;
12097 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12101 if (info
->emitrelocations
)
12103 unsigned int num_rel
;
12104 if (htab
->power10_stubs
)
12105 num_rel
= num_relocs_for_power10_offset (off
, odd
);
12107 num_rel
= num_relocs_for_offset (off
- 8);
12108 stub_entry
->group
->stub_sec
->reloc_count
+= num_rel
;
12109 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12112 size
= plt_stub_size (htab
, stub_entry
, off
);
12114 if (!htab
->power10_stubs
)
12116 /* After the bcl, lr has been modified so we need to emit
12117 .eh_frame info saying the return address is in r12. */
12118 lr_used
= stub_entry
->stub_offset
+ 8;
12119 if (stub_entry
->stub_type
== ppc_stub_plt_call_both
)
12121 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12122 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12123 DW_CFA_restore_extended 65. */
12124 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12125 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12126 stub_entry
->group
->lr_restore
= lr_used
+ 8;
12130 case ppc_stub_plt_call
:
12131 case ppc_stub_plt_call_r2save
:
12132 targ
= stub_entry
->plt_ent
->plt
.offset
& ~(bfd_vma
) 1;
12133 if (targ
>= (bfd_vma
) -2)
12135 plt
= htab
->elf
.splt
;
12136 if (!htab
->elf
.dynamic_sections_created
12137 || stub_entry
->h
== NULL
12138 || stub_entry
->h
->elf
.dynindx
== -1)
12140 if (stub_entry
->symtype
== STT_GNU_IFUNC
)
12141 plt
= htab
->elf
.iplt
;
12143 plt
= htab
->pltlocal
;
12145 targ
+= plt
->output_offset
+ plt
->output_section
->vma
;
12147 off
= (elf_gp (info
->output_bfd
)
12148 + htab
->sec_info
[stub_entry
->group
->link_sec
->id
].toc_off
);
12151 if (htab
->params
->plt_stub_align
!= 0)
12153 unsigned pad
= plt_stub_pad (htab
, stub_entry
, off
);
12155 stub_entry
->group
->stub_sec
->size
+= pad
;
12156 stub_entry
->stub_offset
= stub_entry
->group
->stub_sec
->size
;
12159 if (info
->emitrelocations
)
12161 stub_entry
->group
->stub_sec
->reloc_count
12162 += ((PPC_HA (off
) != 0)
12164 ? 2 + (htab
->params
->plt_static_chain
12165 && PPC_HA (off
+ 16) == PPC_HA (off
))
12167 stub_entry
->group
->stub_sec
->flags
|= SEC_RELOC
;
12170 size
= plt_stub_size (htab
, stub_entry
, off
);
12172 if (stub_entry
->h
!= NULL
12173 && is_tls_get_addr (&stub_entry
->h
->elf
, htab
)
12174 && htab
->params
->tls_get_addr_opt
12175 && stub_entry
->stub_type
== ppc_stub_plt_call_r2save
)
12177 if (htab
->params
->no_tls_get_addr_regsave
)
12179 lr_used
= stub_entry
->stub_offset
+ size
- 20;
12180 /* The eh_frame info will consist of a DW_CFA_advance_loc
12181 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12182 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12183 delta
= lr_used
- stub_entry
->group
->lr_restore
;
12184 stub_entry
->group
->eh_size
+= eh_advance_size (delta
) + 6;
12188 /* Adjustments to r1 need to be described. */
12189 unsigned int cfa_updt
= stub_entry
->stub_offset
+ 18 * 4;
12190 delta
= cfa_updt
- stub_entry
->group
->lr_restore
;
12191 stub_entry
->group
->eh_size
+= eh_advance_size (delta
);
12192 stub_entry
->group
->eh_size
+= htab
->opd_abi
? 36 : 35;
12194 stub_entry
->group
->lr_restore
= size
- 4;
12203 stub_entry
->group
->stub_sec
->size
+= size
;
12207 /* Set up various things so that we can make a list of input sections
12208 for each output section included in the link. Returns -1 on error,
12209 0 when no stubs will be needed, and 1 on success. */
12212 ppc64_elf_setup_section_lists (struct bfd_link_info
*info
)
12216 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12221 htab
->sec_info_arr_size
= _bfd_section_id
;
12222 amt
= sizeof (*htab
->sec_info
) * (htab
->sec_info_arr_size
);
12223 htab
->sec_info
= bfd_zmalloc (amt
);
12224 if (htab
->sec_info
== NULL
)
12227 /* Set toc_off for com, und, abs and ind sections. */
12228 for (id
= 0; id
< 3; id
++)
12229 htab
->sec_info
[id
].toc_off
= TOC_BASE_OFF
;
12234 /* Set up for first pass at multitoc partitioning. */
12237 ppc64_elf_start_multitoc_partition (struct bfd_link_info
*info
)
12239 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12241 htab
->toc_curr
= ppc64_elf_set_toc (info
, info
->output_bfd
);
12242 htab
->toc_bfd
= NULL
;
12243 htab
->toc_first_sec
= NULL
;
12246 /* The linker repeatedly calls this function for each TOC input section
12247 and linker generated GOT section. Group input bfds such that the toc
12248 within a group is less than 64k in size. */
12251 ppc64_elf_next_toc_section (struct bfd_link_info
*info
, asection
*isec
)
12253 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12254 bfd_vma addr
, off
, limit
;
12259 if (!htab
->second_toc_pass
)
12261 /* Keep track of the first .toc or .got section for this input bfd. */
12262 bfd_boolean new_bfd
= htab
->toc_bfd
!= isec
->owner
;
12266 htab
->toc_bfd
= isec
->owner
;
12267 htab
->toc_first_sec
= isec
;
12270 addr
= isec
->output_offset
+ isec
->output_section
->vma
;
12271 off
= addr
- htab
->toc_curr
;
12272 limit
= 0x80008000;
12273 if (ppc64_elf_tdata (isec
->owner
)->has_small_toc_reloc
)
12275 if (off
+ isec
->size
> limit
)
12277 addr
= (htab
->toc_first_sec
->output_offset
12278 + htab
->toc_first_sec
->output_section
->vma
);
12279 htab
->toc_curr
= addr
;
12280 htab
->toc_curr
&= -TOC_BASE_ALIGN
;
12283 /* toc_curr is the base address of this toc group. Set elf_gp
12284 for the input section to be the offset relative to the
12285 output toc base plus 0x8000. Making the input elf_gp an
12286 offset allows us to move the toc as a whole without
12287 recalculating input elf_gp. */
12288 off
= htab
->toc_curr
- elf_gp (info
->output_bfd
);
12289 off
+= TOC_BASE_OFF
;
12291 /* Die if someone uses a linker script that doesn't keep input
12292 file .toc and .got together. */
12294 && elf_gp (isec
->owner
) != 0
12295 && elf_gp (isec
->owner
) != off
)
12298 elf_gp (isec
->owner
) = off
;
12302 /* During the second pass toc_first_sec points to the start of
12303 a toc group, and toc_curr is used to track the old elf_gp.
12304 We use toc_bfd to ensure we only look at each bfd once. */
12305 if (htab
->toc_bfd
== isec
->owner
)
12307 htab
->toc_bfd
= isec
->owner
;
12309 if (htab
->toc_first_sec
== NULL
12310 || htab
->toc_curr
!= elf_gp (isec
->owner
))
12312 htab
->toc_curr
= elf_gp (isec
->owner
);
12313 htab
->toc_first_sec
= isec
;
12315 addr
= (htab
->toc_first_sec
->output_offset
12316 + htab
->toc_first_sec
->output_section
->vma
);
12317 off
= addr
- elf_gp (info
->output_bfd
) + TOC_BASE_OFF
;
12318 elf_gp (isec
->owner
) = off
;
12323 /* Called via elf_link_hash_traverse to merge GOT entries for global
12327 merge_global_got (struct elf_link_hash_entry
*h
, void *inf ATTRIBUTE_UNUSED
)
12329 if (h
->root
.type
== bfd_link_hash_indirect
)
12332 merge_got_entries (&h
->got
.glist
);
12337 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12341 reallocate_got (struct elf_link_hash_entry
*h
, void *inf
)
12343 struct got_entry
*gent
;
12345 if (h
->root
.type
== bfd_link_hash_indirect
)
12348 for (gent
= h
->got
.glist
; gent
!= NULL
; gent
= gent
->next
)
12349 if (!gent
->is_indirect
)
12350 allocate_got (h
, (struct bfd_link_info
*) inf
, gent
);
12354 /* Called on the first multitoc pass after the last call to
12355 ppc64_elf_next_toc_section. This function removes duplicate GOT
12359 ppc64_elf_layout_multitoc (struct bfd_link_info
*info
)
12361 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12362 struct bfd
*ibfd
, *ibfd2
;
12363 bfd_boolean done_something
;
12365 htab
->multi_toc_needed
= htab
->toc_curr
!= elf_gp (info
->output_bfd
);
12367 if (!htab
->do_multi_toc
)
12370 /* Merge global sym got entries within a toc group. */
12371 elf_link_hash_traverse (&htab
->elf
, merge_global_got
, info
);
12373 /* And tlsld_got. */
12374 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12376 struct got_entry
*ent
, *ent2
;
12378 if (!is_ppc64_elf (ibfd
))
12381 ent
= ppc64_tlsld_got (ibfd
);
12382 if (!ent
->is_indirect
12383 && ent
->got
.offset
!= (bfd_vma
) -1)
12385 for (ibfd2
= ibfd
->link
.next
; ibfd2
!= NULL
; ibfd2
= ibfd2
->link
.next
)
12387 if (!is_ppc64_elf (ibfd2
))
12390 ent2
= ppc64_tlsld_got (ibfd2
);
12391 if (!ent2
->is_indirect
12392 && ent2
->got
.offset
!= (bfd_vma
) -1
12393 && elf_gp (ibfd2
) == elf_gp (ibfd
))
12395 ent2
->is_indirect
= TRUE
;
12396 ent2
->got
.ent
= ent
;
12402 /* Zap sizes of got sections. */
12403 htab
->elf
.irelplt
->rawsize
= htab
->elf
.irelplt
->size
;
12404 htab
->elf
.irelplt
->size
-= htab
->got_reli_size
;
12405 htab
->got_reli_size
= 0;
12407 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12409 asection
*got
, *relgot
;
12411 if (!is_ppc64_elf (ibfd
))
12414 got
= ppc64_elf_tdata (ibfd
)->got
;
12417 got
->rawsize
= got
->size
;
12419 relgot
= ppc64_elf_tdata (ibfd
)->relgot
;
12420 relgot
->rawsize
= relgot
->size
;
12425 /* Now reallocate the got, local syms first. We don't need to
12426 allocate section contents again since we never increase size. */
12427 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12429 struct got_entry
**lgot_ents
;
12430 struct got_entry
**end_lgot_ents
;
12431 struct plt_entry
**local_plt
;
12432 struct plt_entry
**end_local_plt
;
12433 unsigned char *lgot_masks
;
12434 bfd_size_type locsymcount
;
12435 Elf_Internal_Shdr
*symtab_hdr
;
12438 if (!is_ppc64_elf (ibfd
))
12441 lgot_ents
= elf_local_got_ents (ibfd
);
12445 symtab_hdr
= &elf_symtab_hdr (ibfd
);
12446 locsymcount
= symtab_hdr
->sh_info
;
12447 end_lgot_ents
= lgot_ents
+ locsymcount
;
12448 local_plt
= (struct plt_entry
**) end_lgot_ents
;
12449 end_local_plt
= local_plt
+ locsymcount
;
12450 lgot_masks
= (unsigned char *) end_local_plt
;
12451 s
= ppc64_elf_tdata (ibfd
)->got
;
12452 for (; lgot_ents
< end_lgot_ents
; ++lgot_ents
, ++lgot_masks
)
12454 struct got_entry
*ent
;
12456 for (ent
= *lgot_ents
; ent
!= NULL
; ent
= ent
->next
)
12458 unsigned int ent_size
= 8;
12459 unsigned int rel_size
= sizeof (Elf64_External_Rela
);
12461 ent
->got
.offset
= s
->size
;
12462 if ((ent
->tls_type
& *lgot_masks
& TLS_GD
) != 0)
12467 s
->size
+= ent_size
;
12468 if ((*lgot_masks
& (TLS_TLS
| PLT_IFUNC
)) == PLT_IFUNC
)
12470 htab
->elf
.irelplt
->size
+= rel_size
;
12471 htab
->got_reli_size
+= rel_size
;
12473 else if (bfd_link_pic (info
)
12474 && !(ent
->tls_type
!= 0
12475 && bfd_link_executable (info
)))
12477 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12478 srel
->size
+= rel_size
;
12484 elf_link_hash_traverse (&htab
->elf
, reallocate_got
, info
);
12486 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12488 struct got_entry
*ent
;
12490 if (!is_ppc64_elf (ibfd
))
12493 ent
= ppc64_tlsld_got (ibfd
);
12494 if (!ent
->is_indirect
12495 && ent
->got
.offset
!= (bfd_vma
) -1)
12497 asection
*s
= ppc64_elf_tdata (ibfd
)->got
;
12498 ent
->got
.offset
= s
->size
;
12500 if (bfd_link_dll (info
))
12502 asection
*srel
= ppc64_elf_tdata (ibfd
)->relgot
;
12503 srel
->size
+= sizeof (Elf64_External_Rela
);
12508 done_something
= htab
->elf
.irelplt
->rawsize
!= htab
->elf
.irelplt
->size
;
12509 if (!done_something
)
12510 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
12514 if (!is_ppc64_elf (ibfd
))
12517 got
= ppc64_elf_tdata (ibfd
)->got
;
12520 done_something
= got
->rawsize
!= got
->size
;
12521 if (done_something
)
12526 if (done_something
)
12527 (*htab
->params
->layout_sections_again
) ();
12529 /* Set up for second pass over toc sections to recalculate elf_gp
12530 on input sections. */
12531 htab
->toc_bfd
= NULL
;
12532 htab
->toc_first_sec
= NULL
;
12533 htab
->second_toc_pass
= TRUE
;
12534 return done_something
;
12537 /* Called after second pass of multitoc partitioning. */
12540 ppc64_elf_finish_multitoc_partition (struct bfd_link_info
*info
)
12542 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12544 /* After the second pass, toc_curr tracks the TOC offset used
12545 for code sections below in ppc64_elf_next_input_section. */
12546 htab
->toc_curr
= TOC_BASE_OFF
;
12549 /* No toc references were found in ISEC. If the code in ISEC makes no
12550 calls, then there's no need to use toc adjusting stubs when branching
12551 into ISEC. Actually, indirect calls from ISEC are OK as they will
12552 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12553 needed, and 2 if a cyclical call-graph was found but no other reason
12554 for a stub was detected. If called from the top level, a return of
12555 2 means the same as a return of 0. */
12558 toc_adjusting_stub_needed (struct bfd_link_info
*info
, asection
*isec
)
12562 /* Mark this section as checked. */
12563 isec
->call_check_done
= 1;
12565 /* We know none of our code bearing sections will need toc stubs. */
12566 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
12569 if (isec
->size
== 0)
12572 if (isec
->output_section
== NULL
)
12576 if (isec
->reloc_count
!= 0)
12578 Elf_Internal_Rela
*relstart
, *rel
;
12579 Elf_Internal_Sym
*local_syms
;
12580 struct ppc_link_hash_table
*htab
;
12582 relstart
= _bfd_elf_link_read_relocs (isec
->owner
, isec
, NULL
, NULL
,
12583 info
->keep_memory
);
12584 if (relstart
== NULL
)
12587 /* Look for branches to outside of this section. */
12589 htab
= ppc_hash_table (info
);
12593 for (rel
= relstart
; rel
< relstart
+ isec
->reloc_count
; ++rel
)
12595 enum elf_ppc64_reloc_type r_type
;
12596 unsigned long r_symndx
;
12597 struct elf_link_hash_entry
*h
;
12598 struct ppc_link_hash_entry
*eh
;
12599 Elf_Internal_Sym
*sym
;
12601 struct _opd_sec_data
*opd
;
12605 r_type
= ELF64_R_TYPE (rel
->r_info
);
12606 if (r_type
!= R_PPC64_REL24
12607 && r_type
!= R_PPC64_REL24_NOTOC
12608 && r_type
!= R_PPC64_REL14
12609 && r_type
!= R_PPC64_REL14_BRTAKEN
12610 && r_type
!= R_PPC64_REL14_BRNTAKEN
12611 && r_type
!= R_PPC64_PLTCALL
12612 && r_type
!= R_PPC64_PLTCALL_NOTOC
)
12615 r_symndx
= ELF64_R_SYM (rel
->r_info
);
12616 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
, r_symndx
,
12623 /* Calls to dynamic lib functions go through a plt call stub
12625 eh
= ppc_elf_hash_entry (h
);
12627 && (eh
->elf
.plt
.plist
!= NULL
12629 && ppc_follow_link (eh
->oh
)->elf
.plt
.plist
!= NULL
)))
12635 if (sym_sec
== NULL
)
12636 /* Ignore other undefined symbols. */
12639 /* Assume branches to other sections not included in the
12640 link need stubs too, to cover -R and absolute syms. */
12641 if (sym_sec
->output_section
== NULL
)
12648 sym_value
= sym
->st_value
;
12651 if (h
->root
.type
!= bfd_link_hash_defined
12652 && h
->root
.type
!= bfd_link_hash_defweak
)
12654 sym_value
= h
->root
.u
.def
.value
;
12656 sym_value
+= rel
->r_addend
;
12658 /* If this branch reloc uses an opd sym, find the code section. */
12659 opd
= get_opd_info (sym_sec
);
12662 if (h
== NULL
&& opd
->adjust
!= NULL
)
12666 adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
12668 /* Assume deleted functions won't ever be called. */
12670 sym_value
+= adjust
;
12673 dest
= opd_entry_value (sym_sec
, sym_value
,
12674 &sym_sec
, NULL
, FALSE
);
12675 if (dest
== (bfd_vma
) -1)
12680 + sym_sec
->output_offset
12681 + sym_sec
->output_section
->vma
);
12683 /* Ignore branch to self. */
12684 if (sym_sec
== isec
)
12687 /* If the called function uses the toc, we need a stub. */
12688 if (sym_sec
->has_toc_reloc
12689 || sym_sec
->makes_toc_func_call
)
12695 /* Assume any branch that needs a long branch stub might in fact
12696 need a plt_branch stub. A plt_branch stub uses r2. */
12697 else if (dest
- (isec
->output_offset
12698 + isec
->output_section
->vma
12699 + rel
->r_offset
) + (1 << 25)
12700 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12708 /* If calling back to a section in the process of being
12709 tested, we can't say for sure that no toc adjusting stubs
12710 are needed, so don't return zero. */
12711 else if (sym_sec
->call_check_in_progress
)
12714 /* Branches to another section that itself doesn't have any TOC
12715 references are OK. Recursively call ourselves to check. */
12716 else if (!sym_sec
->call_check_done
)
12720 /* Mark current section as indeterminate, so that other
12721 sections that call back to current won't be marked as
12723 isec
->call_check_in_progress
= 1;
12724 recur
= toc_adjusting_stub_needed (info
, sym_sec
);
12725 isec
->call_check_in_progress
= 0;
12736 if (elf_symtab_hdr (isec
->owner
).contents
12737 != (unsigned char *) local_syms
)
12739 if (elf_section_data (isec
)->relocs
!= relstart
)
12744 && isec
->map_head
.s
!= NULL
12745 && (strcmp (isec
->output_section
->name
, ".init") == 0
12746 || strcmp (isec
->output_section
->name
, ".fini") == 0))
12748 if (isec
->map_head
.s
->has_toc_reloc
12749 || isec
->map_head
.s
->makes_toc_func_call
)
12751 else if (!isec
->map_head
.s
->call_check_done
)
12754 isec
->call_check_in_progress
= 1;
12755 recur
= toc_adjusting_stub_needed (info
, isec
->map_head
.s
);
12756 isec
->call_check_in_progress
= 0;
12763 isec
->makes_toc_func_call
= 1;
12768 /* The linker repeatedly calls this function for each input section,
12769 in the order that input sections are linked into output sections.
12770 Build lists of input sections to determine groupings between which
12771 we may insert linker stubs. */
12774 ppc64_elf_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
12776 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12781 if ((isec
->output_section
->flags
& SEC_CODE
) != 0
12782 && isec
->output_section
->id
< htab
->sec_info_arr_size
)
12784 /* This happens to make the list in reverse order,
12785 which is what we want. */
12786 htab
->sec_info
[isec
->id
].u
.list
12787 = htab
->sec_info
[isec
->output_section
->id
].u
.list
;
12788 htab
->sec_info
[isec
->output_section
->id
].u
.list
= isec
;
12791 if (htab
->multi_toc_needed
)
12793 /* Analyse sections that aren't already flagged as needing a
12794 valid toc pointer. Exclude .fixup for the linux kernel.
12795 .fixup contains branches, but only back to the function that
12796 hit an exception. */
12797 if (!(isec
->has_toc_reloc
12798 || (isec
->flags
& SEC_CODE
) == 0
12799 || strcmp (isec
->name
, ".fixup") == 0
12800 || isec
->call_check_done
))
12802 if (toc_adjusting_stub_needed (info
, isec
) < 0)
12805 /* Make all sections use the TOC assigned for this object file.
12806 This will be wrong for pasted sections; We fix that in
12807 check_pasted_section(). */
12808 if (elf_gp (isec
->owner
) != 0)
12809 htab
->toc_curr
= elf_gp (isec
->owner
);
12812 htab
->sec_info
[isec
->id
].toc_off
= htab
->toc_curr
;
12816 /* Check that all .init and .fini sections use the same toc, if they
12817 have toc relocs. */
12820 check_pasted_section (struct bfd_link_info
*info
, const char *name
)
12822 asection
*o
= bfd_get_section_by_name (info
->output_bfd
, name
);
12826 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
12827 bfd_vma toc_off
= 0;
12830 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12831 if (i
->has_toc_reloc
)
12834 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12835 else if (toc_off
!= htab
->sec_info
[i
->id
].toc_off
)
12840 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12841 if (i
->makes_toc_func_call
)
12843 toc_off
= htab
->sec_info
[i
->id
].toc_off
;
12847 /* Make sure the whole pasted function uses the same toc offset. */
12849 for (i
= o
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
12850 htab
->sec_info
[i
->id
].toc_off
= toc_off
;
12856 ppc64_elf_check_init_fini (struct bfd_link_info
*info
)
12858 return (check_pasted_section (info
, ".init")
12859 & check_pasted_section (info
, ".fini"));
12862 /* See whether we can group stub sections together. Grouping stub
12863 sections may result in fewer stubs. More importantly, we need to
12864 put all .init* and .fini* stubs at the beginning of the .init or
12865 .fini output sections respectively, because glibc splits the
12866 _init and _fini functions into multiple parts. Putting a stub in
12867 the middle of a function is not a good idea. */
12870 group_sections (struct bfd_link_info
*info
,
12871 bfd_size_type stub_group_size
,
12872 bfd_boolean stubs_always_before_branch
)
12874 struct ppc_link_hash_table
*htab
;
12876 bfd_boolean suppress_size_errors
;
12878 htab
= ppc_hash_table (info
);
12882 suppress_size_errors
= FALSE
;
12883 if (stub_group_size
== 1)
12885 /* Default values. */
12886 if (stubs_always_before_branch
)
12887 stub_group_size
= 0x1e00000;
12889 stub_group_size
= 0x1c00000;
12890 suppress_size_errors
= TRUE
;
12893 for (osec
= info
->output_bfd
->sections
; osec
!= NULL
; osec
= osec
->next
)
12897 if (osec
->id
>= htab
->sec_info_arr_size
)
12900 tail
= htab
->sec_info
[osec
->id
].u
.list
;
12901 while (tail
!= NULL
)
12905 bfd_size_type total
;
12906 bfd_boolean big_sec
;
12908 struct map_stub
*group
;
12909 bfd_size_type group_size
;
12912 total
= tail
->size
;
12913 group_size
= (ppc64_elf_section_data (tail
) != NULL
12914 && ppc64_elf_section_data (tail
)->has_14bit_branch
12915 ? stub_group_size
>> 10 : stub_group_size
);
12917 big_sec
= total
> group_size
;
12918 if (big_sec
&& !suppress_size_errors
)
12919 /* xgettext:c-format */
12920 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12921 tail
->owner
, tail
);
12922 curr_toc
= htab
->sec_info
[tail
->id
].toc_off
;
12924 while ((prev
= htab
->sec_info
[curr
->id
].u
.list
) != NULL
12925 && ((total
+= curr
->output_offset
- prev
->output_offset
)
12926 < (ppc64_elf_section_data (prev
) != NULL
12927 && ppc64_elf_section_data (prev
)->has_14bit_branch
12928 ? (group_size
= stub_group_size
>> 10) : group_size
))
12929 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12932 /* OK, the size from the start of CURR to the end is less
12933 than group_size and thus can be handled by one stub
12934 section. (or the tail section is itself larger than
12935 group_size, in which case we may be toast.) We should
12936 really be keeping track of the total size of stubs added
12937 here, as stubs contribute to the final output section
12938 size. That's a little tricky, and this way will only
12939 break if stubs added make the total size more than 2^25,
12940 ie. for the default stub_group_size, if stubs total more
12941 than 2097152 bytes, or nearly 75000 plt call stubs. */
12942 group
= bfd_alloc (curr
->owner
, sizeof (*group
));
12945 group
->link_sec
= curr
;
12946 group
->stub_sec
= NULL
;
12947 group
->needs_save_res
= 0;
12948 group
->lr_restore
= 0;
12949 group
->eh_size
= 0;
12950 group
->eh_base
= 0;
12951 group
->next
= htab
->group
;
12952 htab
->group
= group
;
12955 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12956 /* Set up this stub group. */
12957 htab
->sec_info
[tail
->id
].u
.group
= group
;
12959 while (tail
!= curr
&& (tail
= prev
) != NULL
);
12961 /* But wait, there's more! Input sections up to group_size
12962 bytes before the stub section can be handled by it too.
12963 Don't do this if we have a really large section after the
12964 stubs, as adding more stubs increases the chance that
12965 branches may not reach into the stub section. */
12966 if (!stubs_always_before_branch
&& !big_sec
)
12969 while (prev
!= NULL
12970 && ((total
+= tail
->output_offset
- prev
->output_offset
)
12971 < (ppc64_elf_section_data (prev
) != NULL
12972 && ppc64_elf_section_data (prev
)->has_14bit_branch
12973 ? (group_size
= stub_group_size
>> 10)
12975 && htab
->sec_info
[prev
->id
].toc_off
== curr_toc
)
12978 prev
= htab
->sec_info
[tail
->id
].u
.list
;
12979 htab
->sec_info
[tail
->id
].u
.group
= group
;
12988 static const unsigned char glink_eh_frame_cie
[] =
12990 0, 0, 0, 16, /* length. */
12991 0, 0, 0, 0, /* id. */
12992 1, /* CIE version. */
12993 'z', 'R', 0, /* Augmentation string. */
12994 4, /* Code alignment. */
12995 0x78, /* Data alignment. */
12997 1, /* Augmentation size. */
12998 DW_EH_PE_pcrel
| DW_EH_PE_sdata4
, /* FDE encoding. */
12999 DW_CFA_def_cfa
, 1, 0 /* def_cfa: r1 offset 0. */
13002 /* Stripping output sections is normally done before dynamic section
13003 symbols have been allocated. This function is called later, and
13004 handles cases like htab->brlt which is mapped to its own output
13008 maybe_strip_output (struct bfd_link_info
*info
, asection
*isec
)
13010 if (isec
->size
== 0
13011 && isec
->output_section
->size
== 0
13012 && !(isec
->output_section
->flags
& SEC_KEEP
)
13013 && !bfd_section_removed_from_list (info
->output_bfd
,
13014 isec
->output_section
)
13015 && elf_section_data (isec
->output_section
)->dynindx
== 0)
13017 isec
->output_section
->flags
|= SEC_EXCLUDE
;
13018 bfd_section_list_remove (info
->output_bfd
, isec
->output_section
);
13019 info
->output_bfd
->section_count
--;
13023 /* Determine and set the size of the stub section for a final link.
13025 The basic idea here is to examine all the relocations looking for
13026 PC-relative calls to a target that is unreachable with a "bl"
13030 ppc64_elf_size_stubs (struct bfd_link_info
*info
)
13032 bfd_size_type stub_group_size
;
13033 bfd_boolean stubs_always_before_branch
;
13034 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13039 if (htab
->params
->plt_thread_safe
== -1 && !bfd_link_executable (info
))
13040 htab
->params
->plt_thread_safe
= 1;
13041 if (!htab
->opd_abi
)
13042 htab
->params
->plt_thread_safe
= 0;
13043 else if (htab
->params
->plt_thread_safe
== -1)
13045 static const char *const thread_starter
[] =
13049 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13051 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13052 "mq_notify", "create_timer",
13057 "GOMP_parallel_start",
13058 "GOMP_parallel_loop_static",
13059 "GOMP_parallel_loop_static_start",
13060 "GOMP_parallel_loop_dynamic",
13061 "GOMP_parallel_loop_dynamic_start",
13062 "GOMP_parallel_loop_guided",
13063 "GOMP_parallel_loop_guided_start",
13064 "GOMP_parallel_loop_runtime",
13065 "GOMP_parallel_loop_runtime_start",
13066 "GOMP_parallel_sections",
13067 "GOMP_parallel_sections_start",
13073 for (i
= 0; i
< ARRAY_SIZE (thread_starter
); i
++)
13075 struct elf_link_hash_entry
*h
;
13076 h
= elf_link_hash_lookup (&htab
->elf
, thread_starter
[i
],
13077 FALSE
, FALSE
, TRUE
);
13078 htab
->params
->plt_thread_safe
= h
!= NULL
&& h
->ref_regular
;
13079 if (htab
->params
->plt_thread_safe
)
13083 stubs_always_before_branch
= htab
->params
->group_size
< 0;
13084 if (htab
->params
->group_size
< 0)
13085 stub_group_size
= -htab
->params
->group_size
;
13087 stub_group_size
= htab
->params
->group_size
;
13089 if (!group_sections (info
, stub_group_size
, stubs_always_before_branch
))
13092 htab
->tga_group
= NULL
;
13093 if (!htab
->params
->no_tls_get_addr_regsave
13094 && htab
->tga_desc_fd
!= NULL
13095 && (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefined
13096 || htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_undefweak
)
13097 && htab
->tls_get_addr_fd
!= NULL
13098 && is_static_defined (&htab
->tls_get_addr_fd
->elf
))
13100 asection
*sym_sec
, *code_sec
, *stub_sec
;
13102 struct _opd_sec_data
*opd
;
13104 sym_sec
= htab
->tls_get_addr_fd
->elf
.root
.u
.def
.section
;
13105 sym_value
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
13106 code_sec
= sym_sec
;
13107 opd
= get_opd_info (sym_sec
);
13109 opd_entry_value (sym_sec
, sym_value
, &code_sec
, NULL
, FALSE
);
13110 htab
->tga_group
= htab
->sec_info
[code_sec
->id
].u
.group
;
13111 stub_sec
= (*htab
->params
->add_stub_section
) (".tga_desc.stub",
13112 htab
->tga_group
->link_sec
);
13113 if (stub_sec
== NULL
)
13115 htab
->tga_group
->stub_sec
= stub_sec
;
13117 htab
->tga_desc_fd
->elf
.root
.type
= bfd_link_hash_defined
;
13118 htab
->tga_desc_fd
->elf
.root
.u
.def
.section
= stub_sec
;
13119 htab
->tga_desc_fd
->elf
.root
.u
.def
.value
= 0;
13120 htab
->tga_desc_fd
->elf
.type
= STT_FUNC
;
13121 htab
->tga_desc_fd
->elf
.def_regular
= 1;
13122 htab
->tga_desc_fd
->elf
.non_elf
= 0;
13123 _bfd_elf_link_hash_hide_symbol (info
, &htab
->tga_desc_fd
->elf
, TRUE
);
13126 #define STUB_SHRINK_ITER 20
13127 /* Loop until no stubs added. After iteration 20 of this loop we may
13128 exit on a stub section shrinking. This is to break out of a
13129 pathological case where adding stubs on one iteration decreases
13130 section gaps (perhaps due to alignment), which then requires
13131 fewer or smaller stubs on the next iteration. */
13136 unsigned int bfd_indx
;
13137 struct map_stub
*group
;
13139 htab
->stub_iteration
+= 1;
13141 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
13143 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
13145 Elf_Internal_Shdr
*symtab_hdr
;
13147 Elf_Internal_Sym
*local_syms
= NULL
;
13149 if (!is_ppc64_elf (input_bfd
))
13152 /* We'll need the symbol table in a second. */
13153 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
13154 if (symtab_hdr
->sh_info
== 0)
13157 /* Walk over each section attached to the input bfd. */
13158 for (section
= input_bfd
->sections
;
13160 section
= section
->next
)
13162 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
13164 /* If there aren't any relocs, then there's nothing more
13166 if ((section
->flags
& SEC_RELOC
) == 0
13167 || (section
->flags
& SEC_ALLOC
) == 0
13168 || (section
->flags
& SEC_LOAD
) == 0
13169 || (section
->flags
& SEC_CODE
) == 0
13170 || section
->reloc_count
== 0)
13173 /* If this section is a link-once section that will be
13174 discarded, then don't create any stubs. */
13175 if (section
->output_section
== NULL
13176 || section
->output_section
->owner
!= info
->output_bfd
)
13179 /* Get the relocs. */
13181 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
13182 info
->keep_memory
);
13183 if (internal_relocs
== NULL
)
13184 goto error_ret_free_local
;
13186 /* Now examine each relocation. */
13187 irela
= internal_relocs
;
13188 irelaend
= irela
+ section
->reloc_count
;
13189 for (; irela
< irelaend
; irela
++)
13191 enum elf_ppc64_reloc_type r_type
;
13192 unsigned int r_indx
;
13193 enum ppc_stub_type stub_type
;
13194 struct ppc_stub_hash_entry
*stub_entry
;
13195 asection
*sym_sec
, *code_sec
;
13196 bfd_vma sym_value
, code_value
;
13197 bfd_vma destination
;
13198 unsigned long local_off
;
13199 bfd_boolean ok_dest
;
13200 struct ppc_link_hash_entry
*hash
;
13201 struct ppc_link_hash_entry
*fdh
;
13202 struct elf_link_hash_entry
*h
;
13203 Elf_Internal_Sym
*sym
;
13205 const asection
*id_sec
;
13206 struct _opd_sec_data
*opd
;
13207 struct plt_entry
*plt_ent
;
13209 r_type
= ELF64_R_TYPE (irela
->r_info
);
13210 r_indx
= ELF64_R_SYM (irela
->r_info
);
13212 if (r_type
>= R_PPC64_max
)
13214 bfd_set_error (bfd_error_bad_value
);
13215 goto error_ret_free_internal
;
13218 /* Only look for stubs on branch instructions. */
13219 if (r_type
!= R_PPC64_REL24
13220 && r_type
!= R_PPC64_REL24_NOTOC
13221 && r_type
!= R_PPC64_REL14
13222 && r_type
!= R_PPC64_REL14_BRTAKEN
13223 && r_type
!= R_PPC64_REL14_BRNTAKEN
)
13226 /* Now determine the call target, its name, value,
13228 if (!get_sym_h (&h
, &sym
, &sym_sec
, NULL
, &local_syms
,
13229 r_indx
, input_bfd
))
13230 goto error_ret_free_internal
;
13231 hash
= ppc_elf_hash_entry (h
);
13238 sym_value
= sym
->st_value
;
13239 if (sym_sec
!= NULL
13240 && sym_sec
->output_section
!= NULL
)
13243 else if (hash
->elf
.root
.type
== bfd_link_hash_defined
13244 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
13246 sym_value
= hash
->elf
.root
.u
.def
.value
;
13247 if (sym_sec
->output_section
!= NULL
)
13250 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
13251 || hash
->elf
.root
.type
== bfd_link_hash_undefined
)
13253 /* Recognise an old ABI func code entry sym, and
13254 use the func descriptor sym instead if it is
13256 if (hash
->elf
.root
.root
.string
[0] == '.'
13257 && hash
->oh
!= NULL
)
13259 fdh
= ppc_follow_link (hash
->oh
);
13260 if (fdh
->elf
.root
.type
== bfd_link_hash_defined
13261 || fdh
->elf
.root
.type
== bfd_link_hash_defweak
)
13263 sym_sec
= fdh
->elf
.root
.u
.def
.section
;
13264 sym_value
= fdh
->elf
.root
.u
.def
.value
;
13265 if (sym_sec
->output_section
!= NULL
)
13274 bfd_set_error (bfd_error_bad_value
);
13275 goto error_ret_free_internal
;
13282 sym_value
+= irela
->r_addend
;
13283 destination
= (sym_value
13284 + sym_sec
->output_offset
13285 + sym_sec
->output_section
->vma
);
13286 local_off
= PPC64_LOCAL_ENTRY_OFFSET (hash
13291 code_sec
= sym_sec
;
13292 code_value
= sym_value
;
13293 opd
= get_opd_info (sym_sec
);
13298 if (hash
== NULL
&& opd
->adjust
!= NULL
)
13300 long adjust
= opd
->adjust
[OPD_NDX (sym_value
)];
13303 code_value
+= adjust
;
13304 sym_value
+= adjust
;
13306 dest
= opd_entry_value (sym_sec
, sym_value
,
13307 &code_sec
, &code_value
, FALSE
);
13308 if (dest
!= (bfd_vma
) -1)
13310 destination
= dest
;
13313 /* Fixup old ABI sym to point at code
13315 hash
->elf
.root
.type
= bfd_link_hash_defweak
;
13316 hash
->elf
.root
.u
.def
.section
= code_sec
;
13317 hash
->elf
.root
.u
.def
.value
= code_value
;
13322 /* Determine what (if any) linker stub is needed. */
13324 stub_type
= ppc_type_of_stub (section
, irela
, &hash
,
13325 &plt_ent
, destination
,
13328 if (r_type
== R_PPC64_REL24_NOTOC
)
13330 if (stub_type
== ppc_stub_plt_call
)
13331 stub_type
= ppc_stub_plt_call_notoc
;
13332 else if (stub_type
== ppc_stub_long_branch
13333 || (code_sec
!= NULL
13334 && code_sec
->output_section
!= NULL
13335 && (((hash
? hash
->elf
.other
: sym
->st_other
)
13336 & STO_PPC64_LOCAL_MASK
)
13337 > 1 << STO_PPC64_LOCAL_BIT
)))
13338 stub_type
= ppc_stub_long_branch_notoc
;
13340 else if (stub_type
!= ppc_stub_plt_call
)
13342 /* Check whether we need a TOC adjusting stub.
13343 Since the linker pastes together pieces from
13344 different object files when creating the
13345 _init and _fini functions, it may be that a
13346 call to what looks like a local sym is in
13347 fact a call needing a TOC adjustment. */
13348 if ((code_sec
!= NULL
13349 && code_sec
->output_section
!= NULL
13350 && (htab
->sec_info
[code_sec
->id
].toc_off
13351 != htab
->sec_info
[section
->id
].toc_off
)
13352 && (code_sec
->has_toc_reloc
13353 || code_sec
->makes_toc_func_call
))
13354 || (((hash
? hash
->elf
.other
: sym
->st_other
)
13355 & STO_PPC64_LOCAL_MASK
)
13356 == 1 << STO_PPC64_LOCAL_BIT
))
13357 stub_type
= ppc_stub_long_branch_r2off
;
13360 if (stub_type
== ppc_stub_none
)
13363 /* __tls_get_addr calls might be eliminated. */
13364 if (stub_type
!= ppc_stub_plt_call
13365 && stub_type
!= ppc_stub_plt_call_notoc
13367 && is_tls_get_addr (&hash
->elf
, htab
)
13368 && section
->has_tls_reloc
13369 && irela
!= internal_relocs
)
13371 /* Get tls info. */
13372 unsigned char *tls_mask
;
13374 if (!get_tls_mask (&tls_mask
, NULL
, NULL
, &local_syms
,
13375 irela
- 1, input_bfd
))
13376 goto error_ret_free_internal
;
13377 if ((*tls_mask
& TLS_TLS
) != 0
13378 && (*tls_mask
& (TLS_GD
| TLS_LD
)) == 0)
13382 if (stub_type
== ppc_stub_plt_call
)
13385 && htab
->params
->plt_localentry0
!= 0
13386 && is_elfv2_localentry0 (&hash
->elf
))
13387 htab
->has_plt_localentry0
= 1;
13388 else if (irela
+ 1 < irelaend
13389 && irela
[1].r_offset
== irela
->r_offset
+ 4
13390 && (ELF64_R_TYPE (irela
[1].r_info
)
13391 == R_PPC64_TOCSAVE
))
13393 if (!tocsave_find (htab
, INSERT
,
13394 &local_syms
, irela
+ 1, input_bfd
))
13395 goto error_ret_free_internal
;
13398 stub_type
= ppc_stub_plt_call_r2save
;
13401 /* Support for grouping stub sections. */
13402 id_sec
= htab
->sec_info
[section
->id
].u
.group
->link_sec
;
13404 /* Get the name of this stub. */
13405 stub_name
= ppc_stub_name (id_sec
, sym_sec
, hash
, irela
);
13407 goto error_ret_free_internal
;
13409 stub_entry
= ppc_stub_hash_lookup (&htab
->stub_hash_table
,
13410 stub_name
, FALSE
, FALSE
);
13411 if (stub_entry
!= NULL
)
13413 enum ppc_stub_type old_type
;
13414 /* A stub has already been created, but it may
13415 not be the required type. We shouldn't be
13416 transitioning from plt_call to long_branch
13417 stubs or vice versa, but we might be
13418 upgrading from plt_call to plt_call_r2save or
13419 from long_branch to long_branch_r2off. */
13421 old_type
= stub_entry
->stub_type
;
13427 case ppc_stub_save_res
:
13430 case ppc_stub_plt_call
:
13431 case ppc_stub_plt_call_r2save
:
13432 case ppc_stub_plt_call_notoc
:
13433 case ppc_stub_plt_call_both
:
13434 if (stub_type
== ppc_stub_plt_call
)
13436 else if (stub_type
== ppc_stub_plt_call_r2save
)
13438 if (old_type
== ppc_stub_plt_call_notoc
)
13439 stub_type
= ppc_stub_plt_call_both
;
13441 else if (stub_type
== ppc_stub_plt_call_notoc
)
13443 if (old_type
== ppc_stub_plt_call_r2save
)
13444 stub_type
= ppc_stub_plt_call_both
;
13450 case ppc_stub_plt_branch
:
13451 case ppc_stub_plt_branch_r2off
:
13452 case ppc_stub_plt_branch_notoc
:
13453 case ppc_stub_plt_branch_both
:
13454 old_type
+= (ppc_stub_long_branch
13455 - ppc_stub_plt_branch
);
13456 /* Fall through. */
13457 case ppc_stub_long_branch
:
13458 case ppc_stub_long_branch_r2off
:
13459 case ppc_stub_long_branch_notoc
:
13460 case ppc_stub_long_branch_both
:
13461 if (stub_type
== ppc_stub_long_branch
)
13463 else if (stub_type
== ppc_stub_long_branch_r2off
)
13465 if (old_type
== ppc_stub_long_branch_notoc
)
13466 stub_type
= ppc_stub_long_branch_both
;
13468 else if (stub_type
== ppc_stub_long_branch_notoc
)
13470 if (old_type
== ppc_stub_long_branch_r2off
)
13471 stub_type
= ppc_stub_long_branch_both
;
13477 if (old_type
< stub_type
)
13478 stub_entry
->stub_type
= stub_type
;
13482 stub_entry
= ppc_add_stub (stub_name
, section
, info
);
13483 if (stub_entry
== NULL
)
13486 error_ret_free_internal
:
13487 if (elf_section_data (section
)->relocs
== NULL
)
13488 free (internal_relocs
);
13489 error_ret_free_local
:
13490 if (symtab_hdr
->contents
13491 != (unsigned char *) local_syms
)
13496 stub_entry
->stub_type
= stub_type
;
13497 if (stub_type
>= ppc_stub_plt_call
13498 && stub_type
<= ppc_stub_plt_call_both
)
13500 stub_entry
->target_value
= sym_value
;
13501 stub_entry
->target_section
= sym_sec
;
13505 stub_entry
->target_value
= code_value
;
13506 stub_entry
->target_section
= code_sec
;
13508 stub_entry
->h
= hash
;
13509 stub_entry
->plt_ent
= plt_ent
;
13510 stub_entry
->symtype
13511 = hash
? hash
->elf
.type
: ELF_ST_TYPE (sym
->st_info
);
13512 stub_entry
->other
= hash
? hash
->elf
.other
: sym
->st_other
;
13515 && (hash
->elf
.root
.type
== bfd_link_hash_defined
13516 || hash
->elf
.root
.type
== bfd_link_hash_defweak
))
13517 htab
->stub_globals
+= 1;
13520 /* We're done with the internal relocs, free them. */
13521 if (elf_section_data (section
)->relocs
!= internal_relocs
)
13522 free (internal_relocs
);
13525 if (local_syms
!= NULL
13526 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
13528 if (!info
->keep_memory
)
13531 symtab_hdr
->contents
= (unsigned char *) local_syms
;
13535 /* We may have added some stubs. Find out the new size of the
13537 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13539 group
->lr_restore
= 0;
13540 group
->eh_size
= 0;
13541 if (group
->stub_sec
!= NULL
)
13543 asection
*stub_sec
= group
->stub_sec
;
13545 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13546 || stub_sec
->rawsize
< stub_sec
->size
)
13547 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13548 stub_sec
->rawsize
= stub_sec
->size
;
13549 stub_sec
->size
= 0;
13550 stub_sec
->reloc_count
= 0;
13551 stub_sec
->flags
&= ~SEC_RELOC
;
13554 if (htab
->tga_group
!= NULL
)
13556 /* See emit_tga_desc and emit_tga_desc_eh_frame. */
13557 htab
->tga_group
->eh_size
13558 = 1 + 2 + (htab
->opd_abi
!= 0) + 3 + 8 * 2 + 3 + 8 + 3;
13559 htab
->tga_group
->lr_restore
= 23 * 4;
13560 htab
->tga_group
->stub_sec
->size
= 24 * 4;
13563 if (htab
->stub_iteration
<= STUB_SHRINK_ITER
13564 || htab
->brlt
->rawsize
< htab
->brlt
->size
)
13565 htab
->brlt
->rawsize
= htab
->brlt
->size
;
13566 htab
->brlt
->size
= 0;
13567 htab
->brlt
->reloc_count
= 0;
13568 htab
->brlt
->flags
&= ~SEC_RELOC
;
13569 if (htab
->relbrlt
!= NULL
)
13570 htab
->relbrlt
->size
= 0;
13572 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_size_one_stub
, info
);
13574 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13575 if (group
->needs_save_res
)
13576 group
->stub_sec
->size
+= htab
->sfpr
->size
;
13578 if (info
->emitrelocations
13579 && htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13581 htab
->glink
->reloc_count
= 1;
13582 htab
->glink
->flags
|= SEC_RELOC
;
13585 if (htab
->glink_eh_frame
!= NULL
13586 && !bfd_is_abs_section (htab
->glink_eh_frame
->output_section
)
13587 && htab
->glink_eh_frame
->output_section
->size
> 8)
13589 size_t size
= 0, align
= 4;
13591 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13592 if (group
->eh_size
!= 0)
13593 size
+= (group
->eh_size
+ 17 + align
- 1) & -align
;
13594 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13595 size
+= (24 + align
- 1) & -align
;
13597 size
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
13598 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13599 size
= (size
+ align
- 1) & -align
;
13600 htab
->glink_eh_frame
->rawsize
= htab
->glink_eh_frame
->size
;
13601 htab
->glink_eh_frame
->size
= size
;
13604 if (htab
->params
->plt_stub_align
!= 0)
13605 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13606 if (group
->stub_sec
!= NULL
)
13608 int align
= abs (htab
->params
->plt_stub_align
);
13609 group
->stub_sec
->size
13610 = (group
->stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
13613 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13614 if (group
->stub_sec
!= NULL
13615 && group
->stub_sec
->rawsize
!= group
->stub_sec
->size
13616 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
13617 || group
->stub_sec
->rawsize
< group
->stub_sec
->size
))
13621 && (htab
->brlt
->rawsize
== htab
->brlt
->size
13622 || (htab
->stub_iteration
> STUB_SHRINK_ITER
13623 && htab
->brlt
->rawsize
> htab
->brlt
->size
))
13624 && (htab
->glink_eh_frame
== NULL
13625 || htab
->glink_eh_frame
->rawsize
== htab
->glink_eh_frame
->size
)
13626 && (htab
->tga_group
== NULL
13627 || htab
->stub_iteration
> 1))
13630 /* Ask the linker to do its stuff. */
13631 (*htab
->params
->layout_sections_again
) ();
13634 if (htab
->glink_eh_frame
!= NULL
13635 && htab
->glink_eh_frame
->size
!= 0)
13638 bfd_byte
*p
, *last_fde
;
13639 size_t last_fde_len
, size
, align
, pad
;
13640 struct map_stub
*group
;
13642 /* It is necessary to at least have a rough outline of the
13643 linker generated CIEs and FDEs written before
13644 bfd_elf_discard_info is run, in order for these FDEs to be
13645 indexed in .eh_frame_hdr. */
13646 p
= bfd_zalloc (htab
->glink_eh_frame
->owner
, htab
->glink_eh_frame
->size
);
13649 htab
->glink_eh_frame
->contents
= p
;
13653 memcpy (p
, glink_eh_frame_cie
, sizeof (glink_eh_frame_cie
));
13654 /* CIE length (rewrite in case little-endian). */
13655 last_fde_len
= ((sizeof (glink_eh_frame_cie
) + align
- 1) & -align
) - 4;
13656 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13657 p
+= last_fde_len
+ 4;
13659 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
13660 if (group
->eh_size
!= 0)
13662 group
->eh_base
= p
- htab
->glink_eh_frame
->contents
;
13664 last_fde_len
= ((group
->eh_size
+ 17 + align
- 1) & -align
) - 4;
13666 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13669 val
= p
- htab
->glink_eh_frame
->contents
;
13670 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13672 /* Offset to stub section, written later. */
13674 /* stub section size. */
13675 bfd_put_32 (htab
->elf
.dynobj
, group
->stub_sec
->size
, p
);
13677 /* Augmentation. */
13679 /* Make sure we don't have all nops. This is enough for
13680 elf-eh-frame.c to detect the last non-nop opcode. */
13681 p
[group
->eh_size
- 1] = DW_CFA_advance_loc
+ 1;
13682 p
= last_fde
+ last_fde_len
+ 4;
13684 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
13687 last_fde_len
= ((24 + align
- 1) & -align
) - 4;
13689 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
, p
);
13692 val
= p
- htab
->glink_eh_frame
->contents
;
13693 bfd_put_32 (htab
->elf
.dynobj
, val
, p
);
13695 /* Offset to .glink, written later. */
13698 bfd_put_32 (htab
->elf
.dynobj
, htab
->glink
->size
- 8, p
);
13700 /* Augmentation. */
13703 *p
++ = DW_CFA_advance_loc
+ 1;
13704 *p
++ = DW_CFA_register
;
13706 *p
++ = htab
->opd_abi
? 12 : 0;
13707 *p
++ = DW_CFA_advance_loc
+ (htab
->opd_abi
? 5 : 7);
13708 *p
++ = DW_CFA_restore_extended
;
13710 p
+= ((24 + align
- 1) & -align
) - 24;
13712 /* Subsume any padding into the last FDE if user .eh_frame
13713 sections are aligned more than glink_eh_frame. Otherwise any
13714 zero padding will be seen as a terminator. */
13715 align
= 1ul << htab
->glink_eh_frame
->output_section
->alignment_power
;
13716 size
= p
- htab
->glink_eh_frame
->contents
;
13717 pad
= ((size
+ align
- 1) & -align
) - size
;
13718 htab
->glink_eh_frame
->size
= size
+ pad
;
13719 bfd_put_32 (htab
->elf
.dynobj
, last_fde_len
+ pad
, last_fde
);
13722 maybe_strip_output (info
, htab
->brlt
);
13723 if (htab
->relbrlt
!= NULL
)
13724 maybe_strip_output (info
, htab
->relbrlt
);
13725 if (htab
->glink_eh_frame
!= NULL
)
13726 maybe_strip_output (info
, htab
->glink_eh_frame
);
13731 /* Called after we have determined section placement. If sections
13732 move, we'll be called again. Provide a value for TOCstart. */
13735 ppc64_elf_set_toc (struct bfd_link_info
*info
, bfd
*obfd
)
13738 bfd_vma TOCstart
, adjust
;
13742 struct elf_link_hash_entry
*h
;
13743 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
13745 if (is_elf_hash_table (htab
)
13746 && htab
->hgot
!= NULL
)
13750 h
= elf_link_hash_lookup (htab
, ".TOC.", FALSE
, FALSE
, TRUE
);
13751 if (is_elf_hash_table (htab
))
13755 && h
->root
.type
== bfd_link_hash_defined
13756 && !h
->root
.linker_def
13757 && (!is_elf_hash_table (htab
)
13758 || h
->def_regular
))
13760 TOCstart
= defined_sym_val (h
) - TOC_BASE_OFF
;
13761 _bfd_set_gp_value (obfd
, TOCstart
);
13766 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13767 order. The TOC starts where the first of these sections starts. */
13768 s
= bfd_get_section_by_name (obfd
, ".got");
13769 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13770 s
= bfd_get_section_by_name (obfd
, ".toc");
13771 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13772 s
= bfd_get_section_by_name (obfd
, ".tocbss");
13773 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13774 s
= bfd_get_section_by_name (obfd
, ".plt");
13775 if (s
== NULL
|| (s
->flags
& SEC_EXCLUDE
) != 0)
13777 /* This may happen for
13778 o references to TOC base (SYM@toc / TOC[tc0]) without a
13780 o bad linker script
13781 o --gc-sections and empty TOC sections
13783 FIXME: Warn user? */
13785 /* Look for a likely section. We probably won't even be
13787 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13788 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_READONLY
13790 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13793 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13794 if ((s
->flags
& (SEC_ALLOC
| SEC_SMALL_DATA
| SEC_EXCLUDE
))
13795 == (SEC_ALLOC
| SEC_SMALL_DATA
))
13798 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13799 if ((s
->flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_EXCLUDE
))
13803 for (s
= obfd
->sections
; s
!= NULL
; s
= s
->next
)
13804 if ((s
->flags
& (SEC_ALLOC
| SEC_EXCLUDE
)) == SEC_ALLOC
)
13810 TOCstart
= s
->output_section
->vma
+ s
->output_offset
;
13812 /* Force alignment. */
13813 adjust
= TOCstart
& (TOC_BASE_ALIGN
- 1);
13814 TOCstart
-= adjust
;
13815 _bfd_set_gp_value (obfd
, TOCstart
);
13817 if (info
!= NULL
&& s
!= NULL
)
13819 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
13823 if (htab
->elf
.hgot
!= NULL
)
13825 htab
->elf
.hgot
->root
.u
.def
.value
= TOC_BASE_OFF
- adjust
;
13826 htab
->elf
.hgot
->root
.u
.def
.section
= s
;
13831 struct bfd_link_hash_entry
*bh
= NULL
;
13832 _bfd_generic_link_add_one_symbol (info
, obfd
, ".TOC.", BSF_GLOBAL
,
13833 s
, TOC_BASE_OFF
- adjust
,
13834 NULL
, FALSE
, FALSE
, &bh
);
13840 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13841 write out any global entry stubs, and PLT relocations. */
13844 build_global_entry_stubs_and_plt (struct elf_link_hash_entry
*h
, void *inf
)
13846 struct bfd_link_info
*info
;
13847 struct ppc_link_hash_table
*htab
;
13848 struct plt_entry
*ent
;
13851 if (h
->root
.type
== bfd_link_hash_indirect
)
13855 htab
= ppc_hash_table (info
);
13859 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13860 if (ent
->plt
.offset
!= (bfd_vma
) -1)
13862 /* This symbol has an entry in the procedure linkage
13863 table. Set it up. */
13864 Elf_Internal_Rela rela
;
13865 asection
*plt
, *relplt
;
13868 if (!htab
->elf
.dynamic_sections_created
13869 || h
->dynindx
== -1)
13871 if (!(h
->def_regular
13872 && (h
->root
.type
== bfd_link_hash_defined
13873 || h
->root
.type
== bfd_link_hash_defweak
)))
13875 if (h
->type
== STT_GNU_IFUNC
)
13877 plt
= htab
->elf
.iplt
;
13878 relplt
= htab
->elf
.irelplt
;
13879 htab
->elf
.ifunc_resolvers
= TRUE
;
13881 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
13883 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
13887 plt
= htab
->pltlocal
;
13888 if (bfd_link_pic (info
))
13890 relplt
= htab
->relpltlocal
;
13892 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
13894 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
13899 rela
.r_addend
= defined_sym_val (h
) + ent
->addend
;
13901 if (relplt
== NULL
)
13903 loc
= plt
->contents
+ ent
->plt
.offset
;
13904 bfd_put_64 (info
->output_bfd
, rela
.r_addend
, loc
);
13907 bfd_vma toc
= elf_gp (info
->output_bfd
);
13908 toc
+= htab
->sec_info
[h
->root
.u
.def
.section
->id
].toc_off
;
13909 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
13914 rela
.r_offset
= (plt
->output_section
->vma
13915 + plt
->output_offset
13916 + ent
->plt
.offset
);
13917 loc
= relplt
->contents
+ (relplt
->reloc_count
++
13918 * sizeof (Elf64_External_Rela
));
13919 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13924 rela
.r_offset
= (htab
->elf
.splt
->output_section
->vma
13925 + htab
->elf
.splt
->output_offset
13926 + ent
->plt
.offset
);
13927 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_JMP_SLOT
);
13928 rela
.r_addend
= ent
->addend
;
13929 loc
= (htab
->elf
.srelplt
->contents
13930 + ((ent
->plt
.offset
- PLT_INITIAL_ENTRY_SIZE (htab
))
13931 / PLT_ENTRY_SIZE (htab
) * sizeof (Elf64_External_Rela
)));
13932 if (h
->type
== STT_GNU_IFUNC
&& is_static_defined (h
))
13933 htab
->elf
.ifunc_resolvers
= TRUE
;
13934 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
13938 if (!h
->pointer_equality_needed
)
13941 if (h
->def_regular
)
13944 s
= htab
->global_entry
;
13945 if (s
== NULL
|| s
->size
== 0)
13948 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
13949 if (ent
->plt
.offset
!= (bfd_vma
) -1
13950 && ent
->addend
== 0)
13956 p
= s
->contents
+ h
->root
.u
.def
.value
;
13957 plt
= htab
->elf
.splt
;
13958 if (!htab
->elf
.dynamic_sections_created
13959 || h
->dynindx
== -1)
13961 if (h
->type
== STT_GNU_IFUNC
)
13962 plt
= htab
->elf
.iplt
;
13964 plt
= htab
->pltlocal
;
13966 off
= ent
->plt
.offset
+ plt
->output_offset
+ plt
->output_section
->vma
;
13967 off
-= h
->root
.u
.def
.value
+ s
->output_offset
+ s
->output_section
->vma
;
13969 if (off
+ 0x80008000 > 0xffffffff || (off
& 3) != 0)
13971 info
->callbacks
->einfo
13972 (_("%P: linkage table error against `%pT'\n"),
13973 h
->root
.root
.string
);
13974 bfd_set_error (bfd_error_bad_value
);
13975 htab
->stub_error
= TRUE
;
13978 htab
->stub_count
[ppc_stub_global_entry
- 1] += 1;
13979 if (htab
->params
->emit_stub_syms
)
13981 size_t len
= strlen (h
->root
.root
.string
);
13982 char *name
= bfd_malloc (sizeof "12345678.global_entry." + len
);
13987 sprintf (name
, "%08x.global_entry.%s", s
->id
, h
->root
.root
.string
);
13988 h
= elf_link_hash_lookup (&htab
->elf
, name
, TRUE
, FALSE
, FALSE
);
13991 if (h
->root
.type
== bfd_link_hash_new
)
13993 h
->root
.type
= bfd_link_hash_defined
;
13994 h
->root
.u
.def
.section
= s
;
13995 h
->root
.u
.def
.value
= p
- s
->contents
;
13996 h
->ref_regular
= 1;
13997 h
->def_regular
= 1;
13998 h
->ref_regular_nonweak
= 1;
13999 h
->forced_local
= 1;
14001 h
->root
.linker_def
= 1;
14005 if (PPC_HA (off
) != 0)
14007 bfd_put_32 (s
->owner
, ADDIS_R12_R12
| PPC_HA (off
), p
);
14010 bfd_put_32 (s
->owner
, LD_R12_0R12
| PPC_LO (off
), p
);
14012 bfd_put_32 (s
->owner
, MTCTR_R12
, p
);
14014 bfd_put_32 (s
->owner
, BCTR
, p
);
14020 /* Write PLT relocs for locals. */
14023 write_plt_relocs_for_local_syms (struct bfd_link_info
*info
)
14025 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14028 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
14030 struct got_entry
**lgot_ents
, **end_lgot_ents
;
14031 struct plt_entry
**local_plt
, **lplt
, **end_local_plt
;
14032 Elf_Internal_Shdr
*symtab_hdr
;
14033 bfd_size_type locsymcount
;
14034 Elf_Internal_Sym
*local_syms
= NULL
;
14035 struct plt_entry
*ent
;
14037 if (!is_ppc64_elf (ibfd
))
14040 lgot_ents
= elf_local_got_ents (ibfd
);
14044 symtab_hdr
= &elf_symtab_hdr (ibfd
);
14045 locsymcount
= symtab_hdr
->sh_info
;
14046 end_lgot_ents
= lgot_ents
+ locsymcount
;
14047 local_plt
= (struct plt_entry
**) end_lgot_ents
;
14048 end_local_plt
= local_plt
+ locsymcount
;
14049 for (lplt
= local_plt
; lplt
< end_local_plt
; ++lplt
)
14050 for (ent
= *lplt
; ent
!= NULL
; ent
= ent
->next
)
14051 if (ent
->plt
.offset
!= (bfd_vma
) -1)
14053 Elf_Internal_Sym
*sym
;
14055 asection
*plt
, *relplt
;
14059 if (!get_sym_h (NULL
, &sym
, &sym_sec
, NULL
, &local_syms
,
14060 lplt
- local_plt
, ibfd
))
14062 if (symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14067 val
= sym
->st_value
+ ent
->addend
;
14068 if (ELF_ST_TYPE (sym
->st_info
) != STT_GNU_IFUNC
)
14069 val
+= PPC64_LOCAL_ENTRY_OFFSET (sym
->st_other
);
14070 if (sym_sec
!= NULL
&& sym_sec
->output_section
!= NULL
)
14071 val
+= sym_sec
->output_offset
+ sym_sec
->output_section
->vma
;
14073 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14075 htab
->elf
.ifunc_resolvers
= TRUE
;
14076 plt
= htab
->elf
.iplt
;
14077 relplt
= htab
->elf
.irelplt
;
14081 plt
= htab
->pltlocal
;
14082 relplt
= bfd_link_pic (info
) ? htab
->relpltlocal
: NULL
;
14085 if (relplt
== NULL
)
14087 loc
= plt
->contents
+ ent
->plt
.offset
;
14088 bfd_put_64 (info
->output_bfd
, val
, loc
);
14091 bfd_vma toc
= elf_gp (ibfd
);
14092 bfd_put_64 (info
->output_bfd
, toc
, loc
+ 8);
14097 Elf_Internal_Rela rela
;
14098 rela
.r_offset
= (ent
->plt
.offset
14099 + plt
->output_offset
14100 + plt
->output_section
->vma
);
14101 if (ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
14104 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_IREL
);
14106 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
14111 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_JMP_SLOT
);
14113 rela
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
14115 rela
.r_addend
= val
;
14116 loc
= relplt
->contents
+ (relplt
->reloc_count
++
14117 * sizeof (Elf64_External_Rela
));
14118 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rela
, loc
);
14122 if (local_syms
!= NULL
14123 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
14125 if (!info
->keep_memory
)
14128 symtab_hdr
->contents
= (unsigned char *) local_syms
;
14134 /* Emit the static wrapper function preserving registers around a
14135 __tls_get_addr_opt call. */
14138 emit_tga_desc (struct ppc_link_hash_table
*htab
)
14140 asection
*stub_sec
= htab
->tga_group
->stub_sec
;
14141 unsigned int cfa_updt
= 11 * 4;
14143 bfd_vma to
, from
, delta
;
14145 BFD_ASSERT (htab
->tga_desc_fd
->elf
.root
.type
== bfd_link_hash_defined
14146 && htab
->tga_desc_fd
->elf
.root
.u
.def
.section
== stub_sec
14147 && htab
->tga_desc_fd
->elf
.root
.u
.def
.value
== 0);
14148 to
= defined_sym_val (&htab
->tls_get_addr_fd
->elf
);
14149 from
= defined_sym_val (&htab
->tga_desc_fd
->elf
) + cfa_updt
;
14151 if (delta
+ (1 << 25) >= 1 << 26)
14153 _bfd_error_handler (_("__tls_get_addr call offset overflow"));
14154 htab
->stub_error
= TRUE
;
14158 p
= stub_sec
->contents
;
14159 p
= tls_get_addr_prologue (htab
->elf
.dynobj
, p
, htab
);
14160 bfd_put_32 (stub_sec
->owner
, B_DOT
| 1 | (delta
& 0x3fffffc), p
);
14162 p
= tls_get_addr_epilogue (htab
->elf
.dynobj
, p
, htab
);
14163 return stub_sec
->size
== (bfd_size_type
) (p
- stub_sec
->contents
);
14166 /* Emit eh_frame describing the static wrapper function. */
14169 emit_tga_desc_eh_frame (struct ppc_link_hash_table
*htab
, bfd_byte
*p
)
14171 unsigned int cfa_updt
= 11 * 4;
14174 *p
++ = DW_CFA_advance_loc
+ cfa_updt
/ 4;
14175 *p
++ = DW_CFA_def_cfa_offset
;
14183 *p
++ = DW_CFA_offset_extended_sf
;
14185 *p
++ = (-16 / 8) & 0x7f;
14186 for (i
= 4; i
< 12; i
++)
14188 *p
++ = DW_CFA_offset
+ i
;
14189 *p
++ = (htab
->opd_abi
? 13 : 12) - i
;
14191 *p
++ = DW_CFA_advance_loc
+ 10;
14192 *p
++ = DW_CFA_def_cfa_offset
;
14194 for (i
= 4; i
< 12; i
++)
14195 *p
++ = DW_CFA_restore
+ i
;
14196 *p
++ = DW_CFA_advance_loc
+ 2;
14197 *p
++ = DW_CFA_restore_extended
;
14202 /* Build all the stubs associated with the current output file.
14203 The stubs are kept in a hash table attached to the main linker
14204 hash table. This function is called via gldelf64ppc_finish. */
14207 ppc64_elf_build_stubs (struct bfd_link_info
*info
,
14210 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
14211 struct map_stub
*group
;
14212 asection
*stub_sec
;
14214 int stub_sec_count
= 0;
14219 /* Allocate memory to hold the linker stubs. */
14220 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14222 group
->eh_size
= 0;
14223 group
->lr_restore
= 0;
14224 if ((stub_sec
= group
->stub_sec
) != NULL
14225 && stub_sec
->size
!= 0)
14227 stub_sec
->contents
= bfd_zalloc (htab
->params
->stub_bfd
,
14229 if (stub_sec
->contents
== NULL
)
14231 stub_sec
->size
= 0;
14235 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14240 /* Build the .glink plt call stub. */
14241 if (htab
->params
->emit_stub_syms
)
14243 struct elf_link_hash_entry
*h
;
14244 h
= elf_link_hash_lookup (&htab
->elf
, "__glink_PLTresolve",
14245 TRUE
, FALSE
, FALSE
);
14248 if (h
->root
.type
== bfd_link_hash_new
)
14250 h
->root
.type
= bfd_link_hash_defined
;
14251 h
->root
.u
.def
.section
= htab
->glink
;
14252 h
->root
.u
.def
.value
= 8;
14253 h
->ref_regular
= 1;
14254 h
->def_regular
= 1;
14255 h
->ref_regular_nonweak
= 1;
14256 h
->forced_local
= 1;
14258 h
->root
.linker_def
= 1;
14261 plt0
= (htab
->elf
.splt
->output_section
->vma
14262 + htab
->elf
.splt
->output_offset
14264 if (info
->emitrelocations
)
14266 Elf_Internal_Rela
*r
= get_relocs (htab
->glink
, 1);
14269 r
->r_offset
= (htab
->glink
->output_offset
14270 + htab
->glink
->output_section
->vma
);
14271 r
->r_info
= ELF64_R_INFO (0, R_PPC64_REL64
);
14272 r
->r_addend
= plt0
;
14274 p
= htab
->glink
->contents
;
14275 plt0
-= htab
->glink
->output_section
->vma
+ htab
->glink
->output_offset
;
14276 bfd_put_64 (htab
->glink
->owner
, plt0
, p
);
14280 bfd_put_32 (htab
->glink
->owner
, MFLR_R12
, p
);
14282 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14284 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14286 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14288 bfd_put_32 (htab
->glink
->owner
, MTLR_R12
, p
);
14290 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14292 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14294 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| 8, p
);
14296 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14298 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 16, p
);
14303 bfd_put_32 (htab
->glink
->owner
, MFLR_R0
, p
);
14305 bfd_put_32 (htab
->glink
->owner
, BCL_20_31
, p
);
14307 bfd_put_32 (htab
->glink
->owner
, MFLR_R11
, p
);
14309 bfd_put_32 (htab
->glink
->owner
, STD_R2_0R1
+ 24, p
);
14311 bfd_put_32 (htab
->glink
->owner
, LD_R2_0R11
| (-16 & 0xfffc), p
);
14313 bfd_put_32 (htab
->glink
->owner
, MTLR_R0
, p
);
14315 bfd_put_32 (htab
->glink
->owner
, SUB_R12_R12_R11
, p
);
14317 bfd_put_32 (htab
->glink
->owner
, ADD_R11_R2_R11
, p
);
14319 bfd_put_32 (htab
->glink
->owner
, ADDI_R0_R12
| (-48 & 0xffff), p
);
14321 bfd_put_32 (htab
->glink
->owner
, LD_R12_0R11
, p
);
14323 bfd_put_32 (htab
->glink
->owner
, SRDI_R0_R0_2
, p
);
14325 bfd_put_32 (htab
->glink
->owner
, MTCTR_R12
, p
);
14327 bfd_put_32 (htab
->glink
->owner
, LD_R11_0R11
| 8, p
);
14330 bfd_put_32 (htab
->glink
->owner
, BCTR
, p
);
14332 BFD_ASSERT (p
== htab
->glink
->contents
+ GLINK_PLTRESOLVE_SIZE (htab
));
14334 /* Build the .glink lazy link call stubs. */
14336 while (p
< htab
->glink
->contents
+ htab
->glink
->size
)
14342 bfd_put_32 (htab
->glink
->owner
, LI_R0_0
| indx
, p
);
14347 bfd_put_32 (htab
->glink
->owner
, LIS_R0_0
| PPC_HI (indx
), p
);
14349 bfd_put_32 (htab
->glink
->owner
, ORI_R0_R0_0
| PPC_LO (indx
),
14354 bfd_put_32 (htab
->glink
->owner
,
14355 B_DOT
| ((htab
->glink
->contents
- p
+ 8) & 0x3fffffc), p
);
14361 if (htab
->tga_group
!= NULL
)
14363 htab
->tga_group
->lr_restore
= 23 * 4;
14364 htab
->tga_group
->stub_sec
->size
= 24 * 4;
14365 if (!emit_tga_desc (htab
))
14367 if (htab
->glink_eh_frame
!= NULL
14368 && htab
->glink_eh_frame
->size
!= 0)
14372 p
= htab
->glink_eh_frame
->contents
;
14373 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14375 htab
->tga_group
->eh_size
= emit_tga_desc_eh_frame (htab
, p
) - p
;
14379 /* Build .glink global entry stubs, and PLT relocs for globals. */
14380 elf_link_hash_traverse (&htab
->elf
, build_global_entry_stubs_and_plt
, info
);
14382 if (!write_plt_relocs_for_local_syms (info
))
14385 if (htab
->brlt
!= NULL
&& htab
->brlt
->size
!= 0)
14387 htab
->brlt
->contents
= bfd_zalloc (htab
->brlt
->owner
,
14389 if (htab
->brlt
->contents
== NULL
)
14392 if (htab
->relbrlt
!= NULL
&& htab
->relbrlt
->size
!= 0)
14394 htab
->relbrlt
->contents
= bfd_zalloc (htab
->relbrlt
->owner
,
14395 htab
->relbrlt
->size
);
14396 if (htab
->relbrlt
->contents
== NULL
)
14400 /* Build the stubs as directed by the stub hash table. */
14401 bfd_hash_traverse (&htab
->stub_hash_table
, ppc_build_one_stub
, info
);
14403 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14404 if (group
->needs_save_res
)
14405 group
->stub_sec
->size
+= htab
->sfpr
->size
;
14407 if (htab
->relbrlt
!= NULL
)
14408 htab
->relbrlt
->reloc_count
= 0;
14410 if (htab
->params
->plt_stub_align
!= 0)
14411 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14412 if ((stub_sec
= group
->stub_sec
) != NULL
)
14414 int align
= abs (htab
->params
->plt_stub_align
);
14415 stub_sec
->size
= (stub_sec
->size
+ (1 << align
) - 1) & -(1 << align
);
14418 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14419 if (group
->needs_save_res
)
14421 stub_sec
= group
->stub_sec
;
14422 memcpy (stub_sec
->contents
+ stub_sec
->size
- htab
->sfpr
->size
,
14423 htab
->sfpr
->contents
, htab
->sfpr
->size
);
14424 if (htab
->params
->emit_stub_syms
)
14428 for (i
= 0; i
< ARRAY_SIZE (save_res_funcs
); i
++)
14429 if (!sfpr_define (info
, &save_res_funcs
[i
], stub_sec
))
14434 if (htab
->glink_eh_frame
!= NULL
14435 && htab
->glink_eh_frame
->size
!= 0)
14440 p
= htab
->glink_eh_frame
->contents
;
14441 p
+= (sizeof (glink_eh_frame_cie
) + align
- 1) & -align
;
14443 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14444 if (group
->eh_size
!= 0)
14446 /* Offset to stub section. */
14447 val
= (group
->stub_sec
->output_section
->vma
14448 + group
->stub_sec
->output_offset
);
14449 val
-= (htab
->glink_eh_frame
->output_section
->vma
14450 + htab
->glink_eh_frame
->output_offset
14451 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14452 if (val
+ 0x80000000 > 0xffffffff)
14455 (_("%s offset too large for .eh_frame sdata4 encoding"),
14456 group
->stub_sec
->name
);
14459 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14460 p
+= (group
->eh_size
+ 17 + 3) & -4;
14462 if (htab
->glink
!= NULL
&& htab
->glink
->size
!= 0)
14464 /* Offset to .glink. */
14465 val
= (htab
->glink
->output_section
->vma
14466 + htab
->glink
->output_offset
14468 val
-= (htab
->glink_eh_frame
->output_section
->vma
14469 + htab
->glink_eh_frame
->output_offset
14470 + (p
+ 8 - htab
->glink_eh_frame
->contents
));
14471 if (val
+ 0x80000000 > 0xffffffff)
14474 (_("%s offset too large for .eh_frame sdata4 encoding"),
14475 htab
->glink
->name
);
14478 bfd_put_32 (htab
->elf
.dynobj
, val
, p
+ 8);
14479 p
+= (24 + align
- 1) & -align
;
14483 for (group
= htab
->group
; group
!= NULL
; group
= group
->next
)
14484 if ((stub_sec
= group
->stub_sec
) != NULL
)
14486 stub_sec_count
+= 1;
14487 if (stub_sec
->rawsize
!= stub_sec
->size
14488 && (htab
->stub_iteration
<= STUB_SHRINK_ITER
14489 || stub_sec
->rawsize
< stub_sec
->size
))
14495 htab
->stub_error
= TRUE
;
14496 _bfd_error_handler (_("stubs don't match calculated size"));
14499 if (htab
->stub_error
)
14505 if (asprintf (&groupmsg
,
14506 ngettext ("linker stubs in %u group\n",
14507 "linker stubs in %u groups\n",
14509 stub_sec_count
) < 0)
14513 if (asprintf (stats
, _("%s"
14515 " branch toc adj %lu\n"
14516 " branch notoc %lu\n"
14517 " branch both %lu\n"
14518 " long branch %lu\n"
14519 " long toc adj %lu\n"
14520 " long notoc %lu\n"
14523 " plt call save %lu\n"
14524 " plt call notoc %lu\n"
14525 " plt call both %lu\n"
14526 " global entry %lu"),
14528 htab
->stub_count
[ppc_stub_long_branch
- 1],
14529 htab
->stub_count
[ppc_stub_long_branch_r2off
- 1],
14530 htab
->stub_count
[ppc_stub_long_branch_notoc
- 1],
14531 htab
->stub_count
[ppc_stub_long_branch_both
- 1],
14532 htab
->stub_count
[ppc_stub_plt_branch
- 1],
14533 htab
->stub_count
[ppc_stub_plt_branch_r2off
- 1],
14534 htab
->stub_count
[ppc_stub_plt_branch_notoc
- 1],
14535 htab
->stub_count
[ppc_stub_plt_branch_both
- 1],
14536 htab
->stub_count
[ppc_stub_plt_call
- 1],
14537 htab
->stub_count
[ppc_stub_plt_call_r2save
- 1],
14538 htab
->stub_count
[ppc_stub_plt_call_notoc
- 1],
14539 htab
->stub_count
[ppc_stub_plt_call_both
- 1],
14540 htab
->stub_count
[ppc_stub_global_entry
- 1]) < 0)
14548 /* What to do when ld finds relocations against symbols defined in
14549 discarded sections. */
14551 static unsigned int
14552 ppc64_elf_action_discarded (asection
*sec
)
14554 if (strcmp (".opd", sec
->name
) == 0)
14557 if (strcmp (".toc", sec
->name
) == 0)
14560 if (strcmp (".toc1", sec
->name
) == 0)
14563 return _bfd_elf_default_action_discarded (sec
);
14566 /* These are the dynamic relocations supported by glibc. */
14569 ppc64_glibc_dynamic_reloc (enum elf_ppc64_reloc_type r_type
)
14573 case R_PPC64_RELATIVE
:
14575 case R_PPC64_ADDR64
:
14576 case R_PPC64_GLOB_DAT
:
14577 case R_PPC64_IRELATIVE
:
14578 case R_PPC64_JMP_IREL
:
14579 case R_PPC64_JMP_SLOT
:
14580 case R_PPC64_DTPMOD64
:
14581 case R_PPC64_DTPREL64
:
14582 case R_PPC64_TPREL64
:
14583 case R_PPC64_TPREL16_LO_DS
:
14584 case R_PPC64_TPREL16_DS
:
14585 case R_PPC64_TPREL16
:
14586 case R_PPC64_TPREL16_LO
:
14587 case R_PPC64_TPREL16_HI
:
14588 case R_PPC64_TPREL16_HIGH
:
14589 case R_PPC64_TPREL16_HA
:
14590 case R_PPC64_TPREL16_HIGHA
:
14591 case R_PPC64_TPREL16_HIGHER
:
14592 case R_PPC64_TPREL16_HIGHEST
:
14593 case R_PPC64_TPREL16_HIGHERA
:
14594 case R_PPC64_TPREL16_HIGHESTA
:
14595 case R_PPC64_ADDR16_LO_DS
:
14596 case R_PPC64_ADDR16_LO
:
14597 case R_PPC64_ADDR16_HI
:
14598 case R_PPC64_ADDR16_HIGH
:
14599 case R_PPC64_ADDR16_HA
:
14600 case R_PPC64_ADDR16_HIGHA
:
14601 case R_PPC64_REL30
:
14603 case R_PPC64_UADDR64
:
14604 case R_PPC64_UADDR32
:
14605 case R_PPC64_ADDR32
:
14606 case R_PPC64_ADDR24
:
14607 case R_PPC64_ADDR16
:
14608 case R_PPC64_UADDR16
:
14609 case R_PPC64_ADDR16_DS
:
14610 case R_PPC64_ADDR16_HIGHER
:
14611 case R_PPC64_ADDR16_HIGHEST
:
14612 case R_PPC64_ADDR16_HIGHERA
:
14613 case R_PPC64_ADDR16_HIGHESTA
:
14614 case R_PPC64_ADDR14
:
14615 case R_PPC64_ADDR14_BRTAKEN
:
14616 case R_PPC64_ADDR14_BRNTAKEN
:
14617 case R_PPC64_REL32
:
14618 case R_PPC64_REL64
:
14626 /* The RELOCATE_SECTION function is called by the ELF backend linker
14627 to handle the relocations for a section.
14629 The relocs are always passed as Rela structures; if the section
14630 actually uses Rel structures, the r_addend field will always be
14633 This function is responsible for adjust the section contents as
14634 necessary, and (if using Rela relocs and generating a
14635 relocatable output file) adjusting the reloc addend as
14638 This function does not have to worry about setting the reloc
14639 address or the reloc symbol index.
14641 LOCAL_SYMS is a pointer to the swapped in local symbols.
14643 LOCAL_SECTIONS is an array giving the section in the input file
14644 corresponding to the st_shndx field of each local symbol.
14646 The global hash table entry for the global symbols can be found
14647 via elf_sym_hashes (input_bfd).
14649 When generating relocatable output, this function must handle
14650 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14651 going to be the section symbol corresponding to the output
14652 section, which means that the addend must be adjusted
14656 ppc64_elf_relocate_section (bfd
*output_bfd
,
14657 struct bfd_link_info
*info
,
14659 asection
*input_section
,
14660 bfd_byte
*contents
,
14661 Elf_Internal_Rela
*relocs
,
14662 Elf_Internal_Sym
*local_syms
,
14663 asection
**local_sections
)
14665 struct ppc_link_hash_table
*htab
;
14666 Elf_Internal_Shdr
*symtab_hdr
;
14667 struct elf_link_hash_entry
**sym_hashes
;
14668 Elf_Internal_Rela
*rel
;
14669 Elf_Internal_Rela
*wrel
;
14670 Elf_Internal_Rela
*relend
;
14671 Elf_Internal_Rela outrel
;
14673 struct got_entry
**local_got_ents
;
14675 bfd_boolean ret
= TRUE
;
14676 bfd_boolean is_opd
;
14677 /* Assume 'at' branch hints. */
14678 bfd_boolean is_isa_v2
= TRUE
;
14679 bfd_boolean warned_dynamic
= FALSE
;
14680 bfd_vma d_offset
= (bfd_big_endian (input_bfd
) ? 2 : 0);
14682 /* Initialize howto table if needed. */
14683 if (!ppc64_elf_howto_table
[R_PPC64_ADDR32
])
14686 htab
= ppc_hash_table (info
);
14690 /* Don't relocate stub sections. */
14691 if (input_section
->owner
== htab
->params
->stub_bfd
)
14694 if (!is_ppc64_elf (input_bfd
))
14696 bfd_set_error (bfd_error_wrong_format
);
14700 local_got_ents
= elf_local_got_ents (input_bfd
);
14701 TOCstart
= elf_gp (output_bfd
);
14702 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
14703 sym_hashes
= elf_sym_hashes (input_bfd
);
14704 is_opd
= ppc64_elf_section_data (input_section
)->sec_type
== sec_opd
;
14706 rel
= wrel
= relocs
;
14707 relend
= relocs
+ input_section
->reloc_count
;
14708 for (; rel
< relend
; wrel
++, rel
++)
14710 enum elf_ppc64_reloc_type r_type
;
14712 bfd_reloc_status_type r
;
14713 Elf_Internal_Sym
*sym
;
14715 struct elf_link_hash_entry
*h_elf
;
14716 struct ppc_link_hash_entry
*h
;
14717 struct ppc_link_hash_entry
*fdh
;
14718 const char *sym_name
;
14719 unsigned long r_symndx
, toc_symndx
;
14720 bfd_vma toc_addend
;
14721 unsigned char tls_mask
, tls_gd
, tls_type
;
14722 unsigned char sym_type
;
14723 bfd_vma relocation
;
14724 bfd_boolean unresolved_reloc
, save_unresolved_reloc
;
14725 bfd_boolean warned
;
14726 enum { DEST_NORMAL
, DEST_OPD
, DEST_STUB
} reloc_dest
;
14729 struct ppc_stub_hash_entry
*stub_entry
;
14730 bfd_vma max_br_offset
;
14732 Elf_Internal_Rela orig_rel
;
14733 reloc_howto_type
*howto
;
14734 struct reloc_howto_struct alt_howto
;
14741 r_type
= ELF64_R_TYPE (rel
->r_info
);
14742 r_symndx
= ELF64_R_SYM (rel
->r_info
);
14744 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14745 symbol of the previous ADDR64 reloc. The symbol gives us the
14746 proper TOC base to use. */
14747 if (rel
->r_info
== ELF64_R_INFO (0, R_PPC64_TOC
)
14749 && ELF64_R_TYPE (wrel
[-1].r_info
) == R_PPC64_ADDR64
14751 r_symndx
= ELF64_R_SYM (wrel
[-1].r_info
);
14757 unresolved_reloc
= FALSE
;
14760 if (r_symndx
< symtab_hdr
->sh_info
)
14762 /* It's a local symbol. */
14763 struct _opd_sec_data
*opd
;
14765 sym
= local_syms
+ r_symndx
;
14766 sec
= local_sections
[r_symndx
];
14767 sym_name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
14768 sym_type
= ELF64_ST_TYPE (sym
->st_info
);
14769 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
14770 opd
= get_opd_info (sec
);
14771 if (opd
!= NULL
&& opd
->adjust
!= NULL
)
14773 long adjust
= opd
->adjust
[OPD_NDX (sym
->st_value
14779 /* If this is a relocation against the opd section sym
14780 and we have edited .opd, adjust the reloc addend so
14781 that ld -r and ld --emit-relocs output is correct.
14782 If it is a reloc against some other .opd symbol,
14783 then the symbol value will be adjusted later. */
14784 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
14785 rel
->r_addend
+= adjust
;
14787 relocation
+= adjust
;
14793 bfd_boolean ignored
;
14795 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
14796 r_symndx
, symtab_hdr
, sym_hashes
,
14797 h_elf
, sec
, relocation
,
14798 unresolved_reloc
, warned
, ignored
);
14799 sym_name
= h_elf
->root
.root
.string
;
14800 sym_type
= h_elf
->type
;
14802 && sec
->owner
== output_bfd
14803 && strcmp (sec
->name
, ".opd") == 0)
14805 /* This is a symbol defined in a linker script. All
14806 such are defined in output sections, even those
14807 defined by simple assignment from a symbol defined in
14808 an input section. Transfer the symbol to an
14809 appropriate input .opd section, so that a branch to
14810 this symbol will be mapped to the location specified
14811 by the opd entry. */
14812 struct bfd_link_order
*lo
;
14813 for (lo
= sec
->map_head
.link_order
; lo
!= NULL
; lo
= lo
->next
)
14814 if (lo
->type
== bfd_indirect_link_order
)
14816 asection
*isec
= lo
->u
.indirect
.section
;
14817 if (h_elf
->root
.u
.def
.value
>= isec
->output_offset
14818 && h_elf
->root
.u
.def
.value
< (isec
->output_offset
14821 h_elf
->root
.u
.def
.value
-= isec
->output_offset
;
14822 h_elf
->root
.u
.def
.section
= isec
;
14829 h
= ppc_elf_hash_entry (h_elf
);
14831 if (sec
!= NULL
&& discarded_section (sec
))
14833 _bfd_clear_contents (ppc64_elf_howto_table
[r_type
],
14834 input_bfd
, input_section
,
14835 contents
, rel
->r_offset
);
14836 wrel
->r_offset
= rel
->r_offset
;
14838 wrel
->r_addend
= 0;
14840 /* For ld -r, remove relocations in debug sections against
14841 symbols defined in discarded sections. Not done for
14842 non-debug to preserve relocs in .eh_frame which the
14843 eh_frame editing code expects to be present. */
14844 if (bfd_link_relocatable (info
)
14845 && (input_section
->flags
& SEC_DEBUGGING
))
14851 if (bfd_link_relocatable (info
))
14854 if (h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
)
14856 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
14857 sec
= bfd_abs_section_ptr
;
14858 unresolved_reloc
= FALSE
;
14861 /* TLS optimizations. Replace instruction sequences and relocs
14862 based on information we collected in tls_optimize. We edit
14863 RELOCS so that --emit-relocs will output something sensible
14864 for the final instruction stream. */
14869 tls_mask
= h
->tls_mask
;
14870 else if (local_got_ents
!= NULL
)
14872 struct plt_entry
**local_plt
= (struct plt_entry
**)
14873 (local_got_ents
+ symtab_hdr
->sh_info
);
14874 unsigned char *lgot_masks
= (unsigned char *)
14875 (local_plt
+ symtab_hdr
->sh_info
);
14876 tls_mask
= lgot_masks
[r_symndx
];
14878 if (((tls_mask
& TLS_TLS
) == 0 || tls_mask
== (TLS_TLS
| TLS_MARK
))
14879 && (r_type
== R_PPC64_TLS
14880 || r_type
== R_PPC64_TLSGD
14881 || r_type
== R_PPC64_TLSLD
))
14883 /* Check for toc tls entries. */
14884 unsigned char *toc_tls
;
14886 if (!get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14887 &local_syms
, rel
, input_bfd
))
14891 tls_mask
= *toc_tls
;
14894 /* Check that tls relocs are used with tls syms, and non-tls
14895 relocs are used with non-tls syms. */
14896 if (r_symndx
!= STN_UNDEF
14897 && r_type
!= R_PPC64_NONE
14899 || h
->elf
.root
.type
== bfd_link_hash_defined
14900 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
14901 && IS_PPC64_TLS_RELOC (r_type
) != (sym_type
== STT_TLS
))
14903 if ((tls_mask
& TLS_TLS
) != 0
14904 && (r_type
== R_PPC64_TLS
14905 || r_type
== R_PPC64_TLSGD
14906 || r_type
== R_PPC64_TLSLD
))
14907 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14910 info
->callbacks
->einfo
14911 (!IS_PPC64_TLS_RELOC (r_type
)
14912 /* xgettext:c-format */
14913 ? _("%H: %s used with TLS symbol `%pT'\n")
14914 /* xgettext:c-format */
14915 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14916 input_bfd
, input_section
, rel
->r_offset
,
14917 ppc64_elf_howto_table
[r_type
]->name
,
14921 /* Ensure reloc mapping code below stays sane. */
14922 if (R_PPC64_TOC16_LO_DS
!= R_PPC64_TOC16_DS
+ 1
14923 || R_PPC64_TOC16_LO
!= R_PPC64_TOC16
+ 1
14924 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TLSGD16
& 3)
14925 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TLSGD16_LO
& 3)
14926 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TLSGD16_HI
& 3)
14927 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TLSGD16_HA
& 3)
14928 || (R_PPC64_GOT_TLSLD16
& 3) != (R_PPC64_GOT_TPREL16_DS
& 3)
14929 || (R_PPC64_GOT_TLSLD16_LO
& 3) != (R_PPC64_GOT_TPREL16_LO_DS
& 3)
14930 || (R_PPC64_GOT_TLSLD16_HI
& 3) != (R_PPC64_GOT_TPREL16_HI
& 3)
14931 || (R_PPC64_GOT_TLSLD16_HA
& 3) != (R_PPC64_GOT_TPREL16_HA
& 3))
14939 case R_PPC64_LO_DS_OPT
:
14940 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- d_offset
);
14941 if ((insn
& (0x3fu
<< 26)) != 58u << 26)
14943 insn
+= (14u << 26) - (58u << 26);
14944 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- d_offset
);
14945 r_type
= R_PPC64_TOC16_LO
;
14946 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
14949 case R_PPC64_TOC16
:
14950 case R_PPC64_TOC16_LO
:
14951 case R_PPC64_TOC16_DS
:
14952 case R_PPC64_TOC16_LO_DS
:
14954 /* Check for toc tls entries. */
14955 unsigned char *toc_tls
;
14958 retval
= get_tls_mask (&toc_tls
, &toc_symndx
, &toc_addend
,
14959 &local_syms
, rel
, input_bfd
);
14965 tls_mask
= *toc_tls
;
14966 if (r_type
== R_PPC64_TOC16_DS
14967 || r_type
== R_PPC64_TOC16_LO_DS
)
14969 if ((tls_mask
& TLS_TLS
) != 0
14970 && (tls_mask
& (TLS_DTPREL
| TLS_TPREL
)) == 0)
14975 /* If we found a GD reloc pair, then we might be
14976 doing a GD->IE transition. */
14980 if ((tls_mask
& TLS_TLS
) != 0
14981 && (tls_mask
& TLS_GD
) == 0)
14984 else if (retval
== 3)
14986 if ((tls_mask
& TLS_TLS
) != 0
14987 && (tls_mask
& TLS_LD
) == 0)
14995 case R_PPC64_GOT_TPREL16_HI
:
14996 case R_PPC64_GOT_TPREL16_HA
:
14997 if ((tls_mask
& TLS_TLS
) != 0
14998 && (tls_mask
& TLS_TPREL
) == 0)
15000 rel
->r_offset
-= d_offset
;
15001 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15002 r_type
= R_PPC64_NONE
;
15003 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15007 case R_PPC64_GOT_TPREL16_DS
:
15008 case R_PPC64_GOT_TPREL16_LO_DS
:
15009 if ((tls_mask
& TLS_TLS
) != 0
15010 && (tls_mask
& TLS_TPREL
) == 0)
15013 insn
= bfd_get_32 (input_bfd
,
15014 contents
+ rel
->r_offset
- d_offset
);
15016 insn
|= 0x3c0d0000; /* addis 0,13,0 */
15017 bfd_put_32 (input_bfd
, insn
,
15018 contents
+ rel
->r_offset
- d_offset
);
15019 r_type
= R_PPC64_TPREL16_HA
;
15020 if (toc_symndx
!= 0)
15022 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15023 rel
->r_addend
= toc_addend
;
15024 /* We changed the symbol. Start over in order to
15025 get h, sym, sec etc. right. */
15029 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15033 case R_PPC64_GOT_TPREL_PCREL34
:
15034 if ((tls_mask
& TLS_TLS
) != 0
15035 && (tls_mask
& TLS_TPREL
) == 0)
15037 /* pld ra,sym@got@tprel@pcrel -> paddi ra,r13,sym@tprel */
15038 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15040 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15041 pinsn
+= ((2ULL << 56) + (-1ULL << 52)
15042 + (14ULL << 26) - (57ULL << 26) + (13ULL << 16));
15043 bfd_put_32 (input_bfd
, pinsn
>> 32,
15044 contents
+ rel
->r_offset
);
15045 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15046 contents
+ rel
->r_offset
+ 4);
15047 r_type
= R_PPC64_TPREL34
;
15048 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15053 if ((tls_mask
& TLS_TLS
) != 0
15054 && (tls_mask
& TLS_TPREL
) == 0)
15056 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15057 insn
= _bfd_elf_ppc_at_tls_transform (insn
, 13);
15060 if ((rel
->r_offset
& 3) == 0)
15062 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15063 /* Was PPC64_TLS which sits on insn boundary, now
15064 PPC64_TPREL16_LO which is at low-order half-word. */
15065 rel
->r_offset
+= d_offset
;
15066 r_type
= R_PPC64_TPREL16_LO
;
15067 if (toc_symndx
!= 0)
15069 rel
->r_info
= ELF64_R_INFO (toc_symndx
, r_type
);
15070 rel
->r_addend
= toc_addend
;
15071 /* We changed the symbol. Start over in order to
15072 get h, sym, sec etc. right. */
15076 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15078 else if ((rel
->r_offset
& 3) == 1)
15080 /* For pcrel IE to LE we already have the full
15081 offset and thus don't need an addi here. A nop
15083 if ((insn
& (0x3fu
<< 26)) == 14 << 26)
15085 /* Extract regs from addi rt,ra,si. */
15086 unsigned int rt
= (insn
>> 21) & 0x1f;
15087 unsigned int ra
= (insn
>> 16) & 0x1f;
15092 /* Build or ra,rs,rb with rb==rs, ie. mr ra,rs. */
15093 insn
= (rt
<< 16) | (ra
<< 21) | (ra
<< 11);
15094 insn
|= (31u << 26) | (444u << 1);
15097 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
- 1);
15102 case R_PPC64_GOT_TLSGD16_HI
:
15103 case R_PPC64_GOT_TLSGD16_HA
:
15105 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15109 case R_PPC64_GOT_TLSLD16_HI
:
15110 case R_PPC64_GOT_TLSLD16_HA
:
15111 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15114 if ((tls_mask
& tls_gd
) != 0)
15115 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 3)) & 3)
15116 + R_PPC64_GOT_TPREL16_DS
);
15119 rel
->r_offset
-= d_offset
;
15120 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15121 r_type
= R_PPC64_NONE
;
15123 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15127 case R_PPC64_GOT_TLSGD16
:
15128 case R_PPC64_GOT_TLSGD16_LO
:
15130 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15134 case R_PPC64_GOT_TLSLD16
:
15135 case R_PPC64_GOT_TLSLD16_LO
:
15136 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15138 unsigned int insn1
, insn2
;
15141 offset
= (bfd_vma
) -1;
15142 /* If not using the newer R_PPC64_TLSGD/LD to mark
15143 __tls_get_addr calls, we must trust that the call
15144 stays with its arg setup insns, ie. that the next
15145 reloc is the __tls_get_addr call associated with
15146 the current reloc. Edit both insns. */
15147 if (input_section
->nomark_tls_get_addr
15148 && rel
+ 1 < relend
15149 && branch_reloc_hash_match (input_bfd
, rel
+ 1,
15150 htab
->tls_get_addr_fd
,
15152 htab
->tls_get_addr
,
15154 offset
= rel
[1].r_offset
;
15155 /* We read the low GOT_TLS (or TOC16) insn because we
15156 need to keep the destination reg. It may be
15157 something other than the usual r3, and moved to r3
15158 before the call by intervening code. */
15159 insn1
= bfd_get_32 (input_bfd
,
15160 contents
+ rel
->r_offset
- d_offset
);
15161 if ((tls_mask
& tls_gd
) != 0)
15164 insn1
&= (0x1f << 21) | (0x1f << 16);
15165 insn1
|= 58u << 26; /* ld */
15166 insn2
= 0x7c636a14; /* add 3,3,13 */
15167 if (offset
!= (bfd_vma
) -1)
15168 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15169 if (r_type
== R_PPC64_TOC16
15170 || r_type
== R_PPC64_TOC16_LO
)
15171 r_type
+= R_PPC64_TOC16_DS
- R_PPC64_TOC16
;
15173 r_type
= (((r_type
- (R_PPC64_GOT_TLSGD16
& 1)) & 1)
15174 + R_PPC64_GOT_TPREL16_DS
);
15175 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15180 insn1
&= 0x1f << 21;
15181 insn1
|= 0x3c0d0000; /* addis r,13,0 */
15182 insn2
= 0x38630000; /* addi 3,3,0 */
15185 /* Was an LD reloc. */
15186 r_symndx
= STN_UNDEF
;
15187 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15189 else if (toc_symndx
!= 0)
15191 r_symndx
= toc_symndx
;
15192 rel
->r_addend
= toc_addend
;
15194 r_type
= R_PPC64_TPREL16_HA
;
15195 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15196 if (offset
!= (bfd_vma
) -1)
15198 rel
[1].r_info
= ELF64_R_INFO (r_symndx
,
15199 R_PPC64_TPREL16_LO
);
15200 rel
[1].r_offset
= offset
+ d_offset
;
15201 rel
[1].r_addend
= rel
->r_addend
;
15204 bfd_put_32 (input_bfd
, insn1
,
15205 contents
+ rel
->r_offset
- d_offset
);
15206 if (offset
!= (bfd_vma
) -1)
15208 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15209 if (offset
+ 8 <= input_section
->size
)
15211 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15212 if (insn2
== LD_R2_0R1
+ STK_TOC (htab
))
15213 bfd_put_32 (input_bfd
, NOP
, contents
+ offset
+ 4);
15216 if ((tls_mask
& tls_gd
) == 0
15217 && (tls_gd
== 0 || toc_symndx
!= 0))
15219 /* We changed the symbol. Start over in order
15220 to get h, sym, sec etc. right. */
15226 case R_PPC64_GOT_TLSGD_PCREL34
:
15227 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0)
15229 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15231 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15232 if ((tls_mask
& TLS_GDIE
) != 0)
15234 /* IE, pla -> pld */
15235 pinsn
+= (-2ULL << 56) + (57ULL << 26) - (14ULL << 26);
15236 r_type
= R_PPC64_GOT_TPREL_PCREL34
;
15240 /* LE, pla pcrel -> paddi r13 */
15241 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15242 r_type
= R_PPC64_TPREL34
;
15244 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15245 bfd_put_32 (input_bfd
, pinsn
>> 32,
15246 contents
+ rel
->r_offset
);
15247 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15248 contents
+ rel
->r_offset
+ 4);
15252 case R_PPC64_GOT_TLSLD_PCREL34
:
15253 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0)
15255 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15257 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15258 pinsn
+= (-1ULL << 52) + (13ULL << 16);
15259 bfd_put_32 (input_bfd
, pinsn
>> 32,
15260 contents
+ rel
->r_offset
);
15261 bfd_put_32 (input_bfd
, pinsn
& 0xffffffff,
15262 contents
+ rel
->r_offset
+ 4);
15263 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15264 r_symndx
= STN_UNDEF
;
15265 r_type
= R_PPC64_TPREL34
;
15266 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15271 case R_PPC64_TLSGD
:
15272 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_GD
) == 0
15273 && rel
+ 1 < relend
)
15275 unsigned int insn2
;
15276 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15278 offset
= rel
->r_offset
;
15279 if (is_plt_seq_reloc (r_type1
))
15281 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15282 if (r_type1
== R_PPC64_PLT_PCREL34
15283 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15284 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15285 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15289 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15290 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15292 if ((tls_mask
& TLS_GDIE
) != 0)
15295 r_type
= R_PPC64_NONE
;
15296 insn2
= 0x7c636a14; /* add 3,3,13 */
15301 if (toc_symndx
!= 0)
15303 r_symndx
= toc_symndx
;
15304 rel
->r_addend
= toc_addend
;
15306 if (r_type1
== R_PPC64_REL24_NOTOC
15307 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15309 r_type
= R_PPC64_NONE
;
15314 rel
->r_offset
= offset
+ d_offset
;
15315 r_type
= R_PPC64_TPREL16_LO
;
15316 insn2
= 0x38630000; /* addi 3,3,0 */
15319 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15320 /* Zap the reloc on the _tls_get_addr call too. */
15321 BFD_ASSERT (offset
== rel
[1].r_offset
);
15322 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15323 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15324 if ((tls_mask
& TLS_GDIE
) == 0
15326 && r_type
!= R_PPC64_NONE
)
15331 case R_PPC64_TLSLD
:
15332 if ((tls_mask
& TLS_TLS
) != 0 && (tls_mask
& TLS_LD
) == 0
15333 && rel
+ 1 < relend
)
15335 unsigned int insn2
;
15336 enum elf_ppc64_reloc_type r_type1
= ELF64_R_TYPE (rel
[1].r_info
);
15338 offset
= rel
->r_offset
;
15339 if (is_plt_seq_reloc (r_type1
))
15341 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
);
15342 if (r_type1
== R_PPC64_PLT_PCREL34
15343 || r_type1
== R_PPC64_PLT_PCREL34_NOTOC
)
15344 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15345 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15349 if (ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_PLTCALL
)
15350 bfd_put_32 (output_bfd
, NOP
, contents
+ offset
+ 4);
15352 if (r_type1
== R_PPC64_REL24_NOTOC
15353 || r_type1
== R_PPC64_PLTCALL_NOTOC
)
15355 r_type
= R_PPC64_NONE
;
15360 rel
->r_offset
= offset
+ d_offset
;
15361 r_symndx
= STN_UNDEF
;
15362 r_type
= R_PPC64_TPREL16_LO
;
15363 rel
->r_addend
= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
15364 insn2
= 0x38630000; /* addi 3,3,0 */
15366 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15367 /* Zap the reloc on the _tls_get_addr call too. */
15368 BFD_ASSERT (offset
== rel
[1].r_offset
);
15369 rel
[1].r_info
= ELF64_R_INFO (STN_UNDEF
, R_PPC64_NONE
);
15370 bfd_put_32 (input_bfd
, insn2
, contents
+ offset
);
15371 if (r_type
!= R_PPC64_NONE
)
15376 case R_PPC64_DTPMOD64
:
15377 if (rel
+ 1 < relend
15378 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_DTPREL64
)
15379 && rel
[1].r_offset
== rel
->r_offset
+ 8)
15381 if ((tls_mask
& TLS_GD
) == 0)
15383 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_NONE
);
15384 if ((tls_mask
& TLS_GDIE
) != 0)
15385 r_type
= R_PPC64_TPREL64
;
15388 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15389 r_type
= R_PPC64_NONE
;
15391 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15396 if ((tls_mask
& TLS_LD
) == 0)
15398 bfd_put_64 (output_bfd
, 1, contents
+ rel
->r_offset
);
15399 r_type
= R_PPC64_NONE
;
15400 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15405 case R_PPC64_TPREL64
:
15406 if ((tls_mask
& TLS_TPREL
) == 0)
15408 r_type
= R_PPC64_NONE
;
15409 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15413 case R_PPC64_ENTRY
:
15414 relocation
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15415 if (!bfd_link_pic (info
)
15416 && !info
->traditional_format
15417 && relocation
+ 0x80008000 <= 0xffffffff)
15419 unsigned int insn1
, insn2
;
15421 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15422 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15423 if ((insn1
& ~0xfffc) == LD_R2_0R12
15424 && insn2
== ADD_R2_R2_R12
)
15426 bfd_put_32 (input_bfd
,
15427 LIS_R2
+ PPC_HA (relocation
),
15428 contents
+ rel
->r_offset
);
15429 bfd_put_32 (input_bfd
,
15430 ADDI_R2_R2
+ PPC_LO (relocation
),
15431 contents
+ rel
->r_offset
+ 4);
15436 relocation
-= (rel
->r_offset
15437 + input_section
->output_offset
15438 + input_section
->output_section
->vma
);
15439 if (relocation
+ 0x80008000 <= 0xffffffff)
15441 unsigned int insn1
, insn2
;
15443 insn1
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15444 insn2
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
15445 if ((insn1
& ~0xfffc) == LD_R2_0R12
15446 && insn2
== ADD_R2_R2_R12
)
15448 bfd_put_32 (input_bfd
,
15449 ADDIS_R2_R12
+ PPC_HA (relocation
),
15450 contents
+ rel
->r_offset
);
15451 bfd_put_32 (input_bfd
,
15452 ADDI_R2_R2
+ PPC_LO (relocation
),
15453 contents
+ rel
->r_offset
+ 4);
15459 case R_PPC64_REL16_HA
:
15460 /* If we are generating a non-PIC executable, edit
15461 . 0: addis 2,12,.TOC.-0b@ha
15462 . addi 2,2,.TOC.-0b@l
15463 used by ELFv2 global entry points to set up r2, to
15466 if .TOC. is in range. */
15467 if (!bfd_link_pic (info
)
15468 && !info
->traditional_format
15470 && rel
->r_addend
== d_offset
15471 && h
!= NULL
&& &h
->elf
== htab
->elf
.hgot
15472 && rel
+ 1 < relend
15473 && rel
[1].r_info
== ELF64_R_INFO (r_symndx
, R_PPC64_REL16_LO
)
15474 && rel
[1].r_offset
== rel
->r_offset
+ 4
15475 && rel
[1].r_addend
== rel
->r_addend
+ 4
15476 && relocation
+ 0x80008000 <= 0xffffffff)
15478 unsigned int insn1
, insn2
;
15479 offset
= rel
->r_offset
- d_offset
;
15480 insn1
= bfd_get_32 (input_bfd
, contents
+ offset
);
15481 insn2
= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15482 if ((insn1
& 0xffff0000) == ADDIS_R2_R12
15483 && (insn2
& 0xffff0000) == ADDI_R2_R2
)
15485 r_type
= R_PPC64_ADDR16_HA
;
15486 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15487 rel
->r_addend
-= d_offset
;
15488 rel
[1].r_info
= ELF64_R_INFO (r_symndx
, R_PPC64_ADDR16_LO
);
15489 rel
[1].r_addend
-= d_offset
+ 4;
15490 bfd_put_32 (input_bfd
, LIS_R2
, contents
+ offset
);
15496 /* Handle other relocations that tweak non-addend part of insn. */
15498 max_br_offset
= 1 << 25;
15499 addend
= rel
->r_addend
;
15500 reloc_dest
= DEST_NORMAL
;
15506 case R_PPC64_TOCSAVE
:
15507 if (relocation
+ addend
== (rel
->r_offset
15508 + input_section
->output_offset
15509 + input_section
->output_section
->vma
)
15510 && tocsave_find (htab
, NO_INSERT
,
15511 &local_syms
, rel
, input_bfd
))
15513 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
15515 || insn
== CROR_151515
|| insn
== CROR_313131
)
15516 bfd_put_32 (input_bfd
,
15517 STD_R2_0R1
+ STK_TOC (htab
),
15518 contents
+ rel
->r_offset
);
15522 /* Branch taken prediction relocations. */
15523 case R_PPC64_ADDR14_BRTAKEN
:
15524 case R_PPC64_REL14_BRTAKEN
:
15525 insn
= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15526 /* Fall through. */
15528 /* Branch not taken prediction relocations. */
15529 case R_PPC64_ADDR14_BRNTAKEN
:
15530 case R_PPC64_REL14_BRNTAKEN
:
15531 insn
|= bfd_get_32 (input_bfd
,
15532 contents
+ rel
->r_offset
) & ~(0x01 << 21);
15533 /* Fall through. */
15535 case R_PPC64_REL14
:
15536 max_br_offset
= 1 << 15;
15537 /* Fall through. */
15539 case R_PPC64_REL24
:
15540 case R_PPC64_REL24_NOTOC
:
15541 case R_PPC64_PLTCALL
:
15542 case R_PPC64_PLTCALL_NOTOC
:
15543 /* Calls to functions with a different TOC, such as calls to
15544 shared objects, need to alter the TOC pointer. This is
15545 done using a linkage stub. A REL24 branching to these
15546 linkage stubs needs to be followed by a nop, as the nop
15547 will be replaced with an instruction to restore the TOC
15552 && h
->oh
->is_func_descriptor
)
15553 fdh
= ppc_follow_link (h
->oh
);
15554 stub_entry
= ppc_get_stub_entry (input_section
, sec
, fdh
, &orig_rel
,
15556 if ((r_type
== R_PPC64_PLTCALL
15557 || r_type
== R_PPC64_PLTCALL_NOTOC
)
15558 && stub_entry
!= NULL
15559 && stub_entry
->stub_type
>= ppc_stub_plt_call
15560 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15563 if (stub_entry
!= NULL
15564 && ((stub_entry
->stub_type
>= ppc_stub_plt_call
15565 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15566 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15567 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15568 || stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15569 || stub_entry
->stub_type
== ppc_stub_long_branch_both
))
15571 bfd_boolean can_plt_call
= FALSE
;
15573 if (stub_entry
->stub_type
== ppc_stub_plt_call
15575 && htab
->params
->plt_localentry0
!= 0
15576 && is_elfv2_localentry0 (&h
->elf
))
15578 /* The function doesn't use or change r2. */
15579 can_plt_call
= TRUE
;
15581 else if (r_type
== R_PPC64_REL24_NOTOC
)
15583 /* NOTOC calls don't need to restore r2. */
15584 can_plt_call
= TRUE
;
15587 /* All of these stubs may modify r2, so there must be a
15588 branch and link followed by a nop. The nop is
15589 replaced by an insn to restore r2. */
15590 else if (rel
->r_offset
+ 8 <= input_section
->size
)
15594 br
= bfd_get_32 (input_bfd
,
15595 contents
+ rel
->r_offset
);
15600 nop
= bfd_get_32 (input_bfd
,
15601 contents
+ rel
->r_offset
+ 4);
15602 if (nop
== LD_R2_0R1
+ STK_TOC (htab
))
15603 can_plt_call
= TRUE
;
15604 else if (nop
== NOP
15605 || nop
== CROR_151515
15606 || nop
== CROR_313131
)
15609 && is_tls_get_addr (&h
->elf
, htab
)
15610 && htab
->params
->tls_get_addr_opt
)
15612 /* Special stub used, leave nop alone. */
15615 bfd_put_32 (input_bfd
,
15616 LD_R2_0R1
+ STK_TOC (htab
),
15617 contents
+ rel
->r_offset
+ 4);
15618 can_plt_call
= TRUE
;
15623 if (!can_plt_call
&& h
!= NULL
)
15625 const char *name
= h
->elf
.root
.root
.string
;
15630 if (strncmp (name
, "__libc_start_main", 17) == 0
15631 && (name
[17] == 0 || name
[17] == '@'))
15633 /* Allow crt1 branch to go via a toc adjusting
15634 stub. Other calls that never return could do
15635 the same, if we could detect such. */
15636 can_plt_call
= TRUE
;
15642 /* g++ as of 20130507 emits self-calls without a
15643 following nop. This is arguably wrong since we
15644 have conflicting information. On the one hand a
15645 global symbol and on the other a local call
15646 sequence, but don't error for this special case.
15647 It isn't possible to cheaply verify we have
15648 exactly such a call. Allow all calls to the same
15650 asection
*code_sec
= sec
;
15652 if (get_opd_info (sec
) != NULL
)
15654 bfd_vma off
= (relocation
+ addend
15655 - sec
->output_section
->vma
15656 - sec
->output_offset
);
15658 opd_entry_value (sec
, off
, &code_sec
, NULL
, FALSE
);
15660 if (code_sec
== input_section
)
15661 can_plt_call
= TRUE
;
15666 if (stub_entry
->stub_type
>= ppc_stub_plt_call
15667 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15668 info
->callbacks
->einfo
15669 /* xgettext:c-format */
15670 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15671 "(plt call stub)\n"),
15672 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15674 info
->callbacks
->einfo
15675 /* xgettext:c-format */
15676 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15677 "(toc save/adjust stub)\n"),
15678 input_bfd
, input_section
, rel
->r_offset
, sym_name
);
15680 bfd_set_error (bfd_error_bad_value
);
15685 && stub_entry
->stub_type
>= ppc_stub_plt_call
15686 && stub_entry
->stub_type
<= ppc_stub_plt_call_both
)
15687 unresolved_reloc
= FALSE
;
15690 if ((stub_entry
== NULL
15691 || stub_entry
->stub_type
== ppc_stub_long_branch
15692 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15693 && get_opd_info (sec
) != NULL
)
15695 /* The branch destination is the value of the opd entry. */
15696 bfd_vma off
= (relocation
+ addend
15697 - sec
->output_section
->vma
15698 - sec
->output_offset
);
15699 bfd_vma dest
= opd_entry_value (sec
, off
, NULL
, NULL
, FALSE
);
15700 if (dest
!= (bfd_vma
) -1)
15704 reloc_dest
= DEST_OPD
;
15708 /* If the branch is out of reach we ought to have a long
15710 from
= (rel
->r_offset
15711 + input_section
->output_offset
15712 + input_section
->output_section
->vma
);
15714 relocation
+= PPC64_LOCAL_ENTRY_OFFSET (fdh
15718 if (stub_entry
!= NULL
15719 && (stub_entry
->stub_type
== ppc_stub_long_branch
15720 || stub_entry
->stub_type
== ppc_stub_plt_branch
)
15721 && (r_type
== R_PPC64_ADDR14_BRTAKEN
15722 || r_type
== R_PPC64_ADDR14_BRNTAKEN
15723 || (relocation
+ addend
- from
+ max_br_offset
15724 < 2 * max_br_offset
)))
15725 /* Don't use the stub if this branch is in range. */
15728 if (stub_entry
!= NULL
15729 && (stub_entry
->stub_type
== ppc_stub_long_branch_notoc
15730 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15731 || stub_entry
->stub_type
== ppc_stub_plt_branch_notoc
15732 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15733 && (r_type
!= R_PPC64_REL24_NOTOC
15734 || ((fdh
? fdh
->elf
.other
: sym
->st_other
)
15735 & STO_PPC64_LOCAL_MASK
) <= 1 << STO_PPC64_LOCAL_BIT
)
15736 && (relocation
+ addend
- from
+ max_br_offset
15737 < 2 * max_br_offset
))
15740 if (stub_entry
!= NULL
15741 && (stub_entry
->stub_type
== ppc_stub_long_branch_r2off
15742 || stub_entry
->stub_type
== ppc_stub_long_branch_both
15743 || stub_entry
->stub_type
== ppc_stub_plt_branch_r2off
15744 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
)
15745 && r_type
== R_PPC64_REL24_NOTOC
15746 && (relocation
+ addend
- from
+ max_br_offset
15747 < 2 * max_br_offset
))
15750 if (stub_entry
!= NULL
)
15752 /* Munge up the value and addend so that we call the stub
15753 rather than the procedure directly. */
15754 asection
*stub_sec
= stub_entry
->group
->stub_sec
;
15756 if (stub_entry
->stub_type
== ppc_stub_save_res
)
15757 relocation
+= (stub_sec
->output_offset
15758 + stub_sec
->output_section
->vma
15759 + stub_sec
->size
- htab
->sfpr
->size
15760 - htab
->sfpr
->output_offset
15761 - htab
->sfpr
->output_section
->vma
);
15763 relocation
= (stub_entry
->stub_offset
15764 + stub_sec
->output_offset
15765 + stub_sec
->output_section
->vma
);
15767 reloc_dest
= DEST_STUB
;
15769 if (((stub_entry
->stub_type
== ppc_stub_plt_call
15770 && ALWAYS_EMIT_R2SAVE
)
15771 || stub_entry
->stub_type
== ppc_stub_plt_call_r2save
15772 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15774 && is_tls_get_addr (&h
->elf
, htab
)
15775 && htab
->params
->tls_get_addr_opt
)
15776 && rel
+ 1 < relend
15777 && rel
[1].r_offset
== rel
->r_offset
+ 4
15778 && ELF64_R_TYPE (rel
[1].r_info
) == R_PPC64_TOCSAVE
)
15780 else if ((stub_entry
->stub_type
== ppc_stub_long_branch_both
15781 || stub_entry
->stub_type
== ppc_stub_plt_branch_both
15782 || stub_entry
->stub_type
== ppc_stub_plt_call_both
)
15783 && r_type
== R_PPC64_REL24_NOTOC
)
15786 if (r_type
== R_PPC64_REL24_NOTOC
15787 && (stub_entry
->stub_type
== ppc_stub_plt_call_notoc
15788 || stub_entry
->stub_type
== ppc_stub_plt_call_both
))
15789 htab
->notoc_plt
= 1;
15796 /* Set 'a' bit. This is 0b00010 in BO field for branch
15797 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15798 for branch on CTR insns (BO == 1a00t or 1a01t). */
15799 if ((insn
& (0x14 << 21)) == (0x04 << 21))
15800 insn
|= 0x02 << 21;
15801 else if ((insn
& (0x14 << 21)) == (0x10 << 21))
15802 insn
|= 0x08 << 21;
15808 /* Invert 'y' bit if not the default. */
15809 if ((bfd_signed_vma
) (relocation
+ addend
- from
) < 0)
15810 insn
^= 0x01 << 21;
15813 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
15816 /* NOP out calls to undefined weak functions.
15817 We can thus call a weak function without first
15818 checking whether the function is defined. */
15820 && h
->elf
.root
.type
== bfd_link_hash_undefweak
15821 && h
->elf
.dynindx
== -1
15822 && (r_type
== R_PPC64_REL24
15823 || r_type
== R_PPC64_REL24_NOTOC
)
15827 bfd_put_32 (input_bfd
, NOP
, contents
+ rel
->r_offset
);
15832 case R_PPC64_GOT16_DS
:
15833 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15835 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15836 if (relocation
+ addend
- from
+ 0x8000 < 0x10000
15837 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15839 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15840 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15842 insn
+= (14u << 26) - (58u << 26);
15843 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15844 r_type
= R_PPC64_TOC16
;
15845 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15850 case R_PPC64_GOT16_LO_DS
:
15851 case R_PPC64_GOT16_HA
:
15852 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15854 from
= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
15855 if (relocation
+ addend
- from
+ 0x80008000ULL
< 0x100000000ULL
15856 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15858 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
15859 if ((insn
& (0x3fu
<< 26 | 0x3)) == 58u << 26 /* ld */)
15861 insn
+= (14u << 26) - (58u << 26);
15862 bfd_put_32 (input_bfd
, insn
, contents
+ (rel
->r_offset
& ~3));
15863 r_type
= R_PPC64_TOC16_LO
;
15864 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15866 else if ((insn
& (0x3fu
<< 26)) == 15u << 26 /* addis */)
15868 r_type
= R_PPC64_TOC16_HA
;
15869 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15874 case R_PPC64_GOT_PCREL34
:
15875 if ((h
? h
->elf
.type
: ELF_ST_TYPE (sym
->st_info
)) == STT_GNU_IFUNC
)
15877 from
= (rel
->r_offset
15878 + input_section
->output_section
->vma
15879 + input_section
->output_offset
);
15880 if (relocation
- from
+ (1ULL << 33) < 1ULL << 34
15881 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15883 offset
= rel
->r_offset
;
15884 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15886 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15887 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15888 == ((1ULL << 58) | (1ULL << 52) | (57ULL << 26) /* pld */))
15890 /* Replace with paddi. */
15891 pinsn
+= (2ULL << 56) + (14ULL << 26) - (57ULL << 26);
15892 r_type
= R_PPC64_PCREL34
;
15893 rel
->r_info
= ELF64_R_INFO (r_symndx
, r_type
);
15894 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ offset
);
15895 bfd_put_32 (input_bfd
, pinsn
, contents
+ offset
+ 4);
15901 case R_PPC64_PCREL34
:
15902 if (SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
15904 offset
= rel
->r_offset
;
15905 pinsn
= bfd_get_32 (input_bfd
, contents
+ offset
);
15907 pinsn
|= bfd_get_32 (input_bfd
, contents
+ offset
+ 4);
15908 if ((pinsn
& ((-1ULL << 50) | (63ULL << 26)))
15909 == ((1ULL << 58) | (2ULL << 56) | (1ULL << 52)
15910 | (14ULL << 26) /* paddi */))
15913 if (rel
+ 1 < relend
15914 && rel
[1].r_offset
== offset
15915 && rel
[1].r_info
== ELF64_R_INFO (0, R_PPC64_PCREL_OPT
))
15917 bfd_vma off2
= rel
[1].r_addend
;
15919 /* zero means next insn. */
15922 if (off2
+ 4 <= input_section
->size
)
15925 bfd_signed_vma addend_off
;
15926 pinsn2
= bfd_get_32 (input_bfd
, contents
+ off2
);
15928 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15930 if (off2
+ 8 > input_section
->size
)
15932 pinsn2
|= bfd_get_32 (input_bfd
,
15933 contents
+ off2
+ 4);
15935 if (xlate_pcrel_opt (&pinsn
, &pinsn2
, &addend_off
))
15937 addend
+= addend_off
;
15938 rel
->r_addend
= addend
;
15939 bfd_put_32 (input_bfd
, pinsn
>> 32,
15940 contents
+ offset
);
15941 bfd_put_32 (input_bfd
, pinsn
,
15942 contents
+ offset
+ 4);
15943 bfd_put_32 (input_bfd
, pinsn2
>> 32,
15945 if ((pinsn2
& (63ULL << 58)) == 1ULL << 58)
15946 bfd_put_32 (input_bfd
, pinsn2
,
15947 contents
+ off2
+ 4);
15957 save_unresolved_reloc
= unresolved_reloc
;
15961 /* xgettext:c-format */
15962 _bfd_error_handler (_("%pB: %s unsupported"),
15963 input_bfd
, ppc64_elf_howto_table
[r_type
]->name
);
15965 bfd_set_error (bfd_error_bad_value
);
15971 case R_PPC64_TLSGD
:
15972 case R_PPC64_TLSLD
:
15973 case R_PPC64_TOCSAVE
:
15974 case R_PPC64_GNU_VTINHERIT
:
15975 case R_PPC64_GNU_VTENTRY
:
15976 case R_PPC64_ENTRY
:
15977 case R_PPC64_PCREL_OPT
:
15980 /* GOT16 relocations. Like an ADDR16 using the symbol's
15981 address in the GOT as relocation value instead of the
15982 symbol's value itself. Also, create a GOT entry for the
15983 symbol and put the symbol value there. */
15984 case R_PPC64_GOT_TLSGD16
:
15985 case R_PPC64_GOT_TLSGD16_LO
:
15986 case R_PPC64_GOT_TLSGD16_HI
:
15987 case R_PPC64_GOT_TLSGD16_HA
:
15988 case R_PPC64_GOT_TLSGD_PCREL34
:
15989 tls_type
= TLS_TLS
| TLS_GD
;
15992 case R_PPC64_GOT_TLSLD16
:
15993 case R_PPC64_GOT_TLSLD16_LO
:
15994 case R_PPC64_GOT_TLSLD16_HI
:
15995 case R_PPC64_GOT_TLSLD16_HA
:
15996 case R_PPC64_GOT_TLSLD_PCREL34
:
15997 tls_type
= TLS_TLS
| TLS_LD
;
16000 case R_PPC64_GOT_TPREL16_DS
:
16001 case R_PPC64_GOT_TPREL16_LO_DS
:
16002 case R_PPC64_GOT_TPREL16_HI
:
16003 case R_PPC64_GOT_TPREL16_HA
:
16004 case R_PPC64_GOT_TPREL_PCREL34
:
16005 tls_type
= TLS_TLS
| TLS_TPREL
;
16008 case R_PPC64_GOT_DTPREL16_DS
:
16009 case R_PPC64_GOT_DTPREL16_LO_DS
:
16010 case R_PPC64_GOT_DTPREL16_HI
:
16011 case R_PPC64_GOT_DTPREL16_HA
:
16012 case R_PPC64_GOT_DTPREL_PCREL34
:
16013 tls_type
= TLS_TLS
| TLS_DTPREL
;
16016 case R_PPC64_GOT16
:
16017 case R_PPC64_GOT16_LO
:
16018 case R_PPC64_GOT16_HI
:
16019 case R_PPC64_GOT16_HA
:
16020 case R_PPC64_GOT16_DS
:
16021 case R_PPC64_GOT16_LO_DS
:
16022 case R_PPC64_GOT_PCREL34
:
16025 /* Relocation is to the entry for this symbol in the global
16030 unsigned long indx
= 0;
16031 struct got_entry
*ent
;
16033 if (tls_type
== (TLS_TLS
| TLS_LD
)
16034 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))
16035 ent
= ppc64_tlsld_got (input_bfd
);
16040 if (!htab
->elf
.dynamic_sections_created
16041 || h
->elf
.dynindx
== -1
16042 || SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16043 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16044 /* This is actually a static link, or it is a
16045 -Bsymbolic link and the symbol is defined
16046 locally, or the symbol was forced to be local
16047 because of a version file. */
16051 indx
= h
->elf
.dynindx
;
16052 unresolved_reloc
= FALSE
;
16054 ent
= h
->elf
.got
.glist
;
16058 if (local_got_ents
== NULL
)
16060 ent
= local_got_ents
[r_symndx
];
16063 for (; ent
!= NULL
; ent
= ent
->next
)
16064 if (ent
->addend
== orig_rel
.r_addend
16065 && ent
->owner
== input_bfd
16066 && ent
->tls_type
== tls_type
)
16072 if (ent
->is_indirect
)
16073 ent
= ent
->got
.ent
;
16074 offp
= &ent
->got
.offset
;
16075 got
= ppc64_elf_tdata (ent
->owner
)->got
;
16079 /* The offset must always be a multiple of 8. We use the
16080 least significant bit to record whether we have already
16081 processed this entry. */
16083 if ((off
& 1) != 0)
16087 /* Generate relocs for the dynamic linker, except in
16088 the case of TLSLD where we'll use one entry per
16096 ? h
->elf
.type
== STT_GNU_IFUNC
16097 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
);
16100 relgot
= htab
->elf
.irelplt
;
16101 if (indx
== 0 || is_static_defined (&h
->elf
))
16102 htab
->elf
.ifunc_resolvers
= TRUE
;
16105 || (bfd_link_pic (info
)
16107 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &h
->elf
))
16109 && bfd_link_executable (info
)
16110 && SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
))))
16111 relgot
= ppc64_elf_tdata (ent
->owner
)->relgot
;
16112 if (relgot
!= NULL
)
16114 outrel
.r_offset
= (got
->output_section
->vma
16115 + got
->output_offset
16117 outrel
.r_addend
= orig_rel
.r_addend
;
16118 if (tls_type
& (TLS_LD
| TLS_GD
))
16120 outrel
.r_addend
= 0;
16121 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPMOD64
);
16122 if (tls_type
== (TLS_TLS
| TLS_GD
))
16124 loc
= relgot
->contents
;
16125 loc
+= (relgot
->reloc_count
++
16126 * sizeof (Elf64_External_Rela
));
16127 bfd_elf64_swap_reloca_out (output_bfd
,
16129 outrel
.r_offset
+= 8;
16130 outrel
.r_addend
= orig_rel
.r_addend
;
16132 = ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16135 else if (tls_type
== (TLS_TLS
| TLS_DTPREL
))
16136 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_DTPREL64
);
16137 else if (tls_type
== (TLS_TLS
| TLS_TPREL
))
16138 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_TPREL64
);
16139 else if (indx
!= 0)
16140 outrel
.r_info
= ELF64_R_INFO (indx
, R_PPC64_GLOB_DAT
);
16144 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16146 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16148 /* Write the .got section contents for the sake
16150 loc
= got
->contents
+ off
;
16151 bfd_put_64 (output_bfd
, outrel
.r_addend
+ relocation
,
16155 if (indx
== 0 && tls_type
!= (TLS_TLS
| TLS_LD
))
16157 outrel
.r_addend
+= relocation
;
16158 if (tls_type
& (TLS_GD
| TLS_DTPREL
| TLS_TPREL
))
16160 if (htab
->elf
.tls_sec
== NULL
)
16161 outrel
.r_addend
= 0;
16163 outrel
.r_addend
-= htab
->elf
.tls_sec
->vma
;
16166 loc
= relgot
->contents
;
16167 loc
+= (relgot
->reloc_count
++
16168 * sizeof (Elf64_External_Rela
));
16169 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16172 /* Init the .got section contents here if we're not
16173 emitting a reloc. */
16176 relocation
+= orig_rel
.r_addend
;
16179 if (htab
->elf
.tls_sec
== NULL
)
16183 if (tls_type
& TLS_LD
)
16186 relocation
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16187 if (tls_type
& TLS_TPREL
)
16188 relocation
+= DTP_OFFSET
- TP_OFFSET
;
16191 if (tls_type
& (TLS_GD
| TLS_LD
))
16193 bfd_put_64 (output_bfd
, relocation
,
16194 got
->contents
+ off
+ 8);
16198 bfd_put_64 (output_bfd
, relocation
,
16199 got
->contents
+ off
);
16203 if (off
>= (bfd_vma
) -2)
16206 relocation
= got
->output_section
->vma
+ got
->output_offset
+ off
;
16208 if (!(r_type
== R_PPC64_GOT_PCREL34
16209 || r_type
== R_PPC64_GOT_TLSGD_PCREL34
16210 || r_type
== R_PPC64_GOT_TLSLD_PCREL34
16211 || r_type
== R_PPC64_GOT_TPREL_PCREL34
16212 || r_type
== R_PPC64_GOT_DTPREL_PCREL34
))
16213 addend
= -(TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
);
16217 case R_PPC64_PLT16_HA
:
16218 case R_PPC64_PLT16_HI
:
16219 case R_PPC64_PLT16_LO
:
16220 case R_PPC64_PLT16_LO_DS
:
16221 case R_PPC64_PLT_PCREL34
:
16222 case R_PPC64_PLT_PCREL34_NOTOC
:
16223 case R_PPC64_PLT32
:
16224 case R_PPC64_PLT64
:
16225 case R_PPC64_PLTSEQ
:
16226 case R_PPC64_PLTSEQ_NOTOC
:
16227 case R_PPC64_PLTCALL
:
16228 case R_PPC64_PLTCALL_NOTOC
:
16229 /* Relocation is to the entry for this symbol in the
16230 procedure linkage table. */
16231 unresolved_reloc
= TRUE
;
16233 struct plt_entry
**plt_list
= NULL
;
16235 plt_list
= &h
->elf
.plt
.plist
;
16236 else if (local_got_ents
!= NULL
)
16238 struct plt_entry
**local_plt
= (struct plt_entry
**)
16239 (local_got_ents
+ symtab_hdr
->sh_info
);
16240 plt_list
= local_plt
+ r_symndx
;
16244 struct plt_entry
*ent
;
16246 for (ent
= *plt_list
; ent
!= NULL
; ent
= ent
->next
)
16247 if (ent
->plt
.offset
!= (bfd_vma
) -1
16248 && ent
->addend
== orig_rel
.r_addend
)
16253 plt
= htab
->elf
.splt
;
16254 if (!htab
->elf
.dynamic_sections_created
16256 || h
->elf
.dynindx
== -1)
16259 ? h
->elf
.type
== STT_GNU_IFUNC
16260 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16261 plt
= htab
->elf
.iplt
;
16263 plt
= htab
->pltlocal
;
16265 relocation
= (plt
->output_section
->vma
16266 + plt
->output_offset
16267 + ent
->plt
.offset
);
16268 if (r_type
== R_PPC64_PLT16_HA
16269 || r_type
== R_PPC64_PLT16_HI
16270 || r_type
== R_PPC64_PLT16_LO
16271 || r_type
== R_PPC64_PLT16_LO_DS
)
16273 got
= (elf_gp (output_bfd
)
16274 + htab
->sec_info
[input_section
->id
].toc_off
);
16278 unresolved_reloc
= FALSE
;
16286 /* Relocation value is TOC base. */
16287 relocation
= TOCstart
;
16288 if (r_symndx
== STN_UNDEF
)
16289 relocation
+= htab
->sec_info
[input_section
->id
].toc_off
;
16290 else if (unresolved_reloc
)
16292 else if (sec
!= NULL
&& sec
->id
< htab
->sec_info_arr_size
)
16293 relocation
+= htab
->sec_info
[sec
->id
].toc_off
;
16295 unresolved_reloc
= TRUE
;
16298 /* TOC16 relocs. We want the offset relative to the TOC base,
16299 which is the address of the start of the TOC plus 0x8000.
16300 The TOC consists of sections .got, .toc, .tocbss, and .plt,
16302 case R_PPC64_TOC16
:
16303 case R_PPC64_TOC16_LO
:
16304 case R_PPC64_TOC16_HI
:
16305 case R_PPC64_TOC16_DS
:
16306 case R_PPC64_TOC16_LO_DS
:
16307 case R_PPC64_TOC16_HA
:
16308 addend
-= TOCstart
+ htab
->sec_info
[input_section
->id
].toc_off
;
16313 /* Relocate against the beginning of the section. */
16314 case R_PPC64_SECTOFF
:
16315 case R_PPC64_SECTOFF_LO
:
16316 case R_PPC64_SECTOFF_HI
:
16317 case R_PPC64_SECTOFF_DS
:
16318 case R_PPC64_SECTOFF_LO_DS
:
16319 case R_PPC64_SECTOFF_HA
:
16321 addend
-= sec
->output_section
->vma
;
16324 case R_PPC64_REL16
:
16325 case R_PPC64_REL16_LO
:
16326 case R_PPC64_REL16_HI
:
16327 case R_PPC64_REL16_HA
:
16328 case R_PPC64_REL16_HIGH
:
16329 case R_PPC64_REL16_HIGHA
:
16330 case R_PPC64_REL16_HIGHER
:
16331 case R_PPC64_REL16_HIGHERA
:
16332 case R_PPC64_REL16_HIGHEST
:
16333 case R_PPC64_REL16_HIGHESTA
:
16334 case R_PPC64_REL16_HIGHER34
:
16335 case R_PPC64_REL16_HIGHERA34
:
16336 case R_PPC64_REL16_HIGHEST34
:
16337 case R_PPC64_REL16_HIGHESTA34
:
16338 case R_PPC64_REL16DX_HA
:
16339 case R_PPC64_REL14
:
16340 case R_PPC64_REL14_BRNTAKEN
:
16341 case R_PPC64_REL14_BRTAKEN
:
16342 case R_PPC64_REL24
:
16343 case R_PPC64_REL24_NOTOC
:
16344 case R_PPC64_PCREL34
:
16345 case R_PPC64_PCREL28
:
16348 case R_PPC64_TPREL16
:
16349 case R_PPC64_TPREL16_LO
:
16350 case R_PPC64_TPREL16_HI
:
16351 case R_PPC64_TPREL16_HA
:
16352 case R_PPC64_TPREL16_DS
:
16353 case R_PPC64_TPREL16_LO_DS
:
16354 case R_PPC64_TPREL16_HIGH
:
16355 case R_PPC64_TPREL16_HIGHA
:
16356 case R_PPC64_TPREL16_HIGHER
:
16357 case R_PPC64_TPREL16_HIGHERA
:
16358 case R_PPC64_TPREL16_HIGHEST
:
16359 case R_PPC64_TPREL16_HIGHESTA
:
16360 case R_PPC64_TPREL34
:
16362 && h
->elf
.root
.type
== bfd_link_hash_undefweak
16363 && h
->elf
.dynindx
== -1)
16365 /* Make this relocation against an undefined weak symbol
16366 resolve to zero. This is really just a tweak, since
16367 code using weak externs ought to check that they are
16368 defined before using them. */
16369 bfd_byte
*p
= contents
+ rel
->r_offset
- d_offset
;
16371 insn
= bfd_get_32 (input_bfd
, p
);
16372 insn
= _bfd_elf_ppc_at_tprel_transform (insn
, 13);
16374 bfd_put_32 (input_bfd
, insn
, p
);
16377 if (htab
->elf
.tls_sec
!= NULL
)
16378 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16379 /* The TPREL16 relocs shouldn't really be used in shared
16380 libs or with non-local symbols as that will result in
16381 DT_TEXTREL being set, but support them anyway. */
16384 case R_PPC64_DTPREL16
:
16385 case R_PPC64_DTPREL16_LO
:
16386 case R_PPC64_DTPREL16_HI
:
16387 case R_PPC64_DTPREL16_HA
:
16388 case R_PPC64_DTPREL16_DS
:
16389 case R_PPC64_DTPREL16_LO_DS
:
16390 case R_PPC64_DTPREL16_HIGH
:
16391 case R_PPC64_DTPREL16_HIGHA
:
16392 case R_PPC64_DTPREL16_HIGHER
:
16393 case R_PPC64_DTPREL16_HIGHERA
:
16394 case R_PPC64_DTPREL16_HIGHEST
:
16395 case R_PPC64_DTPREL16_HIGHESTA
:
16396 case R_PPC64_DTPREL34
:
16397 if (htab
->elf
.tls_sec
!= NULL
)
16398 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16401 case R_PPC64_ADDR64_LOCAL
:
16402 addend
+= PPC64_LOCAL_ENTRY_OFFSET (h
!= NULL
16407 case R_PPC64_DTPMOD64
:
16412 case R_PPC64_TPREL64
:
16413 if (htab
->elf
.tls_sec
!= NULL
)
16414 addend
-= htab
->elf
.tls_sec
->vma
+ TP_OFFSET
;
16417 case R_PPC64_DTPREL64
:
16418 if (htab
->elf
.tls_sec
!= NULL
)
16419 addend
-= htab
->elf
.tls_sec
->vma
+ DTP_OFFSET
;
16420 /* Fall through. */
16422 /* Relocations that may need to be propagated if this is a
16424 case R_PPC64_REL30
:
16425 case R_PPC64_REL32
:
16426 case R_PPC64_REL64
:
16427 case R_PPC64_ADDR14
:
16428 case R_PPC64_ADDR14_BRNTAKEN
:
16429 case R_PPC64_ADDR14_BRTAKEN
:
16430 case R_PPC64_ADDR16
:
16431 case R_PPC64_ADDR16_DS
:
16432 case R_PPC64_ADDR16_HA
:
16433 case R_PPC64_ADDR16_HI
:
16434 case R_PPC64_ADDR16_HIGH
:
16435 case R_PPC64_ADDR16_HIGHA
:
16436 case R_PPC64_ADDR16_HIGHER
:
16437 case R_PPC64_ADDR16_HIGHERA
:
16438 case R_PPC64_ADDR16_HIGHEST
:
16439 case R_PPC64_ADDR16_HIGHESTA
:
16440 case R_PPC64_ADDR16_LO
:
16441 case R_PPC64_ADDR16_LO_DS
:
16442 case R_PPC64_ADDR16_HIGHER34
:
16443 case R_PPC64_ADDR16_HIGHERA34
:
16444 case R_PPC64_ADDR16_HIGHEST34
:
16445 case R_PPC64_ADDR16_HIGHESTA34
:
16446 case R_PPC64_ADDR24
:
16447 case R_PPC64_ADDR32
:
16448 case R_PPC64_ADDR64
:
16449 case R_PPC64_UADDR16
:
16450 case R_PPC64_UADDR32
:
16451 case R_PPC64_UADDR64
:
16453 case R_PPC64_D34_LO
:
16454 case R_PPC64_D34_HI30
:
16455 case R_PPC64_D34_HA30
:
16458 if ((input_section
->flags
& SEC_ALLOC
) == 0)
16461 if (NO_OPD_RELOCS
&& is_opd
)
16464 if (bfd_link_pic (info
)
16466 || h
->elf
.dyn_relocs
!= NULL
)
16467 && ((h
!= NULL
&& pc_dynrelocs (h
))
16468 || must_be_dyn_reloc (info
, r_type
)))
16470 ? h
->elf
.dyn_relocs
!= NULL
16471 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16473 bfd_boolean skip
, relocate
;
16478 /* When generating a dynamic object, these relocations
16479 are copied into the output file to be resolved at run
16485 out_off
= _bfd_elf_section_offset (output_bfd
, info
,
16486 input_section
, rel
->r_offset
);
16487 if (out_off
== (bfd_vma
) -1)
16489 else if (out_off
== (bfd_vma
) -2)
16490 skip
= TRUE
, relocate
= TRUE
;
16491 out_off
+= (input_section
->output_section
->vma
16492 + input_section
->output_offset
);
16493 outrel
.r_offset
= out_off
;
16494 outrel
.r_addend
= rel
->r_addend
;
16496 /* Optimize unaligned reloc use. */
16497 if ((r_type
== R_PPC64_ADDR64
&& (out_off
& 7) != 0)
16498 || (r_type
== R_PPC64_UADDR64
&& (out_off
& 7) == 0))
16499 r_type
^= R_PPC64_ADDR64
^ R_PPC64_UADDR64
;
16500 else if ((r_type
== R_PPC64_ADDR32
&& (out_off
& 3) != 0)
16501 || (r_type
== R_PPC64_UADDR32
&& (out_off
& 3) == 0))
16502 r_type
^= R_PPC64_ADDR32
^ R_PPC64_UADDR32
;
16503 else if ((r_type
== R_PPC64_ADDR16
&& (out_off
& 1) != 0)
16504 || (r_type
== R_PPC64_UADDR16
&& (out_off
& 1) == 0))
16505 r_type
^= R_PPC64_ADDR16
^ R_PPC64_UADDR16
;
16508 memset (&outrel
, 0, sizeof outrel
);
16509 else if (!SYMBOL_REFERENCES_LOCAL (info
, &h
->elf
)
16511 && r_type
!= R_PPC64_TOC
)
16513 indx
= h
->elf
.dynindx
;
16514 BFD_ASSERT (indx
!= -1);
16515 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16519 /* This symbol is local, or marked to become local,
16520 or this is an opd section reloc which must point
16521 at a local function. */
16522 outrel
.r_addend
+= relocation
;
16523 if (r_type
== R_PPC64_ADDR64
|| r_type
== R_PPC64_TOC
)
16525 if (is_opd
&& h
!= NULL
)
16527 /* Lie about opd entries. This case occurs
16528 when building shared libraries and we
16529 reference a function in another shared
16530 lib. The same thing happens for a weak
16531 definition in an application that's
16532 overridden by a strong definition in a
16533 shared lib. (I believe this is a generic
16534 bug in binutils handling of weak syms.)
16535 In these cases we won't use the opd
16536 entry in this lib. */
16537 unresolved_reloc
= FALSE
;
16540 && r_type
== R_PPC64_ADDR64
16542 ? h
->elf
.type
== STT_GNU_IFUNC
16543 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
))
16544 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_IRELATIVE
);
16547 outrel
.r_info
= ELF64_R_INFO (0, R_PPC64_RELATIVE
);
16549 /* We need to relocate .opd contents for ld.so.
16550 Prelink also wants simple and consistent rules
16551 for relocs. This make all RELATIVE relocs have
16552 *r_offset equal to r_addend. */
16559 ? h
->elf
.type
== STT_GNU_IFUNC
16560 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16562 info
->callbacks
->einfo
16563 /* xgettext:c-format */
16564 (_("%H: %s for indirect "
16565 "function `%pT' unsupported\n"),
16566 input_bfd
, input_section
, rel
->r_offset
,
16567 ppc64_elf_howto_table
[r_type
]->name
,
16571 else if (r_symndx
== STN_UNDEF
|| bfd_is_abs_section (sec
))
16573 else if (sec
== NULL
|| sec
->owner
== NULL
)
16575 bfd_set_error (bfd_error_bad_value
);
16580 asection
*osec
= sec
->output_section
;
16582 if ((osec
->flags
& SEC_THREAD_LOCAL
) != 0)
16584 /* TLS symbol values are relative to the
16585 TLS segment. Dynamic relocations for
16586 local TLS symbols therefore can't be
16587 reduced to a relocation against their
16588 section symbol because it holds the
16589 address of the section, not a value
16590 relative to the TLS segment. We could
16591 change the .tdata dynamic section symbol
16592 to be zero value but STN_UNDEF works
16593 and is used elsewhere, eg. for TPREL64
16594 GOT relocs against local TLS symbols. */
16595 osec
= htab
->elf
.tls_sec
;
16600 indx
= elf_section_data (osec
)->dynindx
;
16603 if ((osec
->flags
& SEC_READONLY
) == 0
16604 && htab
->elf
.data_index_section
!= NULL
)
16605 osec
= htab
->elf
.data_index_section
;
16607 osec
= htab
->elf
.text_index_section
;
16608 indx
= elf_section_data (osec
)->dynindx
;
16610 BFD_ASSERT (indx
!= 0);
16613 /* We are turning this relocation into one
16614 against a section symbol, so subtract out
16615 the output section's address but not the
16616 offset of the input section in the output
16618 outrel
.r_addend
-= osec
->vma
;
16621 outrel
.r_info
= ELF64_R_INFO (indx
, r_type
);
16625 sreloc
= elf_section_data (input_section
)->sreloc
;
16627 ? h
->elf
.type
== STT_GNU_IFUNC
16628 : ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
16630 sreloc
= htab
->elf
.irelplt
;
16631 if (indx
== 0 || is_static_defined (&h
->elf
))
16632 htab
->elf
.ifunc_resolvers
= TRUE
;
16634 if (sreloc
== NULL
)
16637 if (sreloc
->reloc_count
* sizeof (Elf64_External_Rela
)
16640 loc
= sreloc
->contents
;
16641 loc
+= sreloc
->reloc_count
++ * sizeof (Elf64_External_Rela
);
16642 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
16644 if (!warned_dynamic
16645 && !ppc64_glibc_dynamic_reloc (ELF64_R_TYPE (outrel
.r_info
)))
16647 info
->callbacks
->einfo
16648 /* xgettext:c-format */
16649 (_("%X%P: %pB: %s against %pT "
16650 "is not supported by glibc as a dynamic relocation\n"),
16652 ppc64_elf_howto_table
[ELF64_R_TYPE (outrel
.r_info
)]->name
,
16654 warned_dynamic
= TRUE
;
16657 /* If this reloc is against an external symbol, it will
16658 be computed at runtime, so there's no need to do
16659 anything now. However, for the sake of prelink ensure
16660 that the section contents are a known value. */
16663 unresolved_reloc
= FALSE
;
16664 /* The value chosen here is quite arbitrary as ld.so
16665 ignores section contents except for the special
16666 case of .opd where the contents might be accessed
16667 before relocation. Choose zero, as that won't
16668 cause reloc overflow. */
16671 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16672 to improve backward compatibility with older
16674 if (r_type
== R_PPC64_ADDR64
)
16675 addend
= outrel
.r_addend
;
16676 /* Adjust pc_relative relocs to have zero in *r_offset. */
16677 else if (ppc64_elf_howto_table
[r_type
]->pc_relative
)
16678 addend
= outrel
.r_offset
;
16684 case R_PPC64_GLOB_DAT
:
16685 case R_PPC64_JMP_SLOT
:
16686 case R_PPC64_JMP_IREL
:
16687 case R_PPC64_RELATIVE
:
16688 /* We shouldn't ever see these dynamic relocs in relocatable
16690 /* Fall through. */
16692 case R_PPC64_PLTGOT16
:
16693 case R_PPC64_PLTGOT16_DS
:
16694 case R_PPC64_PLTGOT16_HA
:
16695 case R_PPC64_PLTGOT16_HI
:
16696 case R_PPC64_PLTGOT16_LO
:
16697 case R_PPC64_PLTGOT16_LO_DS
:
16698 case R_PPC64_PLTREL32
:
16699 case R_PPC64_PLTREL64
:
16700 /* These ones haven't been implemented yet. */
16702 info
->callbacks
->einfo
16703 /* xgettext:c-format */
16704 (_("%P: %pB: %s is not supported for `%pT'\n"),
16706 ppc64_elf_howto_table
[r_type
]->name
, sym_name
);
16708 bfd_set_error (bfd_error_invalid_operation
);
16713 /* Multi-instruction sequences that access the TOC can be
16714 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16715 to nop; addi rb,r2,x; */
16721 case R_PPC64_GOT_TLSLD16_HI
:
16722 case R_PPC64_GOT_TLSGD16_HI
:
16723 case R_PPC64_GOT_TPREL16_HI
:
16724 case R_PPC64_GOT_DTPREL16_HI
:
16725 case R_PPC64_GOT16_HI
:
16726 case R_PPC64_TOC16_HI
:
16727 /* These relocs would only be useful if building up an
16728 offset to later add to r2, perhaps in an indexed
16729 addressing mode instruction. Don't try to optimize.
16730 Unfortunately, the possibility of someone building up an
16731 offset like this or even with the HA relocs, means that
16732 we need to check the high insn when optimizing the low
16736 case R_PPC64_PLTCALL_NOTOC
:
16737 if (!unresolved_reloc
)
16738 htab
->notoc_plt
= 1;
16739 /* Fall through. */
16740 case R_PPC64_PLTCALL
:
16741 if (unresolved_reloc
)
16743 /* No plt entry. Make this into a direct call. */
16744 bfd_byte
*p
= contents
+ rel
->r_offset
;
16745 insn
= bfd_get_32 (input_bfd
, p
);
16747 bfd_put_32 (input_bfd
, B_DOT
| insn
, p
);
16748 if (r_type
== R_PPC64_PLTCALL
)
16749 bfd_put_32 (input_bfd
, NOP
, p
+ 4);
16750 unresolved_reloc
= save_unresolved_reloc
;
16751 r_type
= R_PPC64_REL24
;
16755 case R_PPC64_PLTSEQ_NOTOC
:
16756 case R_PPC64_PLTSEQ
:
16757 if (unresolved_reloc
)
16759 unresolved_reloc
= FALSE
;
16764 case R_PPC64_PLT_PCREL34_NOTOC
:
16765 if (!unresolved_reloc
)
16766 htab
->notoc_plt
= 1;
16767 /* Fall through. */
16768 case R_PPC64_PLT_PCREL34
:
16769 if (unresolved_reloc
)
16771 bfd_byte
*p
= contents
+ rel
->r_offset
;
16772 bfd_put_32 (input_bfd
, PNOP
>> 32, p
);
16773 bfd_put_32 (input_bfd
, PNOP
, p
+ 4);
16774 unresolved_reloc
= FALSE
;
16779 case R_PPC64_PLT16_HA
:
16780 if (unresolved_reloc
)
16782 unresolved_reloc
= FALSE
;
16785 /* Fall through. */
16786 case R_PPC64_GOT_TLSLD16_HA
:
16787 case R_PPC64_GOT_TLSGD16_HA
:
16788 case R_PPC64_GOT_TPREL16_HA
:
16789 case R_PPC64_GOT_DTPREL16_HA
:
16790 case R_PPC64_GOT16_HA
:
16791 case R_PPC64_TOC16_HA
:
16792 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16793 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16797 p
= contents
+ (rel
->r_offset
& ~3);
16798 bfd_put_32 (input_bfd
, NOP
, p
);
16803 case R_PPC64_PLT16_LO
:
16804 case R_PPC64_PLT16_LO_DS
:
16805 if (unresolved_reloc
)
16807 unresolved_reloc
= FALSE
;
16810 /* Fall through. */
16811 case R_PPC64_GOT_TLSLD16_LO
:
16812 case R_PPC64_GOT_TLSGD16_LO
:
16813 case R_PPC64_GOT_TPREL16_LO_DS
:
16814 case R_PPC64_GOT_DTPREL16_LO_DS
:
16815 case R_PPC64_GOT16_LO
:
16816 case R_PPC64_GOT16_LO_DS
:
16817 case R_PPC64_TOC16_LO
:
16818 case R_PPC64_TOC16_LO_DS
:
16819 if (htab
->do_toc_opt
&& relocation
+ addend
+ 0x8000 < 0x10000
16820 && !ppc64_elf_tdata (input_bfd
)->unexpected_toc_insn
)
16822 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16823 insn
= bfd_get_32 (input_bfd
, p
);
16824 if ((insn
& (0x3fu
<< 26)) == 12u << 26 /* addic */)
16826 /* Transform addic to addi when we change reg. */
16827 insn
&= ~((0x3fu
<< 26) | (0x1f << 16));
16828 insn
|= (14u << 26) | (2 << 16);
16832 insn
&= ~(0x1f << 16);
16835 bfd_put_32 (input_bfd
, insn
, p
);
16839 case R_PPC64_TPREL16_HA
:
16840 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16842 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16843 insn
= bfd_get_32 (input_bfd
, p
);
16844 if ((insn
& ((0x3fu
<< 26) | 0x1f << 16))
16845 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16846 /* xgettext:c-format */
16847 info
->callbacks
->minfo
16848 (_("%H: warning: %s unexpected insn %#x.\n"),
16849 input_bfd
, input_section
, rel
->r_offset
,
16850 ppc64_elf_howto_table
[r_type
]->name
, insn
);
16853 bfd_put_32 (input_bfd
, NOP
, p
);
16859 case R_PPC64_TPREL16_LO
:
16860 case R_PPC64_TPREL16_LO_DS
:
16861 if (htab
->do_tls_opt
&& relocation
+ addend
+ 0x8000 < 0x10000)
16863 bfd_byte
*p
= contents
+ (rel
->r_offset
& ~3);
16864 insn
= bfd_get_32 (input_bfd
, p
);
16865 insn
&= ~(0x1f << 16);
16867 bfd_put_32 (input_bfd
, insn
, p
);
16872 /* Do any further special processing. */
16878 case R_PPC64_REL16_HA
:
16879 case R_PPC64_REL16_HIGHA
:
16880 case R_PPC64_REL16_HIGHERA
:
16881 case R_PPC64_REL16_HIGHESTA
:
16882 case R_PPC64_REL16DX_HA
:
16883 case R_PPC64_ADDR16_HA
:
16884 case R_PPC64_ADDR16_HIGHA
:
16885 case R_PPC64_ADDR16_HIGHERA
:
16886 case R_PPC64_ADDR16_HIGHESTA
:
16887 case R_PPC64_TOC16_HA
:
16888 case R_PPC64_SECTOFF_HA
:
16889 case R_PPC64_TPREL16_HA
:
16890 case R_PPC64_TPREL16_HIGHA
:
16891 case R_PPC64_TPREL16_HIGHERA
:
16892 case R_PPC64_TPREL16_HIGHESTA
:
16893 case R_PPC64_DTPREL16_HA
:
16894 case R_PPC64_DTPREL16_HIGHA
:
16895 case R_PPC64_DTPREL16_HIGHERA
:
16896 case R_PPC64_DTPREL16_HIGHESTA
:
16897 /* It's just possible that this symbol is a weak symbol
16898 that's not actually defined anywhere. In that case,
16899 'sec' would be NULL, and we should leave the symbol
16900 alone (it will be set to zero elsewhere in the link). */
16903 /* Fall through. */
16905 case R_PPC64_GOT16_HA
:
16906 case R_PPC64_PLTGOT16_HA
:
16907 case R_PPC64_PLT16_HA
:
16908 case R_PPC64_GOT_TLSGD16_HA
:
16909 case R_PPC64_GOT_TLSLD16_HA
:
16910 case R_PPC64_GOT_TPREL16_HA
:
16911 case R_PPC64_GOT_DTPREL16_HA
:
16912 /* Add 0x10000 if sign bit in 0:15 is set.
16913 Bits 0:15 are not used. */
16917 case R_PPC64_D34_HA30
:
16918 case R_PPC64_ADDR16_HIGHERA34
:
16919 case R_PPC64_ADDR16_HIGHESTA34
:
16920 case R_PPC64_REL16_HIGHERA34
:
16921 case R_PPC64_REL16_HIGHESTA34
:
16923 addend
+= 1ULL << 33;
16926 case R_PPC64_ADDR16_DS
:
16927 case R_PPC64_ADDR16_LO_DS
:
16928 case R_PPC64_GOT16_DS
:
16929 case R_PPC64_GOT16_LO_DS
:
16930 case R_PPC64_PLT16_LO_DS
:
16931 case R_PPC64_SECTOFF_DS
:
16932 case R_PPC64_SECTOFF_LO_DS
:
16933 case R_PPC64_TOC16_DS
:
16934 case R_PPC64_TOC16_LO_DS
:
16935 case R_PPC64_PLTGOT16_DS
:
16936 case R_PPC64_PLTGOT16_LO_DS
:
16937 case R_PPC64_GOT_TPREL16_DS
:
16938 case R_PPC64_GOT_TPREL16_LO_DS
:
16939 case R_PPC64_GOT_DTPREL16_DS
:
16940 case R_PPC64_GOT_DTPREL16_LO_DS
:
16941 case R_PPC64_TPREL16_DS
:
16942 case R_PPC64_TPREL16_LO_DS
:
16943 case R_PPC64_DTPREL16_DS
:
16944 case R_PPC64_DTPREL16_LO_DS
:
16945 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
16947 /* If this reloc is against an lq, lxv, or stxv insn, then
16948 the value must be a multiple of 16. This is somewhat of
16949 a hack, but the "correct" way to do this by defining _DQ
16950 forms of all the _DS relocs bloats all reloc switches in
16951 this file. It doesn't make much sense to use these
16952 relocs in data, so testing the insn should be safe. */
16953 if ((insn
& (0x3fu
<< 26)) == (56u << 26)
16954 || ((insn
& (0x3fu
<< 26)) == (61u << 26) && (insn
& 3) == 1))
16956 relocation
+= addend
;
16957 addend
= insn
& (mask
^ 3);
16958 if ((relocation
& mask
) != 0)
16960 relocation
^= relocation
& mask
;
16961 info
->callbacks
->einfo
16962 /* xgettext:c-format */
16963 (_("%H: error: %s not a multiple of %u\n"),
16964 input_bfd
, input_section
, rel
->r_offset
,
16965 ppc64_elf_howto_table
[r_type
]->name
,
16967 bfd_set_error (bfd_error_bad_value
);
16974 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16975 because such sections are not SEC_ALLOC and thus ld.so will
16976 not process them. */
16977 howto
= ppc64_elf_howto_table
[(int) r_type
];
16978 if (unresolved_reloc
16979 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
16980 && h
->elf
.def_dynamic
)
16981 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
16982 rel
->r_offset
) != (bfd_vma
) -1)
16984 info
->callbacks
->einfo
16985 /* xgettext:c-format */
16986 (_("%H: unresolvable %s against `%pT'\n"),
16987 input_bfd
, input_section
, rel
->r_offset
,
16989 h
->elf
.root
.root
.string
);
16993 /* 16-bit fields in insns mostly have signed values, but a
16994 few insns have 16-bit unsigned values. Really, we should
16995 have different reloc types. */
16996 if (howto
->complain_on_overflow
!= complain_overflow_dont
16997 && howto
->dst_mask
== 0xffff
16998 && (input_section
->flags
& SEC_CODE
) != 0)
17000 enum complain_overflow complain
= complain_overflow_signed
;
17002 insn
= bfd_get_32 (input_bfd
, contents
+ (rel
->r_offset
& ~3));
17003 if ((insn
& (0x3fu
<< 26)) == 10u << 26 /* cmpli */)
17004 complain
= complain_overflow_bitfield
;
17005 else if (howto
->rightshift
== 0
17006 ? ((insn
& (0x3fu
<< 26)) == 28u << 26 /* andi */
17007 || (insn
& (0x3fu
<< 26)) == 24u << 26 /* ori */
17008 || (insn
& (0x3fu
<< 26)) == 26u << 26 /* xori */)
17009 : ((insn
& (0x3fu
<< 26)) == 29u << 26 /* andis */
17010 || (insn
& (0x3fu
<< 26)) == 25u << 26 /* oris */
17011 || (insn
& (0x3fu
<< 26)) == 27u << 26 /* xoris */))
17012 complain
= complain_overflow_unsigned
;
17013 if (howto
->complain_on_overflow
!= complain
)
17015 alt_howto
= *howto
;
17016 alt_howto
.complain_on_overflow
= complain
;
17017 howto
= &alt_howto
;
17023 /* Split field relocs aren't handled by _bfd_final_link_relocate. */
17025 case R_PPC64_D34_LO
:
17026 case R_PPC64_D34_HI30
:
17027 case R_PPC64_D34_HA30
:
17028 case R_PPC64_PCREL34
:
17029 case R_PPC64_GOT_PCREL34
:
17030 case R_PPC64_TPREL34
:
17031 case R_PPC64_DTPREL34
:
17032 case R_PPC64_GOT_TLSGD_PCREL34
:
17033 case R_PPC64_GOT_TLSLD_PCREL34
:
17034 case R_PPC64_GOT_TPREL_PCREL34
:
17035 case R_PPC64_GOT_DTPREL_PCREL34
:
17036 case R_PPC64_PLT_PCREL34
:
17037 case R_PPC64_PLT_PCREL34_NOTOC
:
17039 case R_PPC64_PCREL28
:
17040 if (rel
->r_offset
+ 8 > input_section
->size
)
17041 r
= bfd_reloc_outofrange
;
17044 relocation
+= addend
;
17045 if (howto
->pc_relative
)
17046 relocation
-= (rel
->r_offset
17047 + input_section
->output_offset
17048 + input_section
->output_section
->vma
);
17049 relocation
>>= howto
->rightshift
;
17051 pinsn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17053 pinsn
|= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
+ 4);
17055 pinsn
&= ~howto
->dst_mask
;
17056 pinsn
|= (((relocation
<< 16) | (relocation
& 0xffff))
17057 & howto
->dst_mask
);
17058 bfd_put_32 (input_bfd
, pinsn
>> 32, contents
+ rel
->r_offset
);
17059 bfd_put_32 (input_bfd
, pinsn
, contents
+ rel
->r_offset
+ 4);
17061 if (howto
->complain_on_overflow
== complain_overflow_signed
17062 && (relocation
+ (1ULL << (howto
->bitsize
- 1))
17063 >= 1ULL << howto
->bitsize
))
17064 r
= bfd_reloc_overflow
;
17068 case R_PPC64_REL16DX_HA
:
17069 if (rel
->r_offset
+ 4 > input_section
->size
)
17070 r
= bfd_reloc_outofrange
;
17073 relocation
+= addend
;
17074 relocation
-= (rel
->r_offset
17075 + input_section
->output_offset
17076 + input_section
->output_section
->vma
);
17077 relocation
= (bfd_signed_vma
) relocation
>> 16;
17078 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
17080 insn
|= (relocation
& 0xffc1) | ((relocation
& 0x3e) << 15);
17081 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
17083 if (relocation
+ 0x8000 > 0xffff)
17084 r
= bfd_reloc_overflow
;
17089 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
17090 contents
, rel
->r_offset
,
17091 relocation
, addend
);
17094 if (r
!= bfd_reloc_ok
)
17096 char *more_info
= NULL
;
17097 const char *reloc_name
= howto
->name
;
17099 if (reloc_dest
!= DEST_NORMAL
)
17101 more_info
= bfd_malloc (strlen (reloc_name
) + 8);
17102 if (more_info
!= NULL
)
17104 strcpy (more_info
, reloc_name
);
17105 strcat (more_info
, (reloc_dest
== DEST_OPD
17106 ? " (OPD)" : " (stub)"));
17107 reloc_name
= more_info
;
17111 if (r
== bfd_reloc_overflow
)
17113 /* On code like "if (foo) foo();" don't report overflow
17114 on a branch to zero when foo is undefined. */
17116 && (reloc_dest
== DEST_STUB
17118 && (h
->elf
.root
.type
== bfd_link_hash_undefweak
17119 || h
->elf
.root
.type
== bfd_link_hash_undefined
)
17120 && is_branch_reloc (r_type
))))
17121 info
->callbacks
->reloc_overflow (info
, &h
->elf
.root
,
17122 sym_name
, reloc_name
,
17124 input_bfd
, input_section
,
17129 info
->callbacks
->einfo
17130 /* xgettext:c-format */
17131 (_("%H: %s against `%pT': error %d\n"),
17132 input_bfd
, input_section
, rel
->r_offset
,
17133 reloc_name
, sym_name
, (int) r
);
17145 Elf_Internal_Shdr
*rel_hdr
;
17146 size_t deleted
= rel
- wrel
;
17148 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
->output_section
);
17149 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17150 if (rel_hdr
->sh_size
== 0)
17152 /* It is too late to remove an empty reloc section. Leave
17154 ??? What is wrong with an empty section??? */
17155 rel_hdr
->sh_size
= rel_hdr
->sh_entsize
;
17158 rel_hdr
= _bfd_elf_single_rel_hdr (input_section
);
17159 rel_hdr
->sh_size
-= rel_hdr
->sh_entsize
* deleted
;
17160 input_section
->reloc_count
-= deleted
;
17163 /* If we're emitting relocations, then shortly after this function
17164 returns, reloc offsets and addends for this section will be
17165 adjusted. Worse, reloc symbol indices will be for the output
17166 file rather than the input. Save a copy of the relocs for
17167 opd_entry_value. */
17168 if (is_opd
&& (info
->emitrelocations
|| bfd_link_relocatable (info
)))
17171 amt
= input_section
->reloc_count
* sizeof (Elf_Internal_Rela
);
17172 rel
= bfd_alloc (input_bfd
, amt
);
17173 BFD_ASSERT (ppc64_elf_tdata (input_bfd
)->opd
.relocs
== NULL
);
17174 ppc64_elf_tdata (input_bfd
)->opd
.relocs
= rel
;
17177 memcpy (rel
, relocs
, amt
);
17182 /* Adjust the value of any local symbols in opd sections. */
17185 ppc64_elf_output_symbol_hook (struct bfd_link_info
*info
,
17186 const char *name ATTRIBUTE_UNUSED
,
17187 Elf_Internal_Sym
*elfsym
,
17188 asection
*input_sec
,
17189 struct elf_link_hash_entry
*h
)
17191 struct _opd_sec_data
*opd
;
17198 opd
= get_opd_info (input_sec
);
17199 if (opd
== NULL
|| opd
->adjust
== NULL
)
17202 value
= elfsym
->st_value
- input_sec
->output_offset
;
17203 if (!bfd_link_relocatable (info
))
17204 value
-= input_sec
->output_section
->vma
;
17206 adjust
= opd
->adjust
[OPD_NDX (value
)];
17210 elfsym
->st_value
+= adjust
;
17214 /* Finish up dynamic symbol handling. We set the contents of various
17215 dynamic sections here. */
17218 ppc64_elf_finish_dynamic_symbol (bfd
*output_bfd
,
17219 struct bfd_link_info
*info
,
17220 struct elf_link_hash_entry
*h
,
17221 Elf_Internal_Sym
*sym
)
17223 struct ppc_link_hash_table
*htab
;
17224 struct plt_entry
*ent
;
17226 htab
= ppc_hash_table (info
);
17230 if (!htab
->opd_abi
&& !h
->def_regular
)
17231 for (ent
= h
->plt
.plist
; ent
!= NULL
; ent
= ent
->next
)
17232 if (ent
->plt
.offset
!= (bfd_vma
) -1)
17234 /* Mark the symbol as undefined, rather than as
17235 defined in glink. Leave the value if there were
17236 any relocations where pointer equality matters
17237 (this is a clue for the dynamic linker, to make
17238 function pointer comparisons work between an
17239 application and shared library), otherwise set it
17241 sym
->st_shndx
= SHN_UNDEF
;
17242 if (!h
->pointer_equality_needed
)
17244 else if (!h
->ref_regular_nonweak
)
17246 /* This breaks function pointer comparisons, but
17247 that is better than breaking tests for a NULL
17248 function pointer. */
17255 && (h
->root
.type
== bfd_link_hash_defined
17256 || h
->root
.type
== bfd_link_hash_defweak
)
17257 && (h
->root
.u
.def
.section
== htab
->elf
.sdynbss
17258 || h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
))
17260 /* This symbol needs a copy reloc. Set it up. */
17261 Elf_Internal_Rela rela
;
17265 if (h
->dynindx
== -1)
17268 rela
.r_offset
= defined_sym_val (h
);
17269 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PPC64_COPY
);
17271 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
17272 srel
= htab
->elf
.sreldynrelro
;
17274 srel
= htab
->elf
.srelbss
;
17275 loc
= srel
->contents
;
17276 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
17277 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
17283 /* Used to decide how to sort relocs in an optimal manner for the
17284 dynamic linker, before writing them out. */
17286 static enum elf_reloc_type_class
17287 ppc64_elf_reloc_type_class (const struct bfd_link_info
*info
,
17288 const asection
*rel_sec
,
17289 const Elf_Internal_Rela
*rela
)
17291 enum elf_ppc64_reloc_type r_type
;
17292 struct ppc_link_hash_table
*htab
= ppc_hash_table (info
);
17294 if (rel_sec
== htab
->elf
.irelplt
)
17295 return reloc_class_ifunc
;
17297 r_type
= ELF64_R_TYPE (rela
->r_info
);
17300 case R_PPC64_RELATIVE
:
17301 return reloc_class_relative
;
17302 case R_PPC64_JMP_SLOT
:
17303 return reloc_class_plt
;
17305 return reloc_class_copy
;
17307 return reloc_class_normal
;
17311 /* Finish up the dynamic sections. */
17314 ppc64_elf_finish_dynamic_sections (bfd
*output_bfd
,
17315 struct bfd_link_info
*info
)
17317 struct ppc_link_hash_table
*htab
;
17321 htab
= ppc_hash_table (info
);
17325 dynobj
= htab
->elf
.dynobj
;
17326 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
17328 if (htab
->elf
.dynamic_sections_created
)
17330 Elf64_External_Dyn
*dyncon
, *dynconend
;
17332 if (sdyn
== NULL
|| htab
->elf
.sgot
== NULL
)
17335 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
17336 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
17337 for (; dyncon
< dynconend
; dyncon
++)
17339 Elf_Internal_Dyn dyn
;
17342 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
17349 case DT_PPC64_GLINK
:
17351 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17352 /* We stupidly defined DT_PPC64_GLINK to be the start
17353 of glink rather than the first entry point, which is
17354 what ld.so needs, and now have a bigger stub to
17355 support automatic multiple TOCs. */
17356 dyn
.d_un
.d_ptr
+= GLINK_PLTRESOLVE_SIZE (htab
) - 8 * 4;
17360 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17363 dyn
.d_un
.d_ptr
= s
->vma
;
17367 if ((htab
->do_multi_toc
&& htab
->multi_toc_needed
)
17368 || htab
->notoc_plt
)
17369 dyn
.d_un
.d_val
|= PPC64_OPT_MULTI_TOC
;
17370 if (htab
->has_plt_localentry0
)
17371 dyn
.d_un
.d_val
|= PPC64_OPT_LOCALENTRY
;
17374 case DT_PPC64_OPDSZ
:
17375 s
= bfd_get_section_by_name (output_bfd
, ".opd");
17378 dyn
.d_un
.d_val
= s
->size
;
17382 s
= htab
->elf
.splt
;
17383 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17387 s
= htab
->elf
.srelplt
;
17388 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
17392 dyn
.d_un
.d_val
= htab
->elf
.srelplt
->size
;
17396 if (htab
->elf
.ifunc_resolvers
)
17397 info
->callbacks
->einfo
17398 (_("%P: warning: text relocations and GNU indirect "
17399 "functions may result in a segfault at runtime\n"));
17403 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
17407 if (htab
->elf
.sgot
!= NULL
&& htab
->elf
.sgot
->size
!= 0
17408 && htab
->elf
.sgot
->output_section
!= bfd_abs_section_ptr
)
17410 /* Fill in the first entry in the global offset table.
17411 We use it to hold the link-time TOCbase. */
17412 bfd_put_64 (output_bfd
,
17413 elf_gp (output_bfd
) + TOC_BASE_OFF
,
17414 htab
->elf
.sgot
->contents
);
17416 /* Set .got entry size. */
17417 elf_section_data (htab
->elf
.sgot
->output_section
)->this_hdr
.sh_entsize
17421 if (htab
->elf
.splt
!= NULL
&& htab
->elf
.splt
->size
!= 0
17422 && htab
->elf
.splt
->output_section
!= bfd_abs_section_ptr
)
17424 /* Set .plt entry size. */
17425 elf_section_data (htab
->elf
.splt
->output_section
)->this_hdr
.sh_entsize
17426 = PLT_ENTRY_SIZE (htab
);
17429 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
17430 brlt ourselves if emitrelocations. */
17431 if (htab
->brlt
!= NULL
17432 && htab
->brlt
->reloc_count
!= 0
17433 && !_bfd_elf_link_output_relocs (output_bfd
,
17435 elf_section_data (htab
->brlt
)->rela
.hdr
,
17436 elf_section_data (htab
->brlt
)->relocs
,
17440 if (htab
->glink
!= NULL
17441 && htab
->glink
->reloc_count
!= 0
17442 && !_bfd_elf_link_output_relocs (output_bfd
,
17444 elf_section_data (htab
->glink
)->rela
.hdr
,
17445 elf_section_data (htab
->glink
)->relocs
,
17450 if (htab
->glink_eh_frame
!= NULL
17451 && htab
->glink_eh_frame
->size
!= 0
17452 && htab
->glink_eh_frame
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
17453 && !_bfd_elf_write_section_eh_frame (output_bfd
, info
,
17454 htab
->glink_eh_frame
,
17455 htab
->glink_eh_frame
->contents
))
17458 /* We need to handle writing out multiple GOT sections ourselves,
17459 since we didn't add them to DYNOBJ. We know dynobj is the first
17461 while ((dynobj
= dynobj
->link
.next
) != NULL
)
17465 if (!is_ppc64_elf (dynobj
))
17468 s
= ppc64_elf_tdata (dynobj
)->got
;
17471 && s
->output_section
!= bfd_abs_section_ptr
17472 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17473 s
->contents
, s
->output_offset
,
17476 s
= ppc64_elf_tdata (dynobj
)->relgot
;
17479 && s
->output_section
!= bfd_abs_section_ptr
17480 && !bfd_set_section_contents (output_bfd
, s
->output_section
,
17481 s
->contents
, s
->output_offset
,
17489 #include "elf64-target.h"
17491 /* FreeBSD support */
17493 #undef TARGET_LITTLE_SYM
17494 #undef TARGET_LITTLE_NAME
17496 #undef TARGET_BIG_SYM
17497 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
17498 #undef TARGET_BIG_NAME
17499 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
17502 #define ELF_OSABI ELFOSABI_FREEBSD
17505 #define elf64_bed elf64_powerpc_fbsd_bed
17507 #include "elf64-target.h"