1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2018 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 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
69 #define elf_info_to_howto ppc64_elf_info_to_howto
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_want_dynrelro 1
77 #define elf_backend_can_gc_sections 1
78 #define elf_backend_can_refcount 1
79 #define elf_backend_rela_normal 1
80 #define elf_backend_dtrel_excludes_plt 1
81 #define elf_backend_default_execstack 0
83 #define bfd_elf64_mkobject ppc64_elf_mkobject
84 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
85 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
86 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
87 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
88 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
89 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
90 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
91 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
92 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
94 #define elf_backend_object_p ppc64_elf_object_p
95 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
96 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
97 #define elf_backend_write_core_note ppc64_elf_write_core_note
98 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
99 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
100 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
101 #define elf_backend_check_directives ppc64_elf_before_check_relocs
102 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
103 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
104 #define elf_backend_check_relocs ppc64_elf_check_relocs
105 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
106 #define elf_backend_gc_keep ppc64_elf_gc_keep
107 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
108 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
109 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
110 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
111 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
112 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
113 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
114 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
115 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
116 #define elf_backend_action_discarded ppc64_elf_action_discarded
117 #define elf_backend_relocate_section ppc64_elf_relocate_section
118 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
119 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
120 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
121 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
122 #define elf_backend_special_sections ppc64_elf_special_sections
123 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
124 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
125 #define elf_backend_get_reloc_section bfd_get_section_by_name
127 /* The name of the dynamic interpreter. This is put in the .interp
129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
131 /* The size in bytes of an entry in the procedure linkage table. */
132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
135 /* The initial size of the plt reserved for the dynamic linker. */
136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
138 /* Offsets to some stack save slots. */
140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
141 /* This one is dodgy. ELFv2 does not have a linker word, so use the
142 CR save slot. Used only by optimised __tls_get_addr call stub,
143 relying on __tls_get_addr_opt not saving CR.. */
144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
146 /* TOC base pointers offset from start of TOC. */
147 #define TOC_BASE_OFF 0x8000
148 /* TOC base alignment. */
149 #define TOC_BASE_ALIGN 256
151 /* Offset of tp and dtp pointers from start of TLS block. */
152 #define TP_OFFSET 0x7000
153 #define DTP_OFFSET 0x8000
155 /* .plt call stub instructions. The normal stub is like this, but
156 sometimes the .plt entry crosses a 64k boundary and we need to
157 insert an addi to adjust r11. */
158 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
159 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
160 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
161 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
162 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
163 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
164 #define BCTR 0x4e800420 /* bctr */
166 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
167 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
168 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
169 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
170 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
172 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
173 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
174 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
175 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
176 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
177 #define BNECTR 0x4ca20420 /* bnectr+ */
178 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
180 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
181 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
182 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
184 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
185 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
186 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
188 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
189 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
190 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
191 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
192 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
193 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
194 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
195 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
196 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
197 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
198 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
199 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
201 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
202 #define GLINK_PLTRESOLVE_SIZE(htab) \
203 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
207 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
208 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
210 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
211 /* ld %2,(0b-1b)(%11) */
212 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
213 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
219 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
220 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
221 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
222 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
223 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
226 #define NOP 0x60000000
228 /* Some other nops. */
229 #define CROR_151515 0x4def7b82
230 #define CROR_313131 0x4ffffb82
232 /* .glink entries for the first 32k functions are two instructions. */
233 #define LI_R0_0 0x38000000 /* li %r0,0 */
234 #define B_DOT 0x48000000 /* b . */
236 /* After that, we need two instructions to load the index, followed by
238 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
239 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
241 /* Instructions used by the save and restore reg functions. */
242 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
243 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
244 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
245 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
246 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
247 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
248 #define LI_R12_0 0x39800000 /* li %r12,0 */
249 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
250 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
251 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
252 #define BLR 0x4e800020 /* blr */
254 /* Since .opd is an array of descriptors and each entry will end up
255 with identical R_PPC64_RELATIVE relocs, there is really no need to
256 propagate .opd relocs; The dynamic linker should be taught to
257 relocate .opd without reloc entries. */
258 #ifndef NO_OPD_RELOCS
259 #define NO_OPD_RELOCS 0
263 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
267 abiversion (bfd *abfd)
269 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
273 set_abiversion (bfd *abfd, int ver)
275 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
276 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
279 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
281 /* Relocation HOWTO's. */
282 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
284 static reloc_howto_type ppc64_elf_howto_raw[] =
286 /* This reloc does nothing. */
287 HOWTO (R_PPC64_NONE, /* type */
289 3, /* size (0 = byte, 1 = short, 2 = long) */
291 FALSE, /* pc_relative */
293 complain_overflow_dont, /* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_PPC64_NONE", /* name */
296 FALSE, /* partial_inplace */
299 FALSE), /* pcrel_offset */
301 /* A standard 32 bit relocation. */
302 HOWTO (R_PPC64_ADDR32, /* type */
304 2, /* size (0 = byte, 1 = short, 2 = long) */
306 FALSE, /* pc_relative */
308 complain_overflow_bitfield, /* complain_on_overflow */
309 bfd_elf_generic_reloc, /* special_function */
310 "R_PPC64_ADDR32", /* name */
311 FALSE, /* partial_inplace */
313 0xffffffff, /* dst_mask */
314 FALSE), /* pcrel_offset */
316 /* An absolute 26 bit branch; the lower two bits must be zero.
317 FIXME: we don't check that, we just clear them. */
318 HOWTO (R_PPC64_ADDR24, /* type */
320 2, /* size (0 = byte, 1 = short, 2 = long) */
322 FALSE, /* pc_relative */
324 complain_overflow_bitfield, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_PPC64_ADDR24", /* name */
327 FALSE, /* partial_inplace */
329 0x03fffffc, /* dst_mask */
330 FALSE), /* pcrel_offset */
332 /* A standard 16 bit relocation. */
333 HOWTO (R_PPC64_ADDR16, /* type */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
337 FALSE, /* pc_relative */
339 complain_overflow_bitfield, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_PPC64_ADDR16", /* name */
342 FALSE, /* partial_inplace */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
347 /* A 16 bit relocation without overflow. */
348 HOWTO (R_PPC64_ADDR16_LO, /* type */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
352 FALSE, /* pc_relative */
354 complain_overflow_dont,/* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_PPC64_ADDR16_LO", /* name */
357 FALSE, /* partial_inplace */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
362 /* Bits 16-31 of an address. */
363 HOWTO (R_PPC64_ADDR16_HI, /* type */
365 1, /* size (0 = byte, 1 = short, 2 = long) */
367 FALSE, /* pc_relative */
369 complain_overflow_signed, /* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_PPC64_ADDR16_HI", /* name */
372 FALSE, /* partial_inplace */
374 0xffff, /* dst_mask */
375 FALSE), /* pcrel_offset */
377 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
378 bits, treated as a signed number, is negative. */
379 HOWTO (R_PPC64_ADDR16_HA, /* type */
381 1, /* size (0 = byte, 1 = short, 2 = long) */
383 FALSE, /* pc_relative */
385 complain_overflow_signed, /* complain_on_overflow */
386 ppc64_elf_ha_reloc, /* special_function */
387 "R_PPC64_ADDR16_HA", /* name */
388 FALSE, /* partial_inplace */
390 0xffff, /* dst_mask */
391 FALSE), /* pcrel_offset */
393 /* An absolute 16 bit branch; the lower two bits must be zero.
394 FIXME: we don't check that, we just clear them. */
395 HOWTO (R_PPC64_ADDR14, /* type */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
399 FALSE, /* pc_relative */
401 complain_overflow_signed, /* complain_on_overflow */
402 ppc64_elf_branch_reloc, /* special_function */
403 "R_PPC64_ADDR14", /* name */
404 FALSE, /* partial_inplace */
406 0x0000fffc, /* dst_mask */
407 FALSE), /* pcrel_offset */
409 /* An absolute 16 bit branch, for which bit 10 should be set to
410 indicate that the branch is expected to be taken. The lower two
411 bits must be zero. */
412 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
416 FALSE, /* pc_relative */
418 complain_overflow_signed, /* complain_on_overflow */
419 ppc64_elf_brtaken_reloc, /* special_function */
420 "R_PPC64_ADDR14_BRTAKEN",/* name */
421 FALSE, /* partial_inplace */
423 0x0000fffc, /* dst_mask */
424 FALSE), /* pcrel_offset */
426 /* An absolute 16 bit branch, for which bit 10 should be set to
427 indicate that the branch is not expected to be taken. The lower
428 two bits must be zero. */
429 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
433 FALSE, /* pc_relative */
435 complain_overflow_signed, /* complain_on_overflow */
436 ppc64_elf_brtaken_reloc, /* special_function */
437 "R_PPC64_ADDR14_BRNTAKEN",/* name */
438 FALSE, /* partial_inplace */
440 0x0000fffc, /* dst_mask */
441 FALSE), /* pcrel_offset */
443 /* A relative 26 bit branch; the lower two bits must be zero. */
444 HOWTO (R_PPC64_REL24, /* type */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
448 TRUE, /* pc_relative */
450 complain_overflow_signed, /* complain_on_overflow */
451 ppc64_elf_branch_reloc, /* special_function */
452 "R_PPC64_REL24", /* name */
453 FALSE, /* partial_inplace */
455 0x03fffffc, /* dst_mask */
456 TRUE), /* pcrel_offset */
458 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
459 HOWTO (R_PPC64_REL24_NOTOC, /* type */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
463 TRUE, /* pc_relative */
465 complain_overflow_signed, /* complain_on_overflow */
466 ppc64_elf_branch_reloc, /* special_function */
467 "R_PPC64_REL24_NOTOC", /* name */
468 FALSE, /* partial_inplace */
470 0x03fffffc, /* dst_mask */
471 TRUE), /* pcrel_offset */
473 /* A relative 16 bit branch; the lower two bits must be zero. */
474 HOWTO (R_PPC64_REL14, /* type */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
478 TRUE, /* pc_relative */
480 complain_overflow_signed, /* complain_on_overflow */
481 ppc64_elf_branch_reloc, /* special_function */
482 "R_PPC64_REL14", /* name */
483 FALSE, /* partial_inplace */
485 0x0000fffc, /* dst_mask */
486 TRUE), /* pcrel_offset */
488 /* A relative 16 bit branch. Bit 10 should be set to indicate that
489 the branch is expected to be taken. The lower two bits must be
491 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
493 2, /* size (0 = byte, 1 = short, 2 = long) */
495 TRUE, /* pc_relative */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_brtaken_reloc, /* special_function */
499 "R_PPC64_REL14_BRTAKEN", /* name */
500 FALSE, /* partial_inplace */
502 0x0000fffc, /* dst_mask */
503 TRUE), /* pcrel_offset */
505 /* A relative 16 bit branch. Bit 10 should be set to indicate that
506 the branch is not expected to be taken. The lower two bits must
508 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
510 2, /* size (0 = byte, 1 = short, 2 = long) */
512 TRUE, /* pc_relative */
514 complain_overflow_signed, /* complain_on_overflow */
515 ppc64_elf_brtaken_reloc, /* special_function */
516 "R_PPC64_REL14_BRNTAKEN",/* name */
517 FALSE, /* partial_inplace */
519 0x0000fffc, /* dst_mask */
520 TRUE), /* pcrel_offset */
522 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
524 HOWTO (R_PPC64_GOT16, /* type */
526 1, /* size (0 = byte, 1 = short, 2 = long) */
528 FALSE, /* pc_relative */
530 complain_overflow_signed, /* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GOT16", /* name */
533 FALSE, /* partial_inplace */
535 0xffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
538 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
540 HOWTO (R_PPC64_GOT16_LO, /* type */
542 1, /* size (0 = byte, 1 = short, 2 = long) */
544 FALSE, /* pc_relative */
546 complain_overflow_dont, /* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_GOT16_LO", /* name */
549 FALSE, /* partial_inplace */
551 0xffff, /* dst_mask */
552 FALSE), /* pcrel_offset */
554 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
556 HOWTO (R_PPC64_GOT16_HI, /* type */
558 1, /* size (0 = byte, 1 = short, 2 = long) */
560 FALSE, /* pc_relative */
562 complain_overflow_signed,/* complain_on_overflow */
563 ppc64_elf_unhandled_reloc, /* special_function */
564 "R_PPC64_GOT16_HI", /* name */
565 FALSE, /* partial_inplace */
567 0xffff, /* dst_mask */
568 FALSE), /* pcrel_offset */
570 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
572 HOWTO (R_PPC64_GOT16_HA, /* type */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
576 FALSE, /* pc_relative */
578 complain_overflow_signed,/* complain_on_overflow */
579 ppc64_elf_unhandled_reloc, /* special_function */
580 "R_PPC64_GOT16_HA", /* name */
581 FALSE, /* partial_inplace */
583 0xffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
586 /* This is used only by the dynamic linker. The symbol should exist
587 both in the object being run and in some shared library. The
588 dynamic linker copies the data addressed by the symbol from the
589 shared library into the object, because the object being
590 run has to have the data at some particular address. */
591 HOWTO (R_PPC64_COPY, /* type */
593 0, /* this one is variable size */
595 FALSE, /* pc_relative */
597 complain_overflow_dont, /* complain_on_overflow */
598 ppc64_elf_unhandled_reloc, /* special_function */
599 "R_PPC64_COPY", /* name */
600 FALSE, /* partial_inplace */
603 FALSE), /* pcrel_offset */
605 /* Like R_PPC64_ADDR64, but used when setting global offset table
607 HOWTO (R_PPC64_GLOB_DAT, /* type */
609 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
611 FALSE, /* pc_relative */
613 complain_overflow_dont, /* complain_on_overflow */
614 ppc64_elf_unhandled_reloc, /* special_function */
615 "R_PPC64_GLOB_DAT", /* name */
616 FALSE, /* partial_inplace */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
621 /* Created by the link editor. Marks a procedure linkage table
622 entry for a symbol. */
623 HOWTO (R_PPC64_JMP_SLOT, /* type */
625 0, /* size (0 = byte, 1 = short, 2 = long) */
627 FALSE, /* pc_relative */
629 complain_overflow_dont, /* complain_on_overflow */
630 ppc64_elf_unhandled_reloc, /* special_function */
631 "R_PPC64_JMP_SLOT", /* name */
632 FALSE, /* partial_inplace */
635 FALSE), /* pcrel_offset */
637 /* Used only by the dynamic linker. When the object is run, this
638 doubleword64 is set to the load address of the object, plus the
640 HOWTO (R_PPC64_RELATIVE, /* type */
642 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
644 FALSE, /* pc_relative */
646 complain_overflow_dont, /* complain_on_overflow */
647 bfd_elf_generic_reloc, /* special_function */
648 "R_PPC64_RELATIVE", /* name */
649 FALSE, /* partial_inplace */
651 ONES (64), /* dst_mask */
652 FALSE), /* pcrel_offset */
654 /* Like R_PPC64_ADDR32, but may be unaligned. */
655 HOWTO (R_PPC64_UADDR32, /* type */
657 2, /* size (0 = byte, 1 = short, 2 = long) */
659 FALSE, /* pc_relative */
661 complain_overflow_bitfield, /* complain_on_overflow */
662 bfd_elf_generic_reloc, /* special_function */
663 "R_PPC64_UADDR32", /* name */
664 FALSE, /* partial_inplace */
666 0xffffffff, /* dst_mask */
667 FALSE), /* pcrel_offset */
669 /* Like R_PPC64_ADDR16, but may be unaligned. */
670 HOWTO (R_PPC64_UADDR16, /* type */
672 1, /* size (0 = byte, 1 = short, 2 = long) */
674 FALSE, /* pc_relative */
676 complain_overflow_bitfield, /* complain_on_overflow */
677 bfd_elf_generic_reloc, /* special_function */
678 "R_PPC64_UADDR16", /* name */
679 FALSE, /* partial_inplace */
681 0xffff, /* dst_mask */
682 FALSE), /* pcrel_offset */
684 /* 32-bit PC relative. */
685 HOWTO (R_PPC64_REL32, /* type */
687 2, /* size (0 = byte, 1 = short, 2 = long) */
689 TRUE, /* pc_relative */
691 complain_overflow_signed, /* complain_on_overflow */
692 bfd_elf_generic_reloc, /* special_function */
693 "R_PPC64_REL32", /* name */
694 FALSE, /* partial_inplace */
696 0xffffffff, /* dst_mask */
697 TRUE), /* pcrel_offset */
699 /* 32-bit relocation to the symbol's procedure linkage table. */
700 HOWTO (R_PPC64_PLT32, /* type */
702 2, /* size (0 = byte, 1 = short, 2 = long) */
704 FALSE, /* pc_relative */
706 complain_overflow_bitfield, /* complain_on_overflow */
707 ppc64_elf_unhandled_reloc, /* special_function */
708 "R_PPC64_PLT32", /* name */
709 FALSE, /* partial_inplace */
711 0xffffffff, /* dst_mask */
712 FALSE), /* pcrel_offset */
714 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
715 FIXME: R_PPC64_PLTREL32 not supported. */
716 HOWTO (R_PPC64_PLTREL32, /* type */
718 2, /* size (0 = byte, 1 = short, 2 = long) */
720 TRUE, /* pc_relative */
722 complain_overflow_signed, /* complain_on_overflow */
723 ppc64_elf_unhandled_reloc, /* special_function */
724 "R_PPC64_PLTREL32", /* name */
725 FALSE, /* partial_inplace */
727 0xffffffff, /* dst_mask */
728 TRUE), /* pcrel_offset */
730 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
732 HOWTO (R_PPC64_PLT16_LO, /* type */
734 1, /* size (0 = byte, 1 = short, 2 = long) */
736 FALSE, /* pc_relative */
738 complain_overflow_dont, /* complain_on_overflow */
739 ppc64_elf_unhandled_reloc, /* special_function */
740 "R_PPC64_PLT16_LO", /* name */
741 FALSE, /* partial_inplace */
743 0xffff, /* dst_mask */
744 FALSE), /* pcrel_offset */
746 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
748 HOWTO (R_PPC64_PLT16_HI, /* type */
750 1, /* size (0 = byte, 1 = short, 2 = long) */
752 FALSE, /* pc_relative */
754 complain_overflow_signed, /* complain_on_overflow */
755 ppc64_elf_unhandled_reloc, /* special_function */
756 "R_PPC64_PLT16_HI", /* name */
757 FALSE, /* partial_inplace */
759 0xffff, /* dst_mask */
760 FALSE), /* pcrel_offset */
762 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
764 HOWTO (R_PPC64_PLT16_HA, /* type */
766 1, /* size (0 = byte, 1 = short, 2 = long) */
768 FALSE, /* pc_relative */
770 complain_overflow_signed, /* complain_on_overflow */
771 ppc64_elf_unhandled_reloc, /* special_function */
772 "R_PPC64_PLT16_HA", /* name */
773 FALSE, /* partial_inplace */
775 0xffff, /* dst_mask */
776 FALSE), /* pcrel_offset */
778 /* 16-bit section relative relocation. */
779 HOWTO (R_PPC64_SECTOFF, /* type */
781 1, /* size (0 = byte, 1 = short, 2 = long) */
783 FALSE, /* pc_relative */
785 complain_overflow_signed, /* complain_on_overflow */
786 ppc64_elf_sectoff_reloc, /* special_function */
787 "R_PPC64_SECTOFF", /* name */
788 FALSE, /* partial_inplace */
790 0xffff, /* dst_mask */
791 FALSE), /* pcrel_offset */
793 /* Like R_PPC64_SECTOFF, but no overflow warning. */
794 HOWTO (R_PPC64_SECTOFF_LO, /* type */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
798 FALSE, /* pc_relative */
800 complain_overflow_dont, /* complain_on_overflow */
801 ppc64_elf_sectoff_reloc, /* special_function */
802 "R_PPC64_SECTOFF_LO", /* name */
803 FALSE, /* partial_inplace */
805 0xffff, /* dst_mask */
806 FALSE), /* pcrel_offset */
808 /* 16-bit upper half section relative relocation. */
809 HOWTO (R_PPC64_SECTOFF_HI, /* type */
811 1, /* size (0 = byte, 1 = short, 2 = long) */
813 FALSE, /* pc_relative */
815 complain_overflow_signed, /* complain_on_overflow */
816 ppc64_elf_sectoff_reloc, /* special_function */
817 "R_PPC64_SECTOFF_HI", /* name */
818 FALSE, /* partial_inplace */
820 0xffff, /* dst_mask */
821 FALSE), /* pcrel_offset */
823 /* 16-bit upper half adjusted section relative relocation. */
824 HOWTO (R_PPC64_SECTOFF_HA, /* type */
826 1, /* size (0 = byte, 1 = short, 2 = long) */
828 FALSE, /* pc_relative */
830 complain_overflow_signed, /* complain_on_overflow */
831 ppc64_elf_sectoff_ha_reloc, /* special_function */
832 "R_PPC64_SECTOFF_HA", /* name */
833 FALSE, /* partial_inplace */
835 0xffff, /* dst_mask */
836 FALSE), /* pcrel_offset */
838 /* Like R_PPC64_REL24 without touching the two least significant bits. */
839 HOWTO (R_PPC64_REL30, /* type */
841 2, /* size (0 = byte, 1 = short, 2 = long) */
843 TRUE, /* pc_relative */
845 complain_overflow_dont, /* complain_on_overflow */
846 bfd_elf_generic_reloc, /* special_function */
847 "R_PPC64_REL30", /* name */
848 FALSE, /* partial_inplace */
850 0xfffffffc, /* dst_mask */
851 TRUE), /* pcrel_offset */
853 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
855 /* A standard 64-bit relocation. */
856 HOWTO (R_PPC64_ADDR64, /* type */
858 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
860 FALSE, /* pc_relative */
862 complain_overflow_dont, /* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_PPC64_ADDR64", /* name */
865 FALSE, /* partial_inplace */
867 ONES (64), /* dst_mask */
868 FALSE), /* pcrel_offset */
870 /* The bits 32-47 of an address. */
871 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
873 1, /* size (0 = byte, 1 = short, 2 = long) */
875 FALSE, /* pc_relative */
877 complain_overflow_dont, /* complain_on_overflow */
878 bfd_elf_generic_reloc, /* special_function */
879 "R_PPC64_ADDR16_HIGHER", /* name */
880 FALSE, /* partial_inplace */
882 0xffff, /* dst_mask */
883 FALSE), /* pcrel_offset */
885 /* The bits 32-47 of an address, plus 1 if the contents of the low
886 16 bits, treated as a signed number, is negative. */
887 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
889 1, /* size (0 = byte, 1 = short, 2 = long) */
891 FALSE, /* pc_relative */
893 complain_overflow_dont, /* complain_on_overflow */
894 ppc64_elf_ha_reloc, /* special_function */
895 "R_PPC64_ADDR16_HIGHERA", /* name */
896 FALSE, /* partial_inplace */
898 0xffff, /* dst_mask */
899 FALSE), /* pcrel_offset */
901 /* The bits 48-63 of an address. */
902 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
906 FALSE, /* pc_relative */
908 complain_overflow_dont, /* complain_on_overflow */
909 bfd_elf_generic_reloc, /* special_function */
910 "R_PPC64_ADDR16_HIGHEST", /* name */
911 FALSE, /* partial_inplace */
913 0xffff, /* dst_mask */
914 FALSE), /* pcrel_offset */
916 /* The bits 48-63 of an address, plus 1 if the contents of the low
917 16 bits, treated as a signed number, is negative. */
918 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
920 1, /* size (0 = byte, 1 = short, 2 = long) */
922 FALSE, /* pc_relative */
924 complain_overflow_dont, /* complain_on_overflow */
925 ppc64_elf_ha_reloc, /* special_function */
926 "R_PPC64_ADDR16_HIGHESTA", /* name */
927 FALSE, /* partial_inplace */
929 0xffff, /* dst_mask */
930 FALSE), /* pcrel_offset */
932 /* Like ADDR64, but may be unaligned. */
933 HOWTO (R_PPC64_UADDR64, /* type */
935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
937 FALSE, /* pc_relative */
939 complain_overflow_dont, /* complain_on_overflow */
940 bfd_elf_generic_reloc, /* special_function */
941 "R_PPC64_UADDR64", /* name */
942 FALSE, /* partial_inplace */
944 ONES (64), /* dst_mask */
945 FALSE), /* pcrel_offset */
947 /* 64-bit relative relocation. */
948 HOWTO (R_PPC64_REL64, /* type */
950 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
952 TRUE, /* pc_relative */
954 complain_overflow_dont, /* complain_on_overflow */
955 bfd_elf_generic_reloc, /* special_function */
956 "R_PPC64_REL64", /* name */
957 FALSE, /* partial_inplace */
959 ONES (64), /* dst_mask */
960 TRUE), /* pcrel_offset */
962 /* 64-bit relocation to the symbol's procedure linkage table. */
963 HOWTO (R_PPC64_PLT64, /* type */
965 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
967 FALSE, /* pc_relative */
969 complain_overflow_dont, /* complain_on_overflow */
970 ppc64_elf_unhandled_reloc, /* special_function */
971 "R_PPC64_PLT64", /* name */
972 FALSE, /* partial_inplace */
974 ONES (64), /* dst_mask */
975 FALSE), /* pcrel_offset */
977 /* 64-bit PC relative relocation to the symbol's procedure linkage
979 /* FIXME: R_PPC64_PLTREL64 not supported. */
980 HOWTO (R_PPC64_PLTREL64, /* type */
982 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
984 TRUE, /* pc_relative */
986 complain_overflow_dont, /* complain_on_overflow */
987 ppc64_elf_unhandled_reloc, /* special_function */
988 "R_PPC64_PLTREL64", /* name */
989 FALSE, /* partial_inplace */
991 ONES (64), /* dst_mask */
992 TRUE), /* pcrel_offset */
994 /* 16 bit TOC-relative relocation. */
996 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
997 HOWTO (R_PPC64_TOC16, /* type */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 FALSE, /* pc_relative */
1003 complain_overflow_signed, /* complain_on_overflow */
1004 ppc64_elf_toc_reloc, /* special_function */
1005 "R_PPC64_TOC16", /* name */
1006 FALSE, /* partial_inplace */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1011 /* 16 bit TOC-relative relocation without overflow. */
1013 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
1014 HOWTO (R_PPC64_TOC16_LO, /* type */
1016 1, /* size (0 = byte, 1 = short, 2 = long) */
1018 FALSE, /* pc_relative */
1020 complain_overflow_dont, /* complain_on_overflow */
1021 ppc64_elf_toc_reloc, /* special_function */
1022 "R_PPC64_TOC16_LO", /* name */
1023 FALSE, /* partial_inplace */
1025 0xffff, /* dst_mask */
1026 FALSE), /* pcrel_offset */
1028 /* 16 bit TOC-relative relocation, high 16 bits. */
1030 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1031 HOWTO (R_PPC64_TOC16_HI, /* type */
1032 16, /* rightshift */
1033 1, /* size (0 = byte, 1 = short, 2 = long) */
1035 FALSE, /* pc_relative */
1037 complain_overflow_signed, /* complain_on_overflow */
1038 ppc64_elf_toc_reloc, /* special_function */
1039 "R_PPC64_TOC16_HI", /* name */
1040 FALSE, /* partial_inplace */
1042 0xffff, /* dst_mask */
1043 FALSE), /* pcrel_offset */
1045 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1046 contents of the low 16 bits, treated as a signed number, is
1049 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1050 HOWTO (R_PPC64_TOC16_HA, /* type */
1051 16, /* rightshift */
1052 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 FALSE, /* pc_relative */
1056 complain_overflow_signed, /* complain_on_overflow */
1057 ppc64_elf_toc_ha_reloc, /* special_function */
1058 "R_PPC64_TOC16_HA", /* name */
1059 FALSE, /* partial_inplace */
1061 0xffff, /* dst_mask */
1062 FALSE), /* pcrel_offset */
1064 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1066 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1067 HOWTO (R_PPC64_TOC, /* type */
1069 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1071 FALSE, /* pc_relative */
1073 complain_overflow_dont, /* complain_on_overflow */
1074 ppc64_elf_toc64_reloc, /* special_function */
1075 "R_PPC64_TOC", /* name */
1076 FALSE, /* partial_inplace */
1078 ONES (64), /* dst_mask */
1079 FALSE), /* pcrel_offset */
1081 /* Like R_PPC64_GOT16, but also informs the link editor that the
1082 value to relocate may (!) refer to a PLT entry which the link
1083 editor (a) may replace with the symbol value. If the link editor
1084 is unable to fully resolve the symbol, it may (b) create a PLT
1085 entry and store the address to the new PLT entry in the GOT.
1086 This permits lazy resolution of function symbols at run time.
1087 The link editor may also skip all of this and just (c) emit a
1088 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1089 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1090 HOWTO (R_PPC64_PLTGOT16, /* type */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1094 FALSE, /* pc_relative */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_PLTGOT16", /* name */
1099 FALSE, /* partial_inplace */
1101 0xffff, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1104 /* Like R_PPC64_PLTGOT16, but without overflow. */
1105 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1106 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1108 1, /* size (0 = byte, 1 = short, 2 = long) */
1110 FALSE, /* pc_relative */
1112 complain_overflow_dont, /* complain_on_overflow */
1113 ppc64_elf_unhandled_reloc, /* special_function */
1114 "R_PPC64_PLTGOT16_LO", /* name */
1115 FALSE, /* partial_inplace */
1117 0xffff, /* dst_mask */
1118 FALSE), /* pcrel_offset */
1120 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1121 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1122 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1123 16, /* rightshift */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1126 FALSE, /* pc_relative */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 ppc64_elf_unhandled_reloc, /* special_function */
1130 "R_PPC64_PLTGOT16_HI", /* name */
1131 FALSE, /* partial_inplace */
1133 0xffff, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1136 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1137 1 if the contents of the low 16 bits, treated as a signed number,
1139 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1140 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1141 16, /* rightshift */
1142 1, /* size (0 = byte, 1 = short, 2 = long) */
1144 FALSE, /* pc_relative */
1146 complain_overflow_signed, /* complain_on_overflow */
1147 ppc64_elf_unhandled_reloc, /* special_function */
1148 "R_PPC64_PLTGOT16_HA", /* name */
1149 FALSE, /* partial_inplace */
1151 0xffff, /* dst_mask */
1152 FALSE), /* pcrel_offset */
1154 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1155 HOWTO (R_PPC64_ADDR16_DS, /* type */
1157 1, /* size (0 = byte, 1 = short, 2 = long) */
1159 FALSE, /* pc_relative */
1161 complain_overflow_signed, /* complain_on_overflow */
1162 bfd_elf_generic_reloc, /* special_function */
1163 "R_PPC64_ADDR16_DS", /* name */
1164 FALSE, /* partial_inplace */
1166 0xfffc, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1169 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1170 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1172 1, /* size (0 = byte, 1 = short, 2 = long) */
1174 FALSE, /* pc_relative */
1176 complain_overflow_dont,/* complain_on_overflow */
1177 bfd_elf_generic_reloc, /* special_function */
1178 "R_PPC64_ADDR16_LO_DS",/* name */
1179 FALSE, /* partial_inplace */
1181 0xfffc, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1184 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1185 HOWTO (R_PPC64_GOT16_DS, /* type */
1187 1, /* size (0 = byte, 1 = short, 2 = long) */
1189 FALSE, /* pc_relative */
1191 complain_overflow_signed, /* complain_on_overflow */
1192 ppc64_elf_unhandled_reloc, /* special_function */
1193 "R_PPC64_GOT16_DS", /* name */
1194 FALSE, /* partial_inplace */
1196 0xfffc, /* dst_mask */
1197 FALSE), /* pcrel_offset */
1199 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1200 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1202 1, /* size (0 = byte, 1 = short, 2 = long) */
1204 FALSE, /* pc_relative */
1206 complain_overflow_dont, /* complain_on_overflow */
1207 ppc64_elf_unhandled_reloc, /* special_function */
1208 "R_PPC64_GOT16_LO_DS", /* name */
1209 FALSE, /* partial_inplace */
1211 0xfffc, /* dst_mask */
1212 FALSE), /* pcrel_offset */
1214 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1215 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1217 1, /* size (0 = byte, 1 = short, 2 = long) */
1219 FALSE, /* pc_relative */
1221 complain_overflow_dont, /* complain_on_overflow */
1222 ppc64_elf_unhandled_reloc, /* special_function */
1223 "R_PPC64_PLT16_LO_DS", /* name */
1224 FALSE, /* partial_inplace */
1226 0xfffc, /* dst_mask */
1227 FALSE), /* pcrel_offset */
1229 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1230 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1232 1, /* size (0 = byte, 1 = short, 2 = long) */
1234 FALSE, /* pc_relative */
1236 complain_overflow_signed, /* complain_on_overflow */
1237 ppc64_elf_sectoff_reloc, /* special_function */
1238 "R_PPC64_SECTOFF_DS", /* name */
1239 FALSE, /* partial_inplace */
1241 0xfffc, /* dst_mask */
1242 FALSE), /* pcrel_offset */
1244 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1245 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1247 1, /* size (0 = byte, 1 = short, 2 = long) */
1249 FALSE, /* pc_relative */
1251 complain_overflow_dont, /* complain_on_overflow */
1252 ppc64_elf_sectoff_reloc, /* special_function */
1253 "R_PPC64_SECTOFF_LO_DS",/* name */
1254 FALSE, /* partial_inplace */
1256 0xfffc, /* dst_mask */
1257 FALSE), /* pcrel_offset */
1259 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1260 HOWTO (R_PPC64_TOC16_DS, /* type */
1262 1, /* size (0 = byte, 1 = short, 2 = long) */
1264 FALSE, /* pc_relative */
1266 complain_overflow_signed, /* complain_on_overflow */
1267 ppc64_elf_toc_reloc, /* special_function */
1268 "R_PPC64_TOC16_DS", /* name */
1269 FALSE, /* partial_inplace */
1271 0xfffc, /* dst_mask */
1272 FALSE), /* pcrel_offset */
1274 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1275 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1279 FALSE, /* pc_relative */
1281 complain_overflow_dont, /* complain_on_overflow */
1282 ppc64_elf_toc_reloc, /* special_function */
1283 "R_PPC64_TOC16_LO_DS", /* name */
1284 FALSE, /* partial_inplace */
1286 0xfffc, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1289 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1290 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1291 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1293 1, /* size (0 = byte, 1 = short, 2 = long) */
1295 FALSE, /* pc_relative */
1297 complain_overflow_signed, /* complain_on_overflow */
1298 ppc64_elf_unhandled_reloc, /* special_function */
1299 "R_PPC64_PLTGOT16_DS", /* name */
1300 FALSE, /* partial_inplace */
1302 0xfffc, /* dst_mask */
1303 FALSE), /* pcrel_offset */
1305 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1306 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1307 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1309 1, /* size (0 = byte, 1 = short, 2 = long) */
1311 FALSE, /* pc_relative */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 ppc64_elf_unhandled_reloc, /* special_function */
1315 "R_PPC64_PLTGOT16_LO_DS",/* name */
1316 FALSE, /* partial_inplace */
1318 0xfffc, /* dst_mask */
1319 FALSE), /* pcrel_offset */
1321 /* Marker relocs for TLS. */
1324 2, /* size (0 = byte, 1 = short, 2 = long) */
1326 FALSE, /* pc_relative */
1328 complain_overflow_dont, /* complain_on_overflow */
1329 bfd_elf_generic_reloc, /* special_function */
1330 "R_PPC64_TLS", /* name */
1331 FALSE, /* partial_inplace */
1334 FALSE), /* pcrel_offset */
1336 HOWTO (R_PPC64_TLSGD,
1338 2, /* size (0 = byte, 1 = short, 2 = long) */
1340 FALSE, /* pc_relative */
1342 complain_overflow_dont, /* complain_on_overflow */
1343 bfd_elf_generic_reloc, /* special_function */
1344 "R_PPC64_TLSGD", /* name */
1345 FALSE, /* partial_inplace */
1348 FALSE), /* pcrel_offset */
1350 HOWTO (R_PPC64_TLSLD,
1352 2, /* size (0 = byte, 1 = short, 2 = long) */
1354 FALSE, /* pc_relative */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 bfd_elf_generic_reloc, /* special_function */
1358 "R_PPC64_TLSLD", /* name */
1359 FALSE, /* partial_inplace */
1362 FALSE), /* pcrel_offset */
1364 /* Marker reloc for optimizing r2 save in prologue rather than on
1365 each plt call stub. */
1366 HOWTO (R_PPC64_TOCSAVE,
1368 2, /* size (0 = byte, 1 = short, 2 = long) */
1370 FALSE, /* pc_relative */
1372 complain_overflow_dont, /* complain_on_overflow */
1373 bfd_elf_generic_reloc, /* special_function */
1374 "R_PPC64_TOCSAVE", /* name */
1375 FALSE, /* partial_inplace */
1378 FALSE), /* pcrel_offset */
1380 /* Marker relocs on inline plt call instructions. */
1381 HOWTO (R_PPC64_PLTSEQ,
1383 2, /* size (0 = byte, 1 = short, 2 = long) */
1385 FALSE, /* pc_relative */
1387 complain_overflow_dont, /* complain_on_overflow */
1388 bfd_elf_generic_reloc, /* special_function */
1389 "R_PPC64_PLTSEQ", /* name */
1390 FALSE, /* partial_inplace */
1393 FALSE), /* pcrel_offset */
1395 HOWTO (R_PPC64_PLTCALL,
1397 2, /* size (0 = byte, 1 = short, 2 = long) */
1399 FALSE, /* pc_relative */
1401 complain_overflow_dont, /* complain_on_overflow */
1402 bfd_elf_generic_reloc, /* special_function */
1403 "R_PPC64_PLTCALL", /* name */
1404 FALSE, /* partial_inplace */
1407 FALSE), /* pcrel_offset */
1409 /* Computes the load module index of the load module that contains the
1410 definition of its TLS sym. */
1411 HOWTO (R_PPC64_DTPMOD64,
1413 4, /* size (0 = byte, 1 = short, 2 = long) */
1415 FALSE, /* pc_relative */
1417 complain_overflow_dont, /* complain_on_overflow */
1418 ppc64_elf_unhandled_reloc, /* special_function */
1419 "R_PPC64_DTPMOD64", /* name */
1420 FALSE, /* partial_inplace */
1422 ONES (64), /* dst_mask */
1423 FALSE), /* pcrel_offset */
1425 /* Computes a dtv-relative displacement, the difference between the value
1426 of sym+add and the base address of the thread-local storage block that
1427 contains the definition of sym, minus 0x8000. */
1428 HOWTO (R_PPC64_DTPREL64,
1430 4, /* size (0 = byte, 1 = short, 2 = long) */
1432 FALSE, /* pc_relative */
1434 complain_overflow_dont, /* complain_on_overflow */
1435 ppc64_elf_unhandled_reloc, /* special_function */
1436 "R_PPC64_DTPREL64", /* name */
1437 FALSE, /* partial_inplace */
1439 ONES (64), /* dst_mask */
1440 FALSE), /* pcrel_offset */
1442 /* A 16 bit dtprel reloc. */
1443 HOWTO (R_PPC64_DTPREL16,
1445 1, /* size (0 = byte, 1 = short, 2 = long) */
1447 FALSE, /* pc_relative */
1449 complain_overflow_signed, /* complain_on_overflow */
1450 ppc64_elf_unhandled_reloc, /* special_function */
1451 "R_PPC64_DTPREL16", /* name */
1452 FALSE, /* partial_inplace */
1454 0xffff, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1457 /* Like DTPREL16, but no overflow. */
1458 HOWTO (R_PPC64_DTPREL16_LO,
1460 1, /* size (0 = byte, 1 = short, 2 = long) */
1462 FALSE, /* pc_relative */
1464 complain_overflow_dont, /* complain_on_overflow */
1465 ppc64_elf_unhandled_reloc, /* special_function */
1466 "R_PPC64_DTPREL16_LO", /* name */
1467 FALSE, /* partial_inplace */
1469 0xffff, /* dst_mask */
1470 FALSE), /* pcrel_offset */
1472 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1473 HOWTO (R_PPC64_DTPREL16_HI,
1474 16, /* rightshift */
1475 1, /* size (0 = byte, 1 = short, 2 = long) */
1477 FALSE, /* pc_relative */
1479 complain_overflow_signed, /* complain_on_overflow */
1480 ppc64_elf_unhandled_reloc, /* special_function */
1481 "R_PPC64_DTPREL16_HI", /* name */
1482 FALSE, /* partial_inplace */
1484 0xffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1487 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1488 HOWTO (R_PPC64_DTPREL16_HA,
1489 16, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1492 FALSE, /* pc_relative */
1494 complain_overflow_signed, /* complain_on_overflow */
1495 ppc64_elf_unhandled_reloc, /* special_function */
1496 "R_PPC64_DTPREL16_HA", /* name */
1497 FALSE, /* partial_inplace */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1502 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1503 HOWTO (R_PPC64_DTPREL16_HIGHER,
1504 32, /* rightshift */
1505 1, /* size (0 = byte, 1 = short, 2 = long) */
1507 FALSE, /* pc_relative */
1509 complain_overflow_dont, /* complain_on_overflow */
1510 ppc64_elf_unhandled_reloc, /* special_function */
1511 "R_PPC64_DTPREL16_HIGHER", /* name */
1512 FALSE, /* partial_inplace */
1514 0xffff, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1517 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1518 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1519 32, /* rightshift */
1520 1, /* size (0 = byte, 1 = short, 2 = long) */
1522 FALSE, /* pc_relative */
1524 complain_overflow_dont, /* complain_on_overflow */
1525 ppc64_elf_unhandled_reloc, /* special_function */
1526 "R_PPC64_DTPREL16_HIGHERA", /* name */
1527 FALSE, /* partial_inplace */
1529 0xffff, /* dst_mask */
1530 FALSE), /* pcrel_offset */
1532 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1533 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1534 48, /* rightshift */
1535 1, /* size (0 = byte, 1 = short, 2 = long) */
1537 FALSE, /* pc_relative */
1539 complain_overflow_dont, /* complain_on_overflow */
1540 ppc64_elf_unhandled_reloc, /* special_function */
1541 "R_PPC64_DTPREL16_HIGHEST", /* name */
1542 FALSE, /* partial_inplace */
1544 0xffff, /* dst_mask */
1545 FALSE), /* pcrel_offset */
1547 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1548 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1549 48, /* rightshift */
1550 1, /* size (0 = byte, 1 = short, 2 = long) */
1552 FALSE, /* pc_relative */
1554 complain_overflow_dont, /* complain_on_overflow */
1555 ppc64_elf_unhandled_reloc, /* special_function */
1556 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1557 FALSE, /* partial_inplace */
1559 0xffff, /* dst_mask */
1560 FALSE), /* pcrel_offset */
1562 /* Like DTPREL16, but for insns with a DS field. */
1563 HOWTO (R_PPC64_DTPREL16_DS,
1565 1, /* size (0 = byte, 1 = short, 2 = long) */
1567 FALSE, /* pc_relative */
1569 complain_overflow_signed, /* complain_on_overflow */
1570 ppc64_elf_unhandled_reloc, /* special_function */
1571 "R_PPC64_DTPREL16_DS", /* name */
1572 FALSE, /* partial_inplace */
1574 0xfffc, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1577 /* Like DTPREL16_DS, but no overflow. */
1578 HOWTO (R_PPC64_DTPREL16_LO_DS,
1580 1, /* size (0 = byte, 1 = short, 2 = long) */
1582 FALSE, /* pc_relative */
1584 complain_overflow_dont, /* complain_on_overflow */
1585 ppc64_elf_unhandled_reloc, /* special_function */
1586 "R_PPC64_DTPREL16_LO_DS", /* name */
1587 FALSE, /* partial_inplace */
1589 0xfffc, /* dst_mask */
1590 FALSE), /* pcrel_offset */
1592 /* Computes a tp-relative displacement, the difference between the value of
1593 sym+add and the value of the thread pointer (r13). */
1594 HOWTO (R_PPC64_TPREL64,
1596 4, /* size (0 = byte, 1 = short, 2 = long) */
1598 FALSE, /* pc_relative */
1600 complain_overflow_dont, /* complain_on_overflow */
1601 ppc64_elf_unhandled_reloc, /* special_function */
1602 "R_PPC64_TPREL64", /* name */
1603 FALSE, /* partial_inplace */
1605 ONES (64), /* dst_mask */
1606 FALSE), /* pcrel_offset */
1608 /* A 16 bit tprel reloc. */
1609 HOWTO (R_PPC64_TPREL16,
1611 1, /* size (0 = byte, 1 = short, 2 = long) */
1613 FALSE, /* pc_relative */
1615 complain_overflow_signed, /* complain_on_overflow */
1616 ppc64_elf_unhandled_reloc, /* special_function */
1617 "R_PPC64_TPREL16", /* name */
1618 FALSE, /* partial_inplace */
1620 0xffff, /* dst_mask */
1621 FALSE), /* pcrel_offset */
1623 /* Like TPREL16, but no overflow. */
1624 HOWTO (R_PPC64_TPREL16_LO,
1626 1, /* size (0 = byte, 1 = short, 2 = long) */
1628 FALSE, /* pc_relative */
1630 complain_overflow_dont, /* complain_on_overflow */
1631 ppc64_elf_unhandled_reloc, /* special_function */
1632 "R_PPC64_TPREL16_LO", /* name */
1633 FALSE, /* partial_inplace */
1635 0xffff, /* dst_mask */
1636 FALSE), /* pcrel_offset */
1638 /* Like TPREL16_LO, but next higher group of 16 bits. */
1639 HOWTO (R_PPC64_TPREL16_HI,
1640 16, /* rightshift */
1641 1, /* size (0 = byte, 1 = short, 2 = long) */
1643 FALSE, /* pc_relative */
1645 complain_overflow_signed, /* complain_on_overflow */
1646 ppc64_elf_unhandled_reloc, /* special_function */
1647 "R_PPC64_TPREL16_HI", /* name */
1648 FALSE, /* partial_inplace */
1650 0xffff, /* dst_mask */
1651 FALSE), /* pcrel_offset */
1653 /* Like TPREL16_HI, but adjust for low 16 bits. */
1654 HOWTO (R_PPC64_TPREL16_HA,
1655 16, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 FALSE, /* pc_relative */
1660 complain_overflow_signed, /* complain_on_overflow */
1661 ppc64_elf_unhandled_reloc, /* special_function */
1662 "R_PPC64_TPREL16_HA", /* name */
1663 FALSE, /* partial_inplace */
1665 0xffff, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1668 /* Like TPREL16_HI, but next higher group of 16 bits. */
1669 HOWTO (R_PPC64_TPREL16_HIGHER,
1670 32, /* rightshift */
1671 1, /* size (0 = byte, 1 = short, 2 = long) */
1673 FALSE, /* pc_relative */
1675 complain_overflow_dont, /* complain_on_overflow */
1676 ppc64_elf_unhandled_reloc, /* special_function */
1677 "R_PPC64_TPREL16_HIGHER", /* name */
1678 FALSE, /* partial_inplace */
1680 0xffff, /* dst_mask */
1681 FALSE), /* pcrel_offset */
1683 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1684 HOWTO (R_PPC64_TPREL16_HIGHERA,
1685 32, /* rightshift */
1686 1, /* size (0 = byte, 1 = short, 2 = long) */
1688 FALSE, /* pc_relative */
1690 complain_overflow_dont, /* complain_on_overflow */
1691 ppc64_elf_unhandled_reloc, /* special_function */
1692 "R_PPC64_TPREL16_HIGHERA", /* name */
1693 FALSE, /* partial_inplace */
1695 0xffff, /* dst_mask */
1696 FALSE), /* pcrel_offset */
1698 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1699 HOWTO (R_PPC64_TPREL16_HIGHEST,
1700 48, /* rightshift */
1701 1, /* size (0 = byte, 1 = short, 2 = long) */
1703 FALSE, /* pc_relative */
1705 complain_overflow_dont, /* complain_on_overflow */
1706 ppc64_elf_unhandled_reloc, /* special_function */
1707 "R_PPC64_TPREL16_HIGHEST", /* name */
1708 FALSE, /* partial_inplace */
1710 0xffff, /* dst_mask */
1711 FALSE), /* pcrel_offset */
1713 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1714 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1715 48, /* rightshift */
1716 1, /* size (0 = byte, 1 = short, 2 = long) */
1718 FALSE, /* pc_relative */
1720 complain_overflow_dont, /* complain_on_overflow */
1721 ppc64_elf_unhandled_reloc, /* special_function */
1722 "R_PPC64_TPREL16_HIGHESTA", /* name */
1723 FALSE, /* partial_inplace */
1725 0xffff, /* dst_mask */
1726 FALSE), /* pcrel_offset */
1728 /* Like TPREL16, but for insns with a DS field. */
1729 HOWTO (R_PPC64_TPREL16_DS,
1731 1, /* size (0 = byte, 1 = short, 2 = long) */
1733 FALSE, /* pc_relative */
1735 complain_overflow_signed, /* complain_on_overflow */
1736 ppc64_elf_unhandled_reloc, /* special_function */
1737 "R_PPC64_TPREL16_DS", /* name */
1738 FALSE, /* partial_inplace */
1740 0xfffc, /* dst_mask */
1741 FALSE), /* pcrel_offset */
1743 /* Like TPREL16_DS, but no overflow. */
1744 HOWTO (R_PPC64_TPREL16_LO_DS,
1746 1, /* size (0 = byte, 1 = short, 2 = long) */
1748 FALSE, /* pc_relative */
1750 complain_overflow_dont, /* complain_on_overflow */
1751 ppc64_elf_unhandled_reloc, /* special_function */
1752 "R_PPC64_TPREL16_LO_DS", /* name */
1753 FALSE, /* partial_inplace */
1755 0xfffc, /* dst_mask */
1756 FALSE), /* pcrel_offset */
1758 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1759 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1760 to the first entry relative to the TOC base (r2). */
1761 HOWTO (R_PPC64_GOT_TLSGD16,
1763 1, /* size (0 = byte, 1 = short, 2 = long) */
1765 FALSE, /* pc_relative */
1767 complain_overflow_signed, /* complain_on_overflow */
1768 ppc64_elf_unhandled_reloc, /* special_function */
1769 "R_PPC64_GOT_TLSGD16", /* name */
1770 FALSE, /* partial_inplace */
1772 0xffff, /* dst_mask */
1773 FALSE), /* pcrel_offset */
1775 /* Like GOT_TLSGD16, but no overflow. */
1776 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1778 1, /* size (0 = byte, 1 = short, 2 = long) */
1780 FALSE, /* pc_relative */
1782 complain_overflow_dont, /* complain_on_overflow */
1783 ppc64_elf_unhandled_reloc, /* special_function */
1784 "R_PPC64_GOT_TLSGD16_LO", /* name */
1785 FALSE, /* partial_inplace */
1787 0xffff, /* dst_mask */
1788 FALSE), /* pcrel_offset */
1790 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1791 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1792 16, /* rightshift */
1793 1, /* size (0 = byte, 1 = short, 2 = long) */
1795 FALSE, /* pc_relative */
1797 complain_overflow_signed, /* complain_on_overflow */
1798 ppc64_elf_unhandled_reloc, /* special_function */
1799 "R_PPC64_GOT_TLSGD16_HI", /* name */
1800 FALSE, /* partial_inplace */
1802 0xffff, /* dst_mask */
1803 FALSE), /* pcrel_offset */
1805 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1806 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1807 16, /* rightshift */
1808 1, /* size (0 = byte, 1 = short, 2 = long) */
1810 FALSE, /* pc_relative */
1812 complain_overflow_signed, /* complain_on_overflow */
1813 ppc64_elf_unhandled_reloc, /* special_function */
1814 "R_PPC64_GOT_TLSGD16_HA", /* name */
1815 FALSE, /* partial_inplace */
1817 0xffff, /* dst_mask */
1818 FALSE), /* pcrel_offset */
1820 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1821 with values (sym+add)@dtpmod and zero, and computes the offset to the
1822 first entry relative to the TOC base (r2). */
1823 HOWTO (R_PPC64_GOT_TLSLD16,
1825 1, /* size (0 = byte, 1 = short, 2 = long) */
1827 FALSE, /* pc_relative */
1829 complain_overflow_signed, /* complain_on_overflow */
1830 ppc64_elf_unhandled_reloc, /* special_function */
1831 "R_PPC64_GOT_TLSLD16", /* name */
1832 FALSE, /* partial_inplace */
1834 0xffff, /* dst_mask */
1835 FALSE), /* pcrel_offset */
1837 /* Like GOT_TLSLD16, but no overflow. */
1838 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1840 1, /* size (0 = byte, 1 = short, 2 = long) */
1842 FALSE, /* pc_relative */
1844 complain_overflow_dont, /* complain_on_overflow */
1845 ppc64_elf_unhandled_reloc, /* special_function */
1846 "R_PPC64_GOT_TLSLD16_LO", /* name */
1847 FALSE, /* partial_inplace */
1849 0xffff, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1852 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1853 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1854 16, /* rightshift */
1855 1, /* size (0 = byte, 1 = short, 2 = long) */
1857 FALSE, /* pc_relative */
1859 complain_overflow_signed, /* complain_on_overflow */
1860 ppc64_elf_unhandled_reloc, /* special_function */
1861 "R_PPC64_GOT_TLSLD16_HI", /* name */
1862 FALSE, /* partial_inplace */
1864 0xffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1867 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1868 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1869 16, /* rightshift */
1870 1, /* size (0 = byte, 1 = short, 2 = long) */
1872 FALSE, /* pc_relative */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 ppc64_elf_unhandled_reloc, /* special_function */
1876 "R_PPC64_GOT_TLSLD16_HA", /* name */
1877 FALSE, /* partial_inplace */
1879 0xffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1882 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1883 the offset to the entry relative to the TOC base (r2). */
1884 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1886 1, /* size (0 = byte, 1 = short, 2 = long) */
1888 FALSE, /* pc_relative */
1890 complain_overflow_signed, /* complain_on_overflow */
1891 ppc64_elf_unhandled_reloc, /* special_function */
1892 "R_PPC64_GOT_DTPREL16_DS", /* name */
1893 FALSE, /* partial_inplace */
1895 0xfffc, /* dst_mask */
1896 FALSE), /* pcrel_offset */
1898 /* Like GOT_DTPREL16_DS, but no overflow. */
1899 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1901 1, /* size (0 = byte, 1 = short, 2 = long) */
1903 FALSE, /* pc_relative */
1905 complain_overflow_dont, /* complain_on_overflow */
1906 ppc64_elf_unhandled_reloc, /* special_function */
1907 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1908 FALSE, /* partial_inplace */
1910 0xfffc, /* dst_mask */
1911 FALSE), /* pcrel_offset */
1913 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1914 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1915 16, /* rightshift */
1916 1, /* size (0 = byte, 1 = short, 2 = long) */
1918 FALSE, /* pc_relative */
1920 complain_overflow_signed, /* complain_on_overflow */
1921 ppc64_elf_unhandled_reloc, /* special_function */
1922 "R_PPC64_GOT_DTPREL16_HI", /* name */
1923 FALSE, /* partial_inplace */
1925 0xffff, /* dst_mask */
1926 FALSE), /* pcrel_offset */
1928 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1929 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1930 16, /* rightshift */
1931 1, /* size (0 = byte, 1 = short, 2 = long) */
1933 FALSE, /* pc_relative */
1935 complain_overflow_signed, /* complain_on_overflow */
1936 ppc64_elf_unhandled_reloc, /* special_function */
1937 "R_PPC64_GOT_DTPREL16_HA", /* name */
1938 FALSE, /* partial_inplace */
1940 0xffff, /* dst_mask */
1941 FALSE), /* pcrel_offset */
1943 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1944 offset to the entry relative to the TOC base (r2). */
1945 HOWTO (R_PPC64_GOT_TPREL16_DS,
1947 1, /* size (0 = byte, 1 = short, 2 = long) */
1949 FALSE, /* pc_relative */
1951 complain_overflow_signed, /* complain_on_overflow */
1952 ppc64_elf_unhandled_reloc, /* special_function */
1953 "R_PPC64_GOT_TPREL16_DS", /* name */
1954 FALSE, /* partial_inplace */
1956 0xfffc, /* dst_mask */
1957 FALSE), /* pcrel_offset */
1959 /* Like GOT_TPREL16_DS, but no overflow. */
1960 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1962 1, /* size (0 = byte, 1 = short, 2 = long) */
1964 FALSE, /* pc_relative */
1966 complain_overflow_dont, /* complain_on_overflow */
1967 ppc64_elf_unhandled_reloc, /* special_function */
1968 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1969 FALSE, /* partial_inplace */
1971 0xfffc, /* dst_mask */
1972 FALSE), /* pcrel_offset */
1974 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1975 HOWTO (R_PPC64_GOT_TPREL16_HI,
1976 16, /* rightshift */
1977 1, /* size (0 = byte, 1 = short, 2 = long) */
1979 FALSE, /* pc_relative */
1981 complain_overflow_signed, /* complain_on_overflow */
1982 ppc64_elf_unhandled_reloc, /* special_function */
1983 "R_PPC64_GOT_TPREL16_HI", /* name */
1984 FALSE, /* partial_inplace */
1986 0xffff, /* dst_mask */
1987 FALSE), /* pcrel_offset */
1989 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1990 HOWTO (R_PPC64_GOT_TPREL16_HA,
1991 16, /* rightshift */
1992 1, /* size (0 = byte, 1 = short, 2 = long) */
1994 FALSE, /* pc_relative */
1996 complain_overflow_signed, /* complain_on_overflow */
1997 ppc64_elf_unhandled_reloc, /* special_function */
1998 "R_PPC64_GOT_TPREL16_HA", /* name */
1999 FALSE, /* partial_inplace */
2001 0xffff, /* dst_mask */
2002 FALSE), /* pcrel_offset */
2004 HOWTO (R_PPC64_JMP_IREL, /* type */
2006 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2008 FALSE, /* pc_relative */
2010 complain_overflow_dont, /* complain_on_overflow */
2011 ppc64_elf_unhandled_reloc, /* special_function */
2012 "R_PPC64_JMP_IREL", /* name */
2013 FALSE, /* partial_inplace */
2016 FALSE), /* pcrel_offset */
2018 HOWTO (R_PPC64_IRELATIVE, /* type */
2020 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2022 FALSE, /* pc_relative */
2024 complain_overflow_dont, /* complain_on_overflow */
2025 bfd_elf_generic_reloc, /* special_function */
2026 "R_PPC64_IRELATIVE", /* name */
2027 FALSE, /* partial_inplace */
2029 ONES (64), /* dst_mask */
2030 FALSE), /* pcrel_offset */
2032 /* A 16 bit relative relocation. */
2033 HOWTO (R_PPC64_REL16, /* type */
2035 1, /* size (0 = byte, 1 = short, 2 = long) */
2037 TRUE, /* pc_relative */
2039 complain_overflow_signed, /* complain_on_overflow */
2040 bfd_elf_generic_reloc, /* special_function */
2041 "R_PPC64_REL16", /* name */
2042 FALSE, /* partial_inplace */
2044 0xffff, /* dst_mask */
2045 TRUE), /* pcrel_offset */
2047 /* A 16 bit relative relocation without overflow. */
2048 HOWTO (R_PPC64_REL16_LO, /* type */
2050 1, /* size (0 = byte, 1 = short, 2 = long) */
2052 TRUE, /* pc_relative */
2054 complain_overflow_dont,/* complain_on_overflow */
2055 bfd_elf_generic_reloc, /* special_function */
2056 "R_PPC64_REL16_LO", /* name */
2057 FALSE, /* partial_inplace */
2059 0xffff, /* dst_mask */
2060 TRUE), /* pcrel_offset */
2062 /* The high order 16 bits of a relative address. */
2063 HOWTO (R_PPC64_REL16_HI, /* type */
2064 16, /* rightshift */
2065 1, /* size (0 = byte, 1 = short, 2 = long) */
2067 TRUE, /* pc_relative */
2069 complain_overflow_signed, /* complain_on_overflow */
2070 bfd_elf_generic_reloc, /* special_function */
2071 "R_PPC64_REL16_HI", /* name */
2072 FALSE, /* partial_inplace */
2074 0xffff, /* dst_mask */
2075 TRUE), /* pcrel_offset */
2077 /* The high order 16 bits of a relative address, plus 1 if the contents of
2078 the low 16 bits, treated as a signed number, is negative. */
2079 HOWTO (R_PPC64_REL16_HA, /* type */
2080 16, /* rightshift */
2081 1, /* size (0 = byte, 1 = short, 2 = long) */
2083 TRUE, /* pc_relative */
2085 complain_overflow_signed, /* complain_on_overflow */
2086 ppc64_elf_ha_reloc, /* special_function */
2087 "R_PPC64_REL16_HA", /* name */
2088 FALSE, /* partial_inplace */
2090 0xffff, /* dst_mask */
2091 TRUE), /* pcrel_offset */
2093 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2094 HOWTO (R_PPC64_REL16DX_HA, /* type */
2095 16, /* rightshift */
2096 2, /* size (0 = byte, 1 = short, 2 = long) */
2098 TRUE, /* pc_relative */
2100 complain_overflow_signed, /* complain_on_overflow */
2101 ppc64_elf_ha_reloc, /* special_function */
2102 "R_PPC64_REL16DX_HA", /* name */
2103 FALSE, /* partial_inplace */
2105 0x1fffc1, /* dst_mask */
2106 TRUE), /* pcrel_offset */
2108 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2109 HOWTO (R_PPC64_16DX_HA, /* type */
2110 16, /* rightshift */
2111 2, /* size (0 = byte, 1 = short, 2 = long) */
2113 FALSE, /* pc_relative */
2115 complain_overflow_signed, /* complain_on_overflow */
2116 ppc64_elf_ha_reloc, /* special_function */
2117 "R_PPC64_16DX_HA", /* name */
2118 FALSE, /* partial_inplace */
2120 0x1fffc1, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2123 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2124 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2125 16, /* rightshift */
2126 1, /* size (0 = byte, 1 = short, 2 = long) */
2128 FALSE, /* pc_relative */
2130 complain_overflow_dont, /* complain_on_overflow */
2131 bfd_elf_generic_reloc, /* special_function */
2132 "R_PPC64_ADDR16_HIGH", /* name */
2133 FALSE, /* partial_inplace */
2135 0xffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2138 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2139 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2140 16, /* rightshift */
2141 1, /* size (0 = byte, 1 = short, 2 = long) */
2143 FALSE, /* pc_relative */
2145 complain_overflow_dont, /* complain_on_overflow */
2146 ppc64_elf_ha_reloc, /* special_function */
2147 "R_PPC64_ADDR16_HIGHA", /* name */
2148 FALSE, /* partial_inplace */
2150 0xffff, /* dst_mask */
2151 FALSE), /* pcrel_offset */
2153 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2154 HOWTO (R_PPC64_DTPREL16_HIGH,
2155 16, /* rightshift */
2156 1, /* size (0 = byte, 1 = short, 2 = long) */
2158 FALSE, /* pc_relative */
2160 complain_overflow_dont, /* complain_on_overflow */
2161 ppc64_elf_unhandled_reloc, /* special_function */
2162 "R_PPC64_DTPREL16_HIGH", /* name */
2163 FALSE, /* partial_inplace */
2165 0xffff, /* dst_mask */
2166 FALSE), /* pcrel_offset */
2168 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2169 HOWTO (R_PPC64_DTPREL16_HIGHA,
2170 16, /* rightshift */
2171 1, /* size (0 = byte, 1 = short, 2 = long) */
2173 FALSE, /* pc_relative */
2175 complain_overflow_dont, /* complain_on_overflow */
2176 ppc64_elf_unhandled_reloc, /* special_function */
2177 "R_PPC64_DTPREL16_HIGHA", /* name */
2178 FALSE, /* partial_inplace */
2180 0xffff, /* dst_mask */
2181 FALSE), /* pcrel_offset */
2183 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2184 HOWTO (R_PPC64_TPREL16_HIGH,
2185 16, /* rightshift */
2186 1, /* size (0 = byte, 1 = short, 2 = long) */
2188 FALSE, /* pc_relative */
2190 complain_overflow_dont, /* complain_on_overflow */
2191 ppc64_elf_unhandled_reloc, /* special_function */
2192 "R_PPC64_TPREL16_HIGH", /* name */
2193 FALSE, /* partial_inplace */
2195 0xffff, /* dst_mask */
2196 FALSE), /* pcrel_offset */
2198 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2199 HOWTO (R_PPC64_TPREL16_HIGHA,
2200 16, /* rightshift */
2201 1, /* size (0 = byte, 1 = short, 2 = long) */
2203 FALSE, /* pc_relative */
2205 complain_overflow_dont, /* complain_on_overflow */
2206 ppc64_elf_unhandled_reloc, /* special_function */
2207 "R_PPC64_TPREL16_HIGHA", /* name */
2208 FALSE, /* partial_inplace */
2210 0xffff, /* dst_mask */
2211 FALSE), /* pcrel_offset */
2213 /* Marker reloc on ELFv2 large-model function entry. */
2214 HOWTO (R_PPC64_ENTRY,
2216 2, /* size (0 = byte, 1 = short, 2 = long) */
2218 FALSE, /* pc_relative */
2220 complain_overflow_dont, /* complain_on_overflow */
2221 bfd_elf_generic_reloc, /* special_function */
2222 "R_PPC64_ENTRY", /* name */
2223 FALSE, /* partial_inplace */
2226 FALSE), /* pcrel_offset */
2228 /* Like ADDR64, but use local entry point of function. */
2229 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2231 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2233 FALSE, /* pc_relative */
2235 complain_overflow_dont, /* complain_on_overflow */
2236 bfd_elf_generic_reloc, /* special_function */
2237 "R_PPC64_ADDR64_LOCAL", /* name */
2238 FALSE, /* partial_inplace */
2240 ONES (64), /* dst_mask */
2241 FALSE), /* pcrel_offset */
2243 /* GNU extension to record C++ vtable hierarchy. */
2244 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2246 0, /* size (0 = byte, 1 = short, 2 = long) */
2248 FALSE, /* pc_relative */
2250 complain_overflow_dont, /* complain_on_overflow */
2251 NULL, /* special_function */
2252 "R_PPC64_GNU_VTINHERIT", /* name */
2253 FALSE, /* partial_inplace */
2256 FALSE), /* pcrel_offset */
2258 /* GNU extension to record C++ vtable member usage. */
2259 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2261 0, /* size (0 = byte, 1 = short, 2 = long) */
2263 FALSE, /* pc_relative */
2265 complain_overflow_dont, /* complain_on_overflow */
2266 NULL, /* special_function */
2267 "R_PPC64_GNU_VTENTRY", /* name */
2268 FALSE, /* partial_inplace */
2271 FALSE), /* pcrel_offset */
2275 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2279 ppc_howto_init (void)
2281 unsigned int i, type;
2283 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2285 type = ppc64_elf_howto_raw[i].type;
2286 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2287 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2291 static reloc_howto_type *
2292 ppc64_elf_reloc_type_lookup (bfd *abfd,
2293 bfd_reloc_code_real_type code)
2295 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2297 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2298 /* Initialize howto table if needed. */
2304 /* xgettext:c-format */
2305 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2306 bfd_set_error (bfd_error_bad_value);
2309 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2311 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2313 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2315 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2317 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2319 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2321 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2323 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2325 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2327 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2329 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2331 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2333 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2335 case BFD_RELOC_PPC64_REL24_NOTOC: r = R_PPC64_REL24_NOTOC;
2337 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2339 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2341 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2343 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2345 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2347 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2349 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2351 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2353 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2355 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2357 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2359 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2361 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2363 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2365 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2367 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2369 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2371 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2373 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2375 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2377 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2379 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2381 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2383 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2385 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2387 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2389 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2391 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2393 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2395 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2397 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2399 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2401 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2403 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2405 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2407 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2409 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2411 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2413 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2415 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2417 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2419 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2421 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2423 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2425 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2427 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2429 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2431 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2433 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2435 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2437 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2439 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2441 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2443 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2445 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2447 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2449 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2451 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2453 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2455 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2457 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2459 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2461 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2463 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2465 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2467 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2469 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2471 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2473 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2475 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2477 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2479 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2481 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2483 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2485 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2487 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2489 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2491 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2493 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2495 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2497 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2499 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2501 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2503 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2505 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2507 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2509 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2511 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2513 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2515 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2517 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2519 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2521 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2523 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2525 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2527 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2529 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2531 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2533 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2535 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2537 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2539 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2541 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2543 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2547 return ppc64_elf_howto_table[r];
2550 static reloc_howto_type *
2551 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2556 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2557 if (ppc64_elf_howto_raw[i].name != NULL
2558 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2559 return &ppc64_elf_howto_raw[i];
2565 /* Set the howto pointer for a PowerPC ELF reloc. */
2568 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2569 Elf_Internal_Rela *dst)
2573 /* Initialize howto table if needed. */
2574 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2577 type = ELF64_R_TYPE (dst->r_info);
2578 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2580 /* xgettext:c-format */
2581 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2583 bfd_set_error (bfd_error_bad_value);
2586 cache_ptr->howto = ppc64_elf_howto_table[type];
2587 if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2589 /* xgettext:c-format */
2590 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2592 bfd_set_error (bfd_error_bad_value);
2599 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2601 static bfd_reloc_status_type
2602 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 void *data, asection *input_section,
2604 bfd *output_bfd, char **error_message)
2606 enum elf_ppc64_reloc_type r_type;
2608 bfd_size_type octets;
2611 /* If this is a relocatable link (output_bfd test tells us), just
2612 call the generic function. Any adjustment will be done at final
2614 if (output_bfd != NULL)
2615 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2616 input_section, output_bfd, error_message);
2618 /* Adjust the addend for sign extension of the low 16 bits.
2619 We won't actually be using the low 16 bits, so trashing them
2621 reloc_entry->addend += 0x8000;
2622 r_type = reloc_entry->howto->type;
2623 if (r_type != R_PPC64_REL16DX_HA)
2624 return bfd_reloc_continue;
2627 if (!bfd_is_com_section (symbol->section))
2628 value = symbol->value;
2629 value += (reloc_entry->addend
2630 + symbol->section->output_offset
2631 + symbol->section->output_section->vma);
2632 value -= (reloc_entry->address
2633 + input_section->output_offset
2634 + input_section->output_section->vma);
2635 value = (bfd_signed_vma) value >> 16;
2637 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2638 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2640 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2641 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2642 if (value + 0x8000 > 0xffff)
2643 return bfd_reloc_overflow;
2644 return bfd_reloc_ok;
2647 static bfd_reloc_status_type
2648 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2649 void *data, asection *input_section,
2650 bfd *output_bfd, char **error_message)
2652 if (output_bfd != NULL)
2653 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2654 input_section, output_bfd, error_message);
2656 if (strcmp (symbol->section->name, ".opd") == 0
2657 && (symbol->section->owner->flags & DYNAMIC) == 0)
2659 bfd_vma dest = opd_entry_value (symbol->section,
2660 symbol->value + reloc_entry->addend,
2662 if (dest != (bfd_vma) -1)
2663 reloc_entry->addend = dest - (symbol->value
2664 + symbol->section->output_section->vma
2665 + symbol->section->output_offset);
2669 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2671 if (symbol->section->owner != abfd
2672 && symbol->section->owner != NULL
2673 && abiversion (symbol->section->owner) >= 2)
2677 for (i = 0; i < symbol->section->owner->symcount; ++i)
2679 asymbol *symdef = symbol->section->owner->outsymbols[i];
2681 if (strcmp (symdef->name, symbol->name) == 0)
2683 elfsym = (elf_symbol_type *) symdef;
2689 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2691 return bfd_reloc_continue;
2694 static bfd_reloc_status_type
2695 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696 void *data, asection *input_section,
2697 bfd *output_bfd, char **error_message)
2700 enum elf_ppc64_reloc_type r_type;
2701 bfd_size_type octets;
2702 /* Assume 'at' branch hints. */
2703 bfd_boolean is_isa_v2 = TRUE;
2705 /* If this is a relocatable link (output_bfd test tells us), just
2706 call the generic function. Any adjustment will be done at final
2708 if (output_bfd != NULL)
2709 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2710 input_section, output_bfd, error_message);
2712 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2713 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2714 insn &= ~(0x01 << 21);
2715 r_type = reloc_entry->howto->type;
2716 if (r_type == R_PPC64_ADDR14_BRTAKEN
2717 || r_type == R_PPC64_REL14_BRTAKEN)
2718 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2722 /* Set 'a' bit. This is 0b00010 in BO field for branch
2723 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2724 for branch on CTR insns (BO == 1a00t or 1a01t). */
2725 if ((insn & (0x14 << 21)) == (0x04 << 21))
2727 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2737 if (!bfd_is_com_section (symbol->section))
2738 target = symbol->value;
2739 target += symbol->section->output_section->vma;
2740 target += symbol->section->output_offset;
2741 target += reloc_entry->addend;
2743 from = (reloc_entry->address
2744 + input_section->output_offset
2745 + input_section->output_section->vma);
2747 /* Invert 'y' bit if not the default. */
2748 if ((bfd_signed_vma) (target - from) < 0)
2751 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2753 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2754 input_section, output_bfd, error_message);
2757 static bfd_reloc_status_type
2758 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2759 void *data, asection *input_section,
2760 bfd *output_bfd, char **error_message)
2762 /* If this is a relocatable link (output_bfd test tells us), just
2763 call the generic function. Any adjustment will be done at final
2765 if (output_bfd != NULL)
2766 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2767 input_section, output_bfd, error_message);
2769 /* Subtract the symbol section base address. */
2770 reloc_entry->addend -= symbol->section->output_section->vma;
2771 return bfd_reloc_continue;
2774 static bfd_reloc_status_type
2775 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2776 void *data, asection *input_section,
2777 bfd *output_bfd, char **error_message)
2779 /* If this is a relocatable link (output_bfd test tells us), just
2780 call the generic function. Any adjustment will be done at final
2782 if (output_bfd != NULL)
2783 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2784 input_section, output_bfd, error_message);
2786 /* Subtract the symbol section base address. */
2787 reloc_entry->addend -= symbol->section->output_section->vma;
2789 /* Adjust the addend for sign extension of the low 16 bits. */
2790 reloc_entry->addend += 0x8000;
2791 return bfd_reloc_continue;
2794 static bfd_reloc_status_type
2795 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2796 void *data, asection *input_section,
2797 bfd *output_bfd, char **error_message)
2801 /* If this is a relocatable link (output_bfd test tells us), just
2802 call the generic function. Any adjustment will be done at final
2804 if (output_bfd != NULL)
2805 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2806 input_section, output_bfd, error_message);
2808 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2810 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2812 /* Subtract the TOC base address. */
2813 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2814 return bfd_reloc_continue;
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819 void *data, asection *input_section,
2820 bfd *output_bfd, char **error_message)
2824 /* If this is a relocatable link (output_bfd test tells us), just
2825 call the generic function. Any adjustment will be done at final
2827 if (output_bfd != NULL)
2828 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2829 input_section, output_bfd, error_message);
2831 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2833 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2835 /* Subtract the TOC base address. */
2836 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2838 /* Adjust the addend for sign extension of the low 16 bits. */
2839 reloc_entry->addend += 0x8000;
2840 return bfd_reloc_continue;
2843 static bfd_reloc_status_type
2844 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2845 void *data, asection *input_section,
2846 bfd *output_bfd, char **error_message)
2849 bfd_size_type octets;
2851 /* If this is a relocatable link (output_bfd test tells us), just
2852 call the generic function. Any adjustment will be done at final
2854 if (output_bfd != NULL)
2855 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2856 input_section, output_bfd, error_message);
2858 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2860 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2862 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2863 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2864 return bfd_reloc_ok;
2867 static bfd_reloc_status_type
2868 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2869 void *data, asection *input_section,
2870 bfd *output_bfd, char **error_message)
2872 /* If this is a relocatable link (output_bfd test tells us), just
2873 call the generic function. Any adjustment will be done at final
2875 if (output_bfd != NULL)
2876 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2877 input_section, output_bfd, error_message);
2879 if (error_message != NULL)
2881 static char buf[60];
2882 sprintf (buf, "generic linker can't handle %s",
2883 reloc_entry->howto->name);
2884 *error_message = buf;
2886 return bfd_reloc_dangerous;
2889 /* Track GOT entries needed for a given symbol. We might need more
2890 than one got entry per symbol. */
2893 struct got_entry *next;
2895 /* The symbol addend that we'll be placing in the GOT. */
2898 /* Unlike other ELF targets, we use separate GOT entries for the same
2899 symbol referenced from different input files. This is to support
2900 automatic multiple TOC/GOT sections, where the TOC base can vary
2901 from one input file to another. After partitioning into TOC groups
2902 we merge entries within the group.
2904 Point to the BFD owning this GOT entry. */
2907 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2908 TLS_TPREL or TLS_DTPREL for tls entries. */
2909 unsigned char tls_type;
2911 /* Non-zero if got.ent points to real entry. */
2912 unsigned char is_indirect;
2914 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2917 bfd_signed_vma refcount;
2919 struct got_entry *ent;
2923 /* The same for PLT. */
2926 struct plt_entry *next;
2932 bfd_signed_vma refcount;
2937 struct ppc64_elf_obj_tdata
2939 struct elf_obj_tdata elf;
2941 /* Shortcuts to dynamic linker sections. */
2945 /* Used during garbage collection. We attach global symbols defined
2946 on removed .opd entries to this section so that the sym is removed. */
2947 asection *deleted_section;
2949 /* TLS local dynamic got entry handling. Support for multiple GOT
2950 sections means we potentially need one of these for each input bfd. */
2951 struct got_entry tlsld_got;
2954 /* A copy of relocs before they are modified for --emit-relocs. */
2955 Elf_Internal_Rela *relocs;
2957 /* Section contents. */
2961 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2962 the reloc to be in the range -32768 to 32767. */
2963 unsigned int has_small_toc_reloc : 1;
2965 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2966 instruction not one we handle. */
2967 unsigned int unexpected_toc_insn : 1;
2970 #define ppc64_elf_tdata(bfd) \
2971 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2973 #define ppc64_tlsld_got(bfd) \
2974 (&ppc64_elf_tdata (bfd)->tlsld_got)
2976 #define is_ppc64_elf(bfd) \
2977 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2978 && elf_object_id (bfd) == PPC64_ELF_DATA)
2980 /* Override the generic function because we store some extras. */
2983 ppc64_elf_mkobject (bfd *abfd)
2985 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2989 /* Fix bad default arch selected for a 64 bit input bfd when the
2990 default is 32 bit. Also select arch based on apuinfo. */
2993 ppc64_elf_object_p (bfd *abfd)
2995 if (!abfd->arch_info->the_default)
2998 if (abfd->arch_info->bits_per_word == 32)
3000 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
3002 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
3004 /* Relies on arch after 32 bit default being 64 bit default. */
3005 abfd->arch_info = abfd->arch_info->next;
3006 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
3009 return _bfd_elf_ppc_set_arch (abfd);
3012 /* Support for core dump NOTE sections. */
3015 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3017 size_t offset, size;
3019 if (note->descsz != 504)
3023 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3026 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3032 /* Make a ".reg/999" section. */
3033 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3034 size, note->descpos + offset);
3038 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3040 if (note->descsz != 136)
3043 elf_tdata (abfd)->core->pid
3044 = bfd_get_32 (abfd, note->descdata + 24);
3045 elf_tdata (abfd)->core->program
3046 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3047 elf_tdata (abfd)->core->command
3048 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3054 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3064 char data[136] ATTRIBUTE_NONSTRING;
3067 va_start (ap, note_type);
3068 memset (data, 0, sizeof (data));
3069 strncpy (data + 40, va_arg (ap, const char *), 16);
3070 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3072 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3073 -Wstringop-truncation:
3074 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3076 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3078 strncpy (data + 56, va_arg (ap, const char *), 80);
3079 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3083 return elfcore_write_note (abfd, buf, bufsiz,
3084 "CORE", note_type, data, sizeof (data));
3095 va_start (ap, note_type);
3096 memset (data, 0, 112);
3097 pid = va_arg (ap, long);
3098 bfd_put_32 (abfd, pid, data + 32);
3099 cursig = va_arg (ap, int);
3100 bfd_put_16 (abfd, cursig, data + 12);
3101 greg = va_arg (ap, const void *);
3102 memcpy (data + 112, greg, 384);
3103 memset (data + 496, 0, 8);
3105 return elfcore_write_note (abfd, buf, bufsiz,
3106 "CORE", note_type, data, sizeof (data));
3111 /* Add extra PPC sections. */
3113 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3115 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3116 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3117 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3118 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3119 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3120 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3121 { NULL, 0, 0, 0, 0 }
3124 enum _ppc64_sec_type {
3130 struct _ppc64_elf_section_data
3132 struct bfd_elf_section_data elf;
3136 /* An array with one entry for each opd function descriptor,
3137 and some spares since opd entries may be either 16 or 24 bytes. */
3138 #define OPD_NDX(OFF) ((OFF) >> 4)
3139 struct _opd_sec_data
3141 /* Points to the function code section for local opd entries. */
3142 asection **func_sec;
3144 /* After editing .opd, adjust references to opd local syms. */
3148 /* An array for toc sections, indexed by offset/8. */
3149 struct _toc_sec_data
3151 /* Specifies the relocation symbol index used at a given toc offset. */
3154 /* And the relocation addend. */
3159 enum _ppc64_sec_type sec_type:2;
3161 /* Flag set when small branches are detected. Used to
3162 select suitable defaults for the stub group size. */
3163 unsigned int has_14bit_branch:1;
3165 /* Flag set when PLTCALL relocs are detected. */
3166 unsigned int has_pltcall:1;
3169 #define ppc64_elf_section_data(sec) \
3170 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3173 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3175 if (!sec->used_by_bfd)
3177 struct _ppc64_elf_section_data *sdata;
3178 bfd_size_type amt = sizeof (*sdata);
3180 sdata = bfd_zalloc (abfd, amt);
3183 sec->used_by_bfd = sdata;
3186 return _bfd_elf_new_section_hook (abfd, sec);
3189 static struct _opd_sec_data *
3190 get_opd_info (asection * sec)
3193 && ppc64_elf_section_data (sec) != NULL
3194 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3195 return &ppc64_elf_section_data (sec)->u.opd;
3199 /* Parameters for the qsort hook. */
3200 static bfd_boolean synthetic_relocatable;
3201 static asection *synthetic_opd;
3203 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3206 compare_symbols (const void *ap, const void *bp)
3208 const asymbol *a = * (const asymbol **) ap;
3209 const asymbol *b = * (const asymbol **) bp;
3211 /* Section symbols first. */
3212 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3214 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3217 /* then .opd symbols. */
3218 if (synthetic_opd != NULL)
3220 if (strcmp (a->section->name, ".opd") == 0
3221 && strcmp (b->section->name, ".opd") != 0)
3223 if (strcmp (a->section->name, ".opd") != 0
3224 && strcmp (b->section->name, ".opd") == 0)
3228 /* then other code symbols. */
3229 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3230 == (SEC_CODE | SEC_ALLOC)
3231 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3232 != (SEC_CODE | SEC_ALLOC))
3235 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3236 != (SEC_CODE | SEC_ALLOC)
3237 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3238 == (SEC_CODE | SEC_ALLOC))
3241 if (synthetic_relocatable)
3243 if (a->section->id < b->section->id)
3246 if (a->section->id > b->section->id)
3250 if (a->value + a->section->vma < b->value + b->section->vma)
3253 if (a->value + a->section->vma > b->value + b->section->vma)
3256 /* For syms with the same value, prefer strong dynamic global function
3257 syms over other syms. */
3258 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3261 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3264 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3267 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3270 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3273 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3276 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3279 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3285 /* Search SYMS for a symbol of the given VALUE. */
3288 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3292 if (id == (unsigned) -1)
3296 mid = (lo + hi) >> 1;
3297 if (syms[mid]->value + syms[mid]->section->vma < value)
3299 else if (syms[mid]->value + syms[mid]->section->vma > value)
3309 mid = (lo + hi) >> 1;
3310 if (syms[mid]->section->id < id)
3312 else if (syms[mid]->section->id > id)
3314 else if (syms[mid]->value < value)
3316 else if (syms[mid]->value > value)
3326 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3328 bfd_vma vma = *(bfd_vma *) ptr;
3329 return ((section->flags & SEC_ALLOC) != 0
3330 && section->vma <= vma
3331 && vma < section->vma + section->size);
3334 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3335 entry syms. Also generate @plt symbols for the glink branch table.
3336 Returns count of synthetic symbols in RET or -1 on error. */
3339 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3340 long static_count, asymbol **static_syms,
3341 long dyn_count, asymbol **dyn_syms,
3347 size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3348 asection *opd = NULL;
3349 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3351 int abi = abiversion (abfd);
3357 opd = bfd_get_section_by_name (abfd, ".opd");
3358 if (opd == NULL && abi == 1)
3370 symcount = static_count;
3372 symcount += dyn_count;
3376 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3380 if (!relocatable && static_count != 0 && dyn_count != 0)
3382 /* Use both symbol tables. */
3383 memcpy (syms, static_syms, static_count * sizeof (*syms));
3384 memcpy (syms + static_count, dyn_syms,
3385 (dyn_count + 1) * sizeof (*syms));
3387 else if (!relocatable && static_count == 0)
3388 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3390 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3392 /* Trim uninteresting symbols. Interesting symbols are section,
3393 function, and notype symbols. */
3394 for (i = 0, j = 0; i < symcount; ++i)
3395 if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3396 | BSF_RELC | BSF_SRELC)) == 0)
3397 syms[j++] = syms[i];
3400 synthetic_relocatable = relocatable;
3401 synthetic_opd = opd;
3402 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3404 if (!relocatable && symcount > 1)
3406 /* Trim duplicate syms, since we may have merged the normal
3407 and dynamic symbols. Actually, we only care about syms
3408 that have different values, so trim any with the same
3409 value. Don't consider ifunc and ifunc resolver symbols
3410 duplicates however, because GDB wants to know whether a
3411 text symbol is an ifunc resolver. */
3412 for (i = 1, j = 1; i < symcount; ++i)
3414 const asymbol *s0 = syms[i - 1];
3415 const asymbol *s1 = syms[i];
3417 if ((s0->value + s0->section->vma
3418 != s1->value + s1->section->vma)
3419 || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3420 != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3421 syms[j++] = syms[i];
3427 /* Note that here and in compare_symbols we can't compare opd and
3428 sym->section directly. With separate debug info files, the
3429 symbols will be extracted from the debug file while abfd passed
3430 to this function is the real binary. */
3431 if (strcmp (syms[i]->section->name, ".opd") == 0)
3435 for (; i < symcount; ++i)
3436 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3437 | SEC_THREAD_LOCAL))
3438 != (SEC_CODE | SEC_ALLOC))
3439 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3443 for (; i < symcount; ++i)
3444 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3448 for (; i < symcount; ++i)
3449 if (strcmp (syms[i]->section->name, ".opd") != 0)
3453 for (; i < symcount; ++i)
3454 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3455 != (SEC_CODE | SEC_ALLOC))
3463 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3468 if (opdsymend == secsymend)
3471 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3472 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3476 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3483 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3487 while (r < opd->relocation + relcount
3488 && r->address < syms[i]->value + opd->vma)
3491 if (r == opd->relocation + relcount)
3494 if (r->address != syms[i]->value + opd->vma)
3497 if (r->howto->type != R_PPC64_ADDR64)
3500 sym = *r->sym_ptr_ptr;
3501 if (!sym_exists_at (syms, opdsymend, symcount,
3502 sym->section->id, sym->value + r->addend))
3505 size += sizeof (asymbol);
3506 size += strlen (syms[i]->name) + 2;
3512 s = *ret = bfd_malloc (size);
3519 names = (char *) (s + count);
3521 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3525 while (r < opd->relocation + relcount
3526 && r->address < syms[i]->value + opd->vma)
3529 if (r == opd->relocation + relcount)
3532 if (r->address != syms[i]->value + opd->vma)
3535 if (r->howto->type != R_PPC64_ADDR64)
3538 sym = *r->sym_ptr_ptr;
3539 if (!sym_exists_at (syms, opdsymend, symcount,
3540 sym->section->id, sym->value + r->addend))
3545 s->flags |= BSF_SYNTHETIC;
3546 s->section = sym->section;
3547 s->value = sym->value + r->addend;
3550 len = strlen (syms[i]->name);
3551 memcpy (names, syms[i]->name, len + 1);
3553 /* Have udata.p point back to the original symbol this
3554 synthetic symbol was derived from. */
3555 s->udata.p = syms[i];
3562 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3563 bfd_byte *contents = NULL;
3565 size_t plt_count = 0;
3566 bfd_vma glink_vma = 0, resolv_vma = 0;
3567 asection *dynamic, *glink = NULL, *relplt = NULL;
3570 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3572 free_contents_and_exit_err:
3574 free_contents_and_exit:
3581 for (i = secsymend; i < opdsymend; ++i)
3585 /* Ignore bogus symbols. */
3586 if (syms[i]->value > opd->size - 8)
3589 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3590 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3593 size += sizeof (asymbol);
3594 size += strlen (syms[i]->name) + 2;
3598 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3600 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3602 bfd_byte *dynbuf, *extdyn, *extdynend;
3604 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3606 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3607 goto free_contents_and_exit_err;
3609 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3610 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3613 extdynend = extdyn + dynamic->size;
3614 for (; extdyn < extdynend; extdyn += extdynsize)
3616 Elf_Internal_Dyn dyn;
3617 (*swap_dyn_in) (abfd, extdyn, &dyn);
3619 if (dyn.d_tag == DT_NULL)
3622 if (dyn.d_tag == DT_PPC64_GLINK)
3624 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3625 See comment in ppc64_elf_finish_dynamic_sections. */
3626 glink_vma = dyn.d_un.d_val + 8 * 4;
3627 /* The .glink section usually does not survive the final
3628 link; search for the section (usually .text) where the
3629 glink stubs now reside. */
3630 glink = bfd_sections_find_if (abfd, section_covers_vma,
3641 /* Determine __glink trampoline by reading the relative branch
3642 from the first glink stub. */
3644 unsigned int off = 0;
3646 while (bfd_get_section_contents (abfd, glink, buf,
3647 glink_vma + off - glink->vma, 4))
3649 unsigned int insn = bfd_get_32 (abfd, buf);
3651 if ((insn & ~0x3fffffc) == 0)
3653 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3662 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3664 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3667 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3668 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3669 goto free_contents_and_exit_err;
3671 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3672 size += plt_count * sizeof (asymbol);
3674 p = relplt->relocation;
3675 for (i = 0; i < plt_count; i++, p++)
3677 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3679 size += sizeof ("+0x") - 1 + 16;
3685 goto free_contents_and_exit;
3686 s = *ret = bfd_malloc (size);
3688 goto free_contents_and_exit_err;
3690 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3692 for (i = secsymend; i < opdsymend; ++i)
3696 if (syms[i]->value > opd->size - 8)
3699 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3700 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3704 asection *sec = abfd->sections;
3711 size_t mid = (lo + hi) >> 1;
3712 if (syms[mid]->section->vma < ent)
3714 else if (syms[mid]->section->vma > ent)
3718 sec = syms[mid]->section;
3723 if (lo >= hi && lo > codesecsym)
3724 sec = syms[lo - 1]->section;
3726 for (; sec != NULL; sec = sec->next)
3730 /* SEC_LOAD may not be set if SEC is from a separate debug
3732 if ((sec->flags & SEC_ALLOC) == 0)
3734 if ((sec->flags & SEC_CODE) != 0)
3737 s->flags |= BSF_SYNTHETIC;
3738 s->value = ent - s->section->vma;
3741 len = strlen (syms[i]->name);
3742 memcpy (names, syms[i]->name, len + 1);
3744 /* Have udata.p point back to the original symbol this
3745 synthetic symbol was derived from. */
3746 s->udata.p = syms[i];
3752 if (glink != NULL && relplt != NULL)
3756 /* Add a symbol for the main glink trampoline. */
3757 memset (s, 0, sizeof *s);
3759 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3761 s->value = resolv_vma - glink->vma;
3763 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3764 names += sizeof ("__glink_PLTresolve");
3769 /* FIXME: It would be very much nicer to put sym@plt on the
3770 stub rather than on the glink branch table entry. The
3771 objdump disassembler would then use a sensible symbol
3772 name on plt calls. The difficulty in doing so is
3773 a) finding the stubs, and,
3774 b) matching stubs against plt entries, and,
3775 c) there can be multiple stubs for a given plt entry.
3777 Solving (a) could be done by code scanning, but older
3778 ppc64 binaries used different stubs to current code.
3779 (b) is the tricky one since you need to known the toc
3780 pointer for at least one function that uses a pic stub to
3781 be able to calculate the plt address referenced.
3782 (c) means gdb would need to set multiple breakpoints (or
3783 find the glink branch itself) when setting breakpoints
3784 for pending shared library loads. */
3785 p = relplt->relocation;
3786 for (i = 0; i < plt_count; i++, p++)
3790 *s = **p->sym_ptr_ptr;
3791 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3792 we are defining a symbol, ensure one of them is set. */
3793 if ((s->flags & BSF_LOCAL) == 0)
3794 s->flags |= BSF_GLOBAL;
3795 s->flags |= BSF_SYNTHETIC;
3797 s->value = glink_vma - glink->vma;
3800 len = strlen ((*p->sym_ptr_ptr)->name);
3801 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3805 memcpy (names, "+0x", sizeof ("+0x") - 1);
3806 names += sizeof ("+0x") - 1;
3807 bfd_sprintf_vma (abfd, names, p->addend);
3808 names += strlen (names);
3810 memcpy (names, "@plt", sizeof ("@plt"));
3811 names += sizeof ("@plt");
3831 /* The following functions are specific to the ELF linker, while
3832 functions above are used generally. Those named ppc64_elf_* are
3833 called by the main ELF linker code. They appear in this file more
3834 or less in the order in which they are called. eg.
3835 ppc64_elf_check_relocs is called early in the link process,
3836 ppc64_elf_finish_dynamic_sections is one of the last functions
3839 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3840 functions have both a function code symbol and a function descriptor
3841 symbol. A call to foo in a relocatable object file looks like:
3848 The function definition in another object file might be:
3852 . .quad .TOC.@tocbase
3858 When the linker resolves the call during a static link, the branch
3859 unsurprisingly just goes to .foo and the .opd information is unused.
3860 If the function definition is in a shared library, things are a little
3861 different: The call goes via a plt call stub, the opd information gets
3862 copied to the plt, and the linker patches the nop.
3870 . std 2,40(1) # in practice, the call stub
3871 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3872 . addi 11,11,Lfoo@toc@l # this is the general idea
3880 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3882 The "reloc ()" notation is supposed to indicate that the linker emits
3883 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3886 What are the difficulties here? Well, firstly, the relocations
3887 examined by the linker in check_relocs are against the function code
3888 sym .foo, while the dynamic relocation in the plt is emitted against
3889 the function descriptor symbol, foo. Somewhere along the line, we need
3890 to carefully copy dynamic link information from one symbol to the other.
3891 Secondly, the generic part of the elf linker will make .foo a dynamic
3892 symbol as is normal for most other backends. We need foo dynamic
3893 instead, at least for an application final link. However, when
3894 creating a shared library containing foo, we need to have both symbols
3895 dynamic so that references to .foo are satisfied during the early
3896 stages of linking. Otherwise the linker might decide to pull in a
3897 definition from some other object, eg. a static library.
3899 Update: As of August 2004, we support a new convention. Function
3900 calls may use the function descriptor symbol, ie. "bl foo". This
3901 behaves exactly as "bl .foo". */
3903 /* Of those relocs that might be copied as dynamic relocs, this
3904 function selects those that must be copied when linking a shared
3905 library or PIE, even when the symbol is local. */
3908 must_be_dyn_reloc (struct bfd_link_info *info,
3909 enum elf_ppc64_reloc_type r_type)
3914 /* Only relative relocs can be resolved when the object load
3915 address isn't fixed. DTPREL64 is excluded because the
3916 dynamic linker needs to differentiate global dynamic from
3917 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
3925 case R_PPC64_TPREL16:
3926 case R_PPC64_TPREL16_LO:
3927 case R_PPC64_TPREL16_HI:
3928 case R_PPC64_TPREL16_HA:
3929 case R_PPC64_TPREL16_DS:
3930 case R_PPC64_TPREL16_LO_DS:
3931 case R_PPC64_TPREL16_HIGH:
3932 case R_PPC64_TPREL16_HIGHA:
3933 case R_PPC64_TPREL16_HIGHER:
3934 case R_PPC64_TPREL16_HIGHERA:
3935 case R_PPC64_TPREL16_HIGHEST:
3936 case R_PPC64_TPREL16_HIGHESTA:
3937 case R_PPC64_TPREL64:
3938 /* These relocations are relative but in a shared library the
3939 linker doesn't know the thread pointer base. */
3940 return bfd_link_dll (info);
3944 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3945 copying dynamic variables from a shared lib into an app's dynbss
3946 section, and instead use a dynamic relocation to point into the
3947 shared lib. With code that gcc generates, it's vital that this be
3948 enabled; In the PowerPC64 ABI, the address of a function is actually
3949 the address of a function descriptor, which resides in the .opd
3950 section. gcc uses the descriptor directly rather than going via the
3951 GOT as some other ABI's do, which means that initialized function
3952 pointers must reference the descriptor. Thus, a function pointer
3953 initialized to the address of a function in a shared library will
3954 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3955 redefines the function descriptor symbol to point to the copy. This
3956 presents a problem as a plt entry for that function is also
3957 initialized from the function descriptor symbol and the copy reloc
3958 may not be initialized first. */
3959 #define ELIMINATE_COPY_RELOCS 1
3961 /* Section name for stubs is the associated section name plus this
3963 #define STUB_SUFFIX ".stub"
3966 ppc_stub_long_branch:
3967 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3968 destination, but a 24 bit branch in a stub section will reach.
3971 ppc_stub_plt_branch:
3972 Similar to the above, but a 24 bit branch in the stub section won't
3973 reach its destination.
3974 . addis %r11,%r2,xxx@toc@ha
3975 . ld %r12,xxx@toc@l(%r11)
3980 Used to call a function in a shared library. If it so happens that
3981 the plt entry referenced crosses a 64k boundary, then an extra
3982 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3983 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
3984 . addis %r11,%r2,xxx@toc@ha
3985 . ld %r12,xxx+0@toc@l(%r11)
3987 . ld %r2,xxx+8@toc@l(%r11)
3988 . ld %r11,xxx+16@toc@l(%r11)
3991 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3992 code to adjust the value and save r2 to support multiple toc sections.
3993 A ppc_stub_long_branch with an r2 offset looks like:
3995 . addis %r2,%r2,off@ha
3996 . addi %r2,%r2,off@l
3999 A ppc_stub_plt_branch with an r2 offset looks like:
4001 . addis %r11,%r2,xxx@toc@ha
4002 . ld %r12,xxx@toc@l(%r11)
4003 . addis %r2,%r2,off@ha
4004 . addi %r2,%r2,off@l
4008 All of the above stubs are shown as their ELFv1 variants. ELFv2
4009 variants exist too, simpler for plt calls since a new toc pointer
4010 and static chain are not loaded by the stub. In addition, ELFv2
4011 has some more complex stubs to handle calls marked with NOTOC
4012 relocs from functions where r2 is not a valid toc pointer. These
4013 come in two flavours, the ones shown below, and _both variants that
4014 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
4015 one call is from a function where r2 is used as the toc pointer but
4016 needs a toc adjusting stub for small-model multi-toc, and another
4017 call is from a function where r2 is not valid.
4018 ppc_stub_long_branch_notoc:
4024 . lis %r12,xxx-1b@highest
4025 . ori %r12,xxx-1b@higher
4027 . oris %r12,%r12,xxx-1b@hi
4028 . ori %r12,%r12,xxx-1b@l
4029 . add %r12,%r11,%r12
4032 ppc_stub_plt_branch_notoc:
4038 . lis %r12,xxx-1b@highest
4039 . ori %r12,xxx-1b@higher
4041 . oris %r12,%r12,xxx-1b@hi
4042 . ori %r12,%r12,xxx-1b@l
4043 . add %r12,%r11,%r12
4047 ppc_stub_plt_call_notoc:
4053 . lis %r12,xxx-1b@highest
4054 . ori %r12,xxx-1b@higher
4056 . oris %r12,%r12,xxx-1b@hi
4057 . ori %r12,%r12,xxx-1b@l
4058 . ldx %r12,%r11,%r12
4062 In cases where the high instructions would add zero, they are
4063 omitted and following instructions modified in some cases.
4065 For a given stub group (a set of sections all using the same toc
4066 pointer value) there will be just one stub type used for any
4067 particular function symbol. For example, if printf is called from
4068 code with the tocsave optimization (ie. r2 saved in function
4069 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
4070 and from other code without the tocsave optimization requiring a
4071 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
4072 type will be created. Calls with the tocsave optimization will
4073 enter this stub after the instruction saving r2. A similar
4074 situation exists when calls are marked with R_PPC64_REL24_NOTOC
4075 relocations. These require a ppc_stub_plt_call_notoc linkage stub
4076 to call an external function like printf. If other calls to printf
4077 require a ppc_stub_plt_call linkage stub then a single
4078 ppc_stub_plt_call_notoc linkage stub will be used for both types of
4079 call. If other calls to printf require a ppc_stub_plt_call_r2save
4080 linkage stub then a single ppc_stub_plt_call_both linkage stub will
4081 be created and calls not requiring r2 to be saved will enter the
4082 stub after the r2 save instruction. There is an analogous
4083 hierarchy of long branch and plt branch stubs for local call
4086 enum ppc_stub_type {
4088 ppc_stub_long_branch,
4089 ppc_stub_long_branch_r2off,
4090 ppc_stub_long_branch_notoc,
4091 ppc_stub_long_branch_both, /* r2off and notoc variants both needed. */
4092 ppc_stub_plt_branch,
4093 ppc_stub_plt_branch_r2off,
4094 ppc_stub_plt_branch_notoc,
4095 ppc_stub_plt_branch_both,
4097 ppc_stub_plt_call_r2save,
4098 ppc_stub_plt_call_notoc,
4099 ppc_stub_plt_call_both,
4100 ppc_stub_global_entry,
4104 /* Information on stub grouping. */
4107 /* The stub section. */
4109 /* This is the section to which stubs in the group will be attached. */
4112 struct map_stub *next;
4113 /* Whether to emit a copy of register save/restore functions in this
4116 /* Current offset within stubs after the insn restoring lr in a
4117 _notoc or _both stub using bcl for pc-relative addressing, or
4118 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
4119 unsigned int lr_restore;
4120 /* Accumulated size of EH info emitted to describe return address
4121 if stubs modify lr. Does not include 17 byte FDE header. */
4122 unsigned int eh_size;
4123 /* Offset in glink_eh_frame to the start of EH info for this group. */
4124 unsigned int eh_base;
4127 struct ppc_stub_hash_entry {
4129 /* Base hash table entry structure. */
4130 struct bfd_hash_entry root;
4132 enum ppc_stub_type stub_type;
4134 /* Group information. */
4135 struct map_stub *group;
4137 /* Offset within stub_sec of the beginning of this stub. */
4138 bfd_vma stub_offset;
4140 /* Given the symbol's value and its section we can determine its final
4141 value when building the stubs (so the stub knows where to jump. */
4142 bfd_vma target_value;
4143 asection *target_section;
4145 /* The symbol table entry, if any, that this was derived from. */
4146 struct ppc_link_hash_entry *h;
4147 struct plt_entry *plt_ent;
4150 unsigned char symtype;
4152 /* Symbol st_other. */
4153 unsigned char other;
4156 struct ppc_branch_hash_entry {
4158 /* Base hash table entry structure. */
4159 struct bfd_hash_entry root;
4161 /* Offset within branch lookup table. */
4162 unsigned int offset;
4164 /* Generation marker. */
4168 /* Used to track dynamic relocations for local symbols. */
4169 struct ppc_dyn_relocs
4171 struct ppc_dyn_relocs *next;
4173 /* The input section of the reloc. */
4176 /* Total number of relocs copied for the input section. */
4177 unsigned int count : 31;
4179 /* Whether this entry is for STT_GNU_IFUNC symbols. */
4180 unsigned int ifunc : 1;
4183 struct ppc_link_hash_entry
4185 struct elf_link_hash_entry elf;
4188 /* A pointer to the most recently used stub hash entry against this
4190 struct ppc_stub_hash_entry *stub_cache;
4192 /* A pointer to the next symbol starting with a '.' */
4193 struct ppc_link_hash_entry *next_dot_sym;
4196 /* Track dynamic relocs copied for this symbol. */
4197 struct elf_dyn_relocs *dyn_relocs;
4199 /* Link between function code and descriptor symbols. */
4200 struct ppc_link_hash_entry *oh;
4202 /* Flag function code and descriptor symbols. */
4203 unsigned int is_func:1;
4204 unsigned int is_func_descriptor:1;
4205 unsigned int fake:1;
4207 /* Whether global opd/toc sym has been adjusted or not.
4208 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4209 should be set for all globals defined in any opd/toc section. */
4210 unsigned int adjust_done:1;
4212 /* Set if this is an out-of-line register save/restore function,
4213 with non-standard calling convention. */
4214 unsigned int save_res:1;
4216 /* Set if a duplicate symbol with non-zero localentry is detected,
4217 even when the duplicate symbol does not provide a definition. */
4218 unsigned int non_zero_localentry:1;
4220 /* Contexts in which symbol is used in the GOT (or TOC).
4221 Bits are or'd into the mask as the corresponding relocs are
4222 encountered during check_relocs, with TLS_TLS being set when any
4223 of the other TLS bits are set. tls_optimize clears bits when
4224 optimizing to indicate the corresponding GOT entry type is not
4225 needed. If set, TLS_TLS is never cleared. tls_optimize may also
4226 set TLS_TPRELGD when a GD reloc turns into a TPREL one. We use a
4227 separate flag rather than setting TPREL just for convenience in
4228 distinguishing the two cases.
4229 These flags are also kept for local symbols. */
4230 #define TLS_TLS 1 /* Any TLS reloc. */
4231 #define TLS_GD 2 /* GD reloc. */
4232 #define TLS_LD 4 /* LD reloc. */
4233 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
4234 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
4235 #define TLS_MARK 32 /* __tls_get_addr call marked. */
4236 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4237 #define TLS_EXPLICIT 128 /* Marks TOC section TLS relocs. */
4238 unsigned char tls_mask;
4240 /* The above field is also used to mark function symbols. In which
4241 case TLS_TLS will be 0. */
4242 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
4243 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
4244 #define NON_GOT 256 /* local symbol plt, not stored. */
4247 /* ppc64 ELF linker hash table. */
4249 struct ppc_link_hash_table
4251 struct elf_link_hash_table elf;
4253 /* The stub hash table. */
4254 struct bfd_hash_table stub_hash_table;
4256 /* Another hash table for plt_branch stubs. */
4257 struct bfd_hash_table branch_hash_table;
4259 /* Hash table for function prologue tocsave. */
4260 htab_t tocsave_htab;
4262 /* Various options and other info passed from the linker. */
4263 struct ppc64_elf_params *params;
4265 /* The size of sec_info below. */
4266 unsigned int sec_info_arr_size;
4268 /* Per-section array of extra section info. Done this way rather
4269 than as part of ppc64_elf_section_data so we have the info for
4270 non-ppc64 sections. */
4273 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4278 /* The section group that this section belongs to. */
4279 struct map_stub *group;
4280 /* A temp section list pointer. */
4285 /* Linked list of groups. */
4286 struct map_stub *group;
4288 /* Temp used when calculating TOC pointers. */
4291 asection *toc_first_sec;
4293 /* Used when adding symbols. */
4294 struct ppc_link_hash_entry *dot_syms;
4296 /* Shortcuts to get to dynamic linker sections. */
4298 asection *global_entry;
4301 asection *relpltlocal;
4304 asection *glink_eh_frame;
4306 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4307 struct ppc_link_hash_entry *tls_get_addr;
4308 struct ppc_link_hash_entry *tls_get_addr_fd;
4310 /* The size of reliplt used by got entry relocs. */
4311 bfd_size_type got_reli_size;
4314 unsigned long stub_count[ppc_stub_global_entry];
4316 /* Number of stubs against global syms. */
4317 unsigned long stub_globals;
4319 /* Set if we're linking code with function descriptors. */
4320 unsigned int opd_abi:1;
4322 /* Support for multiple toc sections. */
4323 unsigned int do_multi_toc:1;
4324 unsigned int multi_toc_needed:1;
4325 unsigned int second_toc_pass:1;
4326 unsigned int do_toc_opt:1;
4328 /* Set if tls optimization is enabled. */
4329 unsigned int do_tls_opt:1;
4331 /* Set if inline plt calls should be converted to direct calls. */
4332 unsigned int can_convert_all_inline_plt:1;
4335 unsigned int stub_error:1;
4337 /* Whether func_desc_adjust needs to be run over symbols. */
4338 unsigned int need_func_desc_adj:1;
4340 /* Whether there exist local gnu indirect function resolvers,
4341 referenced by dynamic relocations. */
4342 unsigned int local_ifunc_resolver:1;
4343 unsigned int maybe_local_ifunc_resolver:1;
4345 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
4346 unsigned int has_plt_localentry0:1;
4348 /* Incremented every time we size stubs. */
4349 unsigned int stub_iteration;
4351 /* Small local sym cache. */
4352 struct sym_cache sym_cache;
4355 /* Rename some of the generic section flags to better document how they
4358 /* Nonzero if this section has TLS related relocations. */
4359 #define has_tls_reloc sec_flg0
4361 /* Nonzero if this section has an old-style call to __tls_get_addr. */
4362 #define has_tls_get_addr_call sec_flg1
4364 /* Nonzero if this section has any toc or got relocs. */
4365 #define has_toc_reloc sec_flg2
4367 /* Nonzero if this section has a call to another section that uses
4369 #define makes_toc_func_call sec_flg3
4371 /* Recursion protection when determining above flag. */
4372 #define call_check_in_progress sec_flg4
4373 #define call_check_done sec_flg5
4375 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4377 #define ppc_hash_table(p) \
4378 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4379 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4381 #define ppc_stub_hash_lookup(table, string, create, copy) \
4382 ((struct ppc_stub_hash_entry *) \
4383 bfd_hash_lookup ((table), (string), (create), (copy)))
4385 #define ppc_branch_hash_lookup(table, string, create, copy) \
4386 ((struct ppc_branch_hash_entry *) \
4387 bfd_hash_lookup ((table), (string), (create), (copy)))
4389 /* Create an entry in the stub hash table. */
4391 static struct bfd_hash_entry *
4392 stub_hash_newfunc (struct bfd_hash_entry *entry,
4393 struct bfd_hash_table *table,
4396 /* Allocate the structure if it has not already been allocated by a
4400 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4405 /* Call the allocation method of the superclass. */
4406 entry = bfd_hash_newfunc (entry, table, string);
4409 struct ppc_stub_hash_entry *eh;
4411 /* Initialize the local fields. */
4412 eh = (struct ppc_stub_hash_entry *) entry;
4413 eh->stub_type = ppc_stub_none;
4415 eh->stub_offset = 0;
4416 eh->target_value = 0;
4417 eh->target_section = NULL;
4426 /* Create an entry in the branch hash table. */
4428 static struct bfd_hash_entry *
4429 branch_hash_newfunc (struct bfd_hash_entry *entry,
4430 struct bfd_hash_table *table,
4433 /* Allocate the structure if it has not already been allocated by a
4437 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4442 /* Call the allocation method of the superclass. */
4443 entry = bfd_hash_newfunc (entry, table, string);
4446 struct ppc_branch_hash_entry *eh;
4448 /* Initialize the local fields. */
4449 eh = (struct ppc_branch_hash_entry *) entry;
4457 /* Create an entry in a ppc64 ELF linker hash table. */
4459 static struct bfd_hash_entry *
4460 link_hash_newfunc (struct bfd_hash_entry *entry,
4461 struct bfd_hash_table *table,
4464 /* Allocate the structure if it has not already been allocated by a
4468 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4473 /* Call the allocation method of the superclass. */
4474 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4477 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4479 memset (&eh->u.stub_cache, 0,
4480 (sizeof (struct ppc_link_hash_entry)
4481 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4483 /* When making function calls, old ABI code references function entry
4484 points (dot symbols), while new ABI code references the function
4485 descriptor symbol. We need to make any combination of reference and
4486 definition work together, without breaking archive linking.
4488 For a defined function "foo" and an undefined call to "bar":
4489 An old object defines "foo" and ".foo", references ".bar" (possibly
4491 A new object defines "foo" and references "bar".
4493 A new object thus has no problem with its undefined symbols being
4494 satisfied by definitions in an old object. On the other hand, the
4495 old object won't have ".bar" satisfied by a new object.
4497 Keep a list of newly added dot-symbols. */
4499 if (string[0] == '.')
4501 struct ppc_link_hash_table *htab;
4503 htab = (struct ppc_link_hash_table *) table;
4504 eh->u.next_dot_sym = htab->dot_syms;
4505 htab->dot_syms = eh;
4512 struct tocsave_entry {
4518 tocsave_htab_hash (const void *p)
4520 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4521 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4525 tocsave_htab_eq (const void *p1, const void *p2)
4527 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4528 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4529 return e1->sec == e2->sec && e1->offset == e2->offset;
4532 /* Destroy a ppc64 ELF linker hash table. */
4535 ppc64_elf_link_hash_table_free (bfd *obfd)
4537 struct ppc_link_hash_table *htab;
4539 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4540 if (htab->tocsave_htab)
4541 htab_delete (htab->tocsave_htab);
4542 bfd_hash_table_free (&htab->branch_hash_table);
4543 bfd_hash_table_free (&htab->stub_hash_table);
4544 _bfd_elf_link_hash_table_free (obfd);
4547 /* Create a ppc64 ELF linker hash table. */
4549 static struct bfd_link_hash_table *
4550 ppc64_elf_link_hash_table_create (bfd *abfd)
4552 struct ppc_link_hash_table *htab;
4553 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4555 htab = bfd_zmalloc (amt);
4559 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4560 sizeof (struct ppc_link_hash_entry),
4567 /* Init the stub hash table too. */
4568 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4569 sizeof (struct ppc_stub_hash_entry)))
4571 _bfd_elf_link_hash_table_free (abfd);
4575 /* And the branch hash table. */
4576 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4577 sizeof (struct ppc_branch_hash_entry)))
4579 bfd_hash_table_free (&htab->stub_hash_table);
4580 _bfd_elf_link_hash_table_free (abfd);
4584 htab->tocsave_htab = htab_try_create (1024,
4588 if (htab->tocsave_htab == NULL)
4590 ppc64_elf_link_hash_table_free (abfd);
4593 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4595 /* Initializing two fields of the union is just cosmetic. We really
4596 only care about glist, but when compiled on a 32-bit host the
4597 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4598 debugger inspection of these fields look nicer. */
4599 htab->elf.init_got_refcount.refcount = 0;
4600 htab->elf.init_got_refcount.glist = NULL;
4601 htab->elf.init_plt_refcount.refcount = 0;
4602 htab->elf.init_plt_refcount.glist = NULL;
4603 htab->elf.init_got_offset.offset = 0;
4604 htab->elf.init_got_offset.glist = NULL;
4605 htab->elf.init_plt_offset.offset = 0;
4606 htab->elf.init_plt_offset.glist = NULL;
4608 return &htab->elf.root;
4611 /* Create sections for linker generated code. */
4614 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4616 struct ppc_link_hash_table *htab;
4619 htab = ppc_hash_table (info);
4621 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4622 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4623 if (htab->params->save_restore_funcs)
4625 /* Create .sfpr for code to save and restore fp regs. */
4626 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4628 if (htab->sfpr == NULL
4629 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4633 if (bfd_link_relocatable (info))
4636 /* Create .glink for lazy dynamic linking support. */
4637 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4639 if (htab->glink == NULL
4640 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4643 /* The part of .glink used by global entry stubs, separate so that
4644 it can be aligned appropriately without affecting htab->glink. */
4645 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4647 if (htab->global_entry == NULL
4648 || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4651 if (!info->no_ld_generated_unwind_info)
4653 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4654 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4655 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4658 if (htab->glink_eh_frame == NULL
4659 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4663 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4664 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4665 if (htab->elf.iplt == NULL
4666 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4669 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4670 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4672 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4673 if (htab->elf.irelplt == NULL
4674 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4677 /* Create branch lookup table for plt_branch stubs. */
4678 flags = (SEC_ALLOC | SEC_LOAD
4679 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4680 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4682 if (htab->brlt == NULL
4683 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4686 /* Local plt entries, put in .branch_lt but a separate section for
4688 htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4690 if (htab->pltlocal == NULL
4691 || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4694 if (!bfd_link_pic (info))
4697 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4698 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4700 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4701 if (htab->relbrlt == NULL
4702 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4706 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4707 if (htab->relpltlocal == NULL
4708 || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4714 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4717 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4718 struct ppc64_elf_params *params)
4720 struct ppc_link_hash_table *htab;
4722 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4724 /* Always hook our dynamic sections into the first bfd, which is the
4725 linker created stub bfd. This ensures that the GOT header is at
4726 the start of the output TOC section. */
4727 htab = ppc_hash_table (info);
4728 htab->elf.dynobj = params->stub_bfd;
4729 htab->params = params;
4731 return create_linkage_sections (htab->elf.dynobj, info);
4734 /* Build a name for an entry in the stub hash table. */
4737 ppc_stub_name (const asection *input_section,
4738 const asection *sym_sec,
4739 const struct ppc_link_hash_entry *h,
4740 const Elf_Internal_Rela *rel)
4745 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4746 offsets from a sym as a branch target? In fact, we could
4747 probably assume the addend is always zero. */
4748 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4752 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4753 stub_name = bfd_malloc (len);
4754 if (stub_name == NULL)
4757 len = sprintf (stub_name, "%08x.%s+%x",
4758 input_section->id & 0xffffffff,
4759 h->elf.root.root.string,
4760 (int) rel->r_addend & 0xffffffff);
4764 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4765 stub_name = bfd_malloc (len);
4766 if (stub_name == NULL)
4769 len = sprintf (stub_name, "%08x.%x:%x+%x",
4770 input_section->id & 0xffffffff,
4771 sym_sec->id & 0xffffffff,
4772 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4773 (int) rel->r_addend & 0xffffffff);
4775 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4776 stub_name[len - 2] = 0;
4780 /* Look up an entry in the stub hash. Stub entries are cached because
4781 creating the stub name takes a bit of time. */
4783 static struct ppc_stub_hash_entry *
4784 ppc_get_stub_entry (const asection *input_section,
4785 const asection *sym_sec,
4786 struct ppc_link_hash_entry *h,
4787 const Elf_Internal_Rela *rel,
4788 struct ppc_link_hash_table *htab)
4790 struct ppc_stub_hash_entry *stub_entry;
4791 struct map_stub *group;
4793 /* If this input section is part of a group of sections sharing one
4794 stub section, then use the id of the first section in the group.
4795 Stub names need to include a section id, as there may well be
4796 more than one stub used to reach say, printf, and we need to
4797 distinguish between them. */
4798 group = htab->sec_info[input_section->id].u.group;
4802 if (h != NULL && h->u.stub_cache != NULL
4803 && h->u.stub_cache->h == h
4804 && h->u.stub_cache->group == group)
4806 stub_entry = h->u.stub_cache;
4812 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4813 if (stub_name == NULL)
4816 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4817 stub_name, FALSE, FALSE);
4819 h->u.stub_cache = stub_entry;
4827 /* Add a new stub entry to the stub hash. Not all fields of the new
4828 stub entry are initialised. */
4830 static struct ppc_stub_hash_entry *
4831 ppc_add_stub (const char *stub_name,
4833 struct bfd_link_info *info)
4835 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4836 struct map_stub *group;
4839 struct ppc_stub_hash_entry *stub_entry;
4841 group = htab->sec_info[section->id].u.group;
4842 link_sec = group->link_sec;
4843 stub_sec = group->stub_sec;
4844 if (stub_sec == NULL)
4850 namelen = strlen (link_sec->name);
4851 len = namelen + sizeof (STUB_SUFFIX);
4852 s_name = bfd_alloc (htab->params->stub_bfd, len);
4856 memcpy (s_name, link_sec->name, namelen);
4857 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4858 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4859 if (stub_sec == NULL)
4861 group->stub_sec = stub_sec;
4864 /* Enter this entry into the linker stub hash table. */
4865 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4867 if (stub_entry == NULL)
4869 /* xgettext:c-format */
4870 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4871 section->owner, stub_name);
4875 stub_entry->group = group;
4876 stub_entry->stub_offset = 0;
4880 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4881 not already done. */
4884 create_got_section (bfd *abfd, struct bfd_link_info *info)
4886 asection *got, *relgot;
4888 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4890 if (!is_ppc64_elf (abfd))
4896 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4899 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4900 | SEC_LINKER_CREATED);
4902 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4904 || !bfd_set_section_alignment (abfd, got, 3))
4907 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4908 flags | SEC_READONLY);
4910 || ! bfd_set_section_alignment (abfd, relgot, 3))
4913 ppc64_elf_tdata (abfd)->got = got;
4914 ppc64_elf_tdata (abfd)->relgot = relgot;
4918 /* Follow indirect and warning symbol links. */
4920 static inline struct bfd_link_hash_entry *
4921 follow_link (struct bfd_link_hash_entry *h)
4923 while (h->type == bfd_link_hash_indirect
4924 || h->type == bfd_link_hash_warning)
4929 static inline struct elf_link_hash_entry *
4930 elf_follow_link (struct elf_link_hash_entry *h)
4932 return (struct elf_link_hash_entry *) follow_link (&h->root);
4935 static inline struct ppc_link_hash_entry *
4936 ppc_follow_link (struct ppc_link_hash_entry *h)
4938 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4941 /* Merge PLT info on FROM with that on TO. */
4944 move_plt_plist (struct ppc_link_hash_entry *from,
4945 struct ppc_link_hash_entry *to)
4947 if (from->elf.plt.plist != NULL)
4949 if (to->elf.plt.plist != NULL)
4951 struct plt_entry **entp;
4952 struct plt_entry *ent;
4954 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4956 struct plt_entry *dent;
4958 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4959 if (dent->addend == ent->addend)
4961 dent->plt.refcount += ent->plt.refcount;
4968 *entp = to->elf.plt.plist;
4971 to->elf.plt.plist = from->elf.plt.plist;
4972 from->elf.plt.plist = NULL;
4976 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4979 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4980 struct elf_link_hash_entry *dir,
4981 struct elf_link_hash_entry *ind)
4983 struct ppc_link_hash_entry *edir, *eind;
4985 edir = (struct ppc_link_hash_entry *) dir;
4986 eind = (struct ppc_link_hash_entry *) ind;
4988 edir->is_func |= eind->is_func;
4989 edir->is_func_descriptor |= eind->is_func_descriptor;
4990 edir->tls_mask |= eind->tls_mask;
4991 if (eind->oh != NULL)
4992 edir->oh = ppc_follow_link (eind->oh);
4994 if (edir->elf.versioned != versioned_hidden)
4995 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4996 edir->elf.ref_regular |= eind->elf.ref_regular;
4997 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4998 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4999 edir->elf.needs_plt |= eind->elf.needs_plt;
5000 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
5002 /* If we were called to copy over info for a weak sym, don't copy
5003 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
5004 in order to simplify readonly_dynrelocs and save a field in the
5005 symbol hash entry, but that means dyn_relocs can't be used in any
5006 tests about a specific symbol, or affect other symbol flags which
5008 if (eind->elf.root.type != bfd_link_hash_indirect)
5011 /* Copy over any dynamic relocs we may have on the indirect sym. */
5012 if (eind->dyn_relocs != NULL)
5014 if (edir->dyn_relocs != NULL)
5016 struct elf_dyn_relocs **pp;
5017 struct elf_dyn_relocs *p;
5019 /* Add reloc counts against the indirect sym to the direct sym
5020 list. Merge any entries against the same section. */
5021 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5023 struct elf_dyn_relocs *q;
5025 for (q = edir->dyn_relocs; q != NULL; q = q->next)
5026 if (q->sec == p->sec)
5028 q->pc_count += p->pc_count;
5029 q->count += p->count;
5036 *pp = edir->dyn_relocs;
5039 edir->dyn_relocs = eind->dyn_relocs;
5040 eind->dyn_relocs = NULL;
5043 /* Copy over got entries that we may have already seen to the
5044 symbol which just became indirect. */
5045 if (eind->elf.got.glist != NULL)
5047 if (edir->elf.got.glist != NULL)
5049 struct got_entry **entp;
5050 struct got_entry *ent;
5052 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
5054 struct got_entry *dent;
5056 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
5057 if (dent->addend == ent->addend
5058 && dent->owner == ent->owner
5059 && dent->tls_type == ent->tls_type)
5061 dent->got.refcount += ent->got.refcount;
5068 *entp = edir->elf.got.glist;
5071 edir->elf.got.glist = eind->elf.got.glist;
5072 eind->elf.got.glist = NULL;
5075 /* And plt entries. */
5076 move_plt_plist (eind, edir);
5078 if (eind->elf.dynindx != -1)
5080 if (edir->elf.dynindx != -1)
5081 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5082 edir->elf.dynstr_index);
5083 edir->elf.dynindx = eind->elf.dynindx;
5084 edir->elf.dynstr_index = eind->elf.dynstr_index;
5085 eind->elf.dynindx = -1;
5086 eind->elf.dynstr_index = 0;
5090 /* Find the function descriptor hash entry from the given function code
5091 hash entry FH. Link the entries via their OH fields. */
5093 static struct ppc_link_hash_entry *
5094 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
5096 struct ppc_link_hash_entry *fdh = fh->oh;
5100 const char *fd_name = fh->elf.root.root.string + 1;
5102 fdh = (struct ppc_link_hash_entry *)
5103 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
5107 fdh->is_func_descriptor = 1;
5113 fdh = ppc_follow_link (fdh);
5114 fdh->is_func_descriptor = 1;
5119 /* Make a fake function descriptor sym for the undefined code sym FH. */
5121 static struct ppc_link_hash_entry *
5122 make_fdh (struct bfd_link_info *info,
5123 struct ppc_link_hash_entry *fh)
5125 bfd *abfd = fh->elf.root.u.undef.abfd;
5126 struct bfd_link_hash_entry *bh = NULL;
5127 struct ppc_link_hash_entry *fdh;
5128 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5132 if (!_bfd_generic_link_add_one_symbol (info, abfd,
5133 fh->elf.root.root.string + 1,
5134 flags, bfd_und_section_ptr, 0,
5135 NULL, FALSE, FALSE, &bh))
5138 fdh = (struct ppc_link_hash_entry *) bh;
5139 fdh->elf.non_elf = 0;
5141 fdh->is_func_descriptor = 1;
5148 /* Fix function descriptor symbols defined in .opd sections to be
5152 ppc64_elf_add_symbol_hook (bfd *ibfd,
5153 struct bfd_link_info *info,
5154 Elf_Internal_Sym *isym,
5156 flagword *flags ATTRIBUTE_UNUSED,
5161 && strcmp ((*sec)->name, ".opd") == 0)
5165 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5166 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5167 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5169 /* If the symbol is a function defined in .opd, and the function
5170 code is in a discarded group, let it appear to be undefined. */
5171 if (!bfd_link_relocatable (info)
5172 && (*sec)->reloc_count != 0
5173 && opd_entry_value (*sec, *value, &code_sec, NULL,
5174 FALSE) != (bfd_vma) -1
5175 && discarded_section (code_sec))
5177 *sec = bfd_und_section_ptr;
5178 isym->st_shndx = SHN_UNDEF;
5181 else if (*sec != NULL
5182 && strcmp ((*sec)->name, ".toc") == 0
5183 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5185 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5187 htab->params->object_in_toc = 1;
5190 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5192 if (abiversion (ibfd) == 0)
5193 set_abiversion (ibfd, 2);
5194 else if (abiversion (ibfd) == 1)
5196 _bfd_error_handler (_("symbol '%s' has invalid st_other"
5197 " for ABI version 1"), *name);
5198 bfd_set_error (bfd_error_bad_value);
5206 /* Merge non-visibility st_other attributes: local entry point. */
5209 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5210 const Elf_Internal_Sym *isym,
5211 bfd_boolean definition,
5212 bfd_boolean dynamic)
5214 if (definition && (!dynamic || !h->def_regular))
5215 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5216 | ELF_ST_VISIBILITY (h->other));
5219 /* Hook called on merging a symbol. We use this to clear "fake" since
5220 we now have a real symbol. */
5223 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5224 const Elf_Internal_Sym *isym,
5225 asection **psec ATTRIBUTE_UNUSED,
5226 bfd_boolean newdef ATTRIBUTE_UNUSED,
5227 bfd_boolean olddef ATTRIBUTE_UNUSED,
5228 bfd *oldbfd ATTRIBUTE_UNUSED,
5229 const asection *oldsec ATTRIBUTE_UNUSED)
5231 ((struct ppc_link_hash_entry *) h)->fake = 0;
5232 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5233 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5237 /* This function makes an old ABI object reference to ".bar" cause the
5238 inclusion of a new ABI object archive that defines "bar".
5239 NAME is a symbol defined in an archive. Return a symbol in the hash
5240 table that might be satisfied by the archive symbols. */
5242 static struct elf_link_hash_entry *
5243 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5244 struct bfd_link_info *info,
5247 struct elf_link_hash_entry *h;
5251 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5253 /* Don't return this sym if it is a fake function descriptor
5254 created by add_symbol_adjust. */
5255 && !((struct ppc_link_hash_entry *) h)->fake)
5261 len = strlen (name);
5262 dot_name = bfd_alloc (abfd, len + 2);
5263 if (dot_name == NULL)
5264 return (struct elf_link_hash_entry *) -1;
5266 memcpy (dot_name + 1, name, len + 1);
5267 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5268 bfd_release (abfd, dot_name);
5272 /* This function satisfies all old ABI object references to ".bar" if a
5273 new ABI object defines "bar". Well, at least, undefined dot symbols
5274 are made weak. This stops later archive searches from including an
5275 object if we already have a function descriptor definition. It also
5276 prevents the linker complaining about undefined symbols.
5277 We also check and correct mismatched symbol visibility here. The
5278 most restrictive visibility of the function descriptor and the
5279 function entry symbol is used. */
5282 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5284 struct ppc_link_hash_table *htab;
5285 struct ppc_link_hash_entry *fdh;
5287 if (eh->elf.root.type == bfd_link_hash_warning)
5288 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5290 if (eh->elf.root.type == bfd_link_hash_indirect)
5293 if (eh->elf.root.root.string[0] != '.')
5296 htab = ppc_hash_table (info);
5300 fdh = lookup_fdh (eh, htab);
5302 && !bfd_link_relocatable (info)
5303 && (eh->elf.root.type == bfd_link_hash_undefined
5304 || eh->elf.root.type == bfd_link_hash_undefweak)
5305 && eh->elf.ref_regular)
5307 /* Make an undefined function descriptor sym, in order to
5308 pull in an --as-needed shared lib. Archives are handled
5310 fdh = make_fdh (info, eh);
5317 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5318 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5320 /* Make both descriptor and entry symbol have the most
5321 constraining visibility of either symbol. */
5322 if (entry_vis < descr_vis)
5323 fdh->elf.other += entry_vis - descr_vis;
5324 else if (entry_vis > descr_vis)
5325 eh->elf.other += descr_vis - entry_vis;
5327 /* Propagate reference flags from entry symbol to function
5328 descriptor symbol. */
5329 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5330 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5331 fdh->elf.ref_regular |= eh->elf.ref_regular;
5332 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5334 if (!fdh->elf.forced_local
5335 && fdh->elf.dynindx == -1
5336 && fdh->elf.versioned != versioned_hidden
5337 && (bfd_link_dll (info)
5338 || fdh->elf.def_dynamic
5339 || fdh->elf.ref_dynamic)
5340 && (eh->elf.ref_regular
5341 || eh->elf.def_regular))
5343 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5351 /* Set up opd section info and abiversion for IBFD, and process list
5352 of dot-symbols we made in link_hash_newfunc. */
5355 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5357 struct ppc_link_hash_table *htab;
5358 struct ppc_link_hash_entry **p, *eh;
5359 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5361 if (opd != NULL && opd->size != 0)
5363 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5364 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5366 if (abiversion (ibfd) == 0)
5367 set_abiversion (ibfd, 1);
5368 else if (abiversion (ibfd) >= 2)
5370 /* xgettext:c-format */
5371 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5372 ibfd, abiversion (ibfd));
5373 bfd_set_error (bfd_error_bad_value);
5378 if (is_ppc64_elf (info->output_bfd))
5380 /* For input files without an explicit abiversion in e_flags
5381 we should have flagged any with symbol st_other bits set
5382 as ELFv1 and above flagged those with .opd as ELFv2.
5383 Set the output abiversion if not yet set, and for any input
5384 still ambiguous, take its abiversion from the output.
5385 Differences in ABI are reported later. */
5386 if (abiversion (info->output_bfd) == 0)
5387 set_abiversion (info->output_bfd, abiversion (ibfd));
5388 else if (abiversion (ibfd) == 0)
5389 set_abiversion (ibfd, abiversion (info->output_bfd));
5392 htab = ppc_hash_table (info);
5396 if (opd != NULL && opd->size != 0
5397 && (ibfd->flags & DYNAMIC) == 0
5398 && (opd->flags & SEC_RELOC) != 0
5399 && opd->reloc_count != 0
5400 && !bfd_is_abs_section (opd->output_section)
5401 && info->gc_sections)
5403 /* Garbage collection needs some extra help with .opd sections.
5404 We don't want to necessarily keep everything referenced by
5405 relocs in .opd, as that would keep all functions. Instead,
5406 if we reference an .opd symbol (a function descriptor), we
5407 want to keep the function code symbol's section. This is
5408 easy for global symbols, but for local syms we need to keep
5409 information about the associated function section. */
5411 asection **opd_sym_map;
5412 Elf_Internal_Shdr *symtab_hdr;
5413 Elf_Internal_Rela *relocs, *rel_end, *rel;
5415 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5416 opd_sym_map = bfd_zalloc (ibfd, amt);
5417 if (opd_sym_map == NULL)
5419 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5420 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5424 symtab_hdr = &elf_symtab_hdr (ibfd);
5425 rel_end = relocs + opd->reloc_count - 1;
5426 for (rel = relocs; rel < rel_end; rel++)
5428 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5429 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5431 if (r_type == R_PPC64_ADDR64
5432 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5433 && r_symndx < symtab_hdr->sh_info)
5435 Elf_Internal_Sym *isym;
5438 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5441 if (elf_section_data (opd)->relocs != relocs)
5446 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5447 if (s != NULL && s != opd)
5448 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5451 if (elf_section_data (opd)->relocs != relocs)
5455 p = &htab->dot_syms;
5456 while ((eh = *p) != NULL)
5459 if (&eh->elf == htab->elf.hgot)
5461 else if (htab->elf.hgot == NULL
5462 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5463 htab->elf.hgot = &eh->elf;
5464 else if (abiversion (ibfd) <= 1)
5466 htab->need_func_desc_adj = 1;
5467 if (!add_symbol_adjust (eh, info))
5470 p = &eh->u.next_dot_sym;
5475 /* Undo hash table changes when an --as-needed input file is determined
5476 not to be needed. */
5479 ppc64_elf_notice_as_needed (bfd *ibfd,
5480 struct bfd_link_info *info,
5481 enum notice_asneeded_action act)
5483 if (act == notice_not_needed)
5485 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5490 htab->dot_syms = NULL;
5492 return _bfd_elf_notice_as_needed (ibfd, info, act);
5495 /* If --just-symbols against a final linked binary, then assume we need
5496 toc adjusting stubs when calling functions defined there. */
5499 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5501 if ((sec->flags & SEC_CODE) != 0
5502 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5503 && is_ppc64_elf (sec->owner))
5505 if (abiversion (sec->owner) >= 2
5506 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5507 sec->has_toc_reloc = 1;
5509 _bfd_elf_link_just_syms (sec, info);
5512 static struct plt_entry **
5513 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5514 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5516 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5517 struct plt_entry **local_plt;
5518 unsigned char *local_got_tls_masks;
5520 if (local_got_ents == NULL)
5522 bfd_size_type size = symtab_hdr->sh_info;
5524 size *= (sizeof (*local_got_ents)
5525 + sizeof (*local_plt)
5526 + sizeof (*local_got_tls_masks));
5527 local_got_ents = bfd_zalloc (abfd, size);
5528 if (local_got_ents == NULL)
5530 elf_local_got_ents (abfd) = local_got_ents;
5533 if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5535 struct got_entry *ent;
5537 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5538 if (ent->addend == r_addend
5539 && ent->owner == abfd
5540 && ent->tls_type == tls_type)
5544 bfd_size_type amt = sizeof (*ent);
5545 ent = bfd_alloc (abfd, amt);
5548 ent->next = local_got_ents[r_symndx];
5549 ent->addend = r_addend;
5551 ent->tls_type = tls_type;
5552 ent->is_indirect = FALSE;
5553 ent->got.refcount = 0;
5554 local_got_ents[r_symndx] = ent;
5556 ent->got.refcount += 1;
5559 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5560 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5561 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5563 return local_plt + r_symndx;
5567 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5569 struct plt_entry *ent;
5571 for (ent = *plist; ent != NULL; ent = ent->next)
5572 if (ent->addend == addend)
5576 bfd_size_type amt = sizeof (*ent);
5577 ent = bfd_alloc (abfd, amt);
5581 ent->addend = addend;
5582 ent->plt.refcount = 0;
5585 ent->plt.refcount += 1;
5590 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5592 return (r_type == R_PPC64_REL24
5593 || r_type == R_PPC64_REL24_NOTOC
5594 || r_type == R_PPC64_REL14
5595 || r_type == R_PPC64_REL14_BRTAKEN
5596 || r_type == R_PPC64_REL14_BRNTAKEN
5597 || r_type == R_PPC64_ADDR24
5598 || r_type == R_PPC64_ADDR14
5599 || r_type == R_PPC64_ADDR14_BRTAKEN
5600 || r_type == R_PPC64_ADDR14_BRNTAKEN
5601 || r_type == R_PPC64_PLTCALL);
5604 /* Relocs on inline plt call sequence insns prior to the call. */
5607 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5609 return (r_type == R_PPC64_PLT16_HA
5610 || r_type == R_PPC64_PLT16_HI
5611 || r_type == R_PPC64_PLT16_LO
5612 || r_type == R_PPC64_PLT16_LO_DS
5613 || r_type == R_PPC64_PLTSEQ);
5616 /* Look through the relocs for a section during the first phase, and
5617 calculate needed space in the global offset table, procedure
5618 linkage table, and dynamic reloc sections. */
5621 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5622 asection *sec, const Elf_Internal_Rela *relocs)
5624 struct ppc_link_hash_table *htab;
5625 Elf_Internal_Shdr *symtab_hdr;
5626 struct elf_link_hash_entry **sym_hashes;
5627 const Elf_Internal_Rela *rel;
5628 const Elf_Internal_Rela *rel_end;
5630 struct elf_link_hash_entry *tga, *dottga;
5633 if (bfd_link_relocatable (info))
5636 /* Don't do anything special with non-loaded, non-alloced sections.
5637 In particular, any relocs in such sections should not affect GOT
5638 and PLT reference counting (ie. we don't allow them to create GOT
5639 or PLT entries), there's no possibility or desire to optimize TLS
5640 relocs, and there's not much point in propagating relocs to shared
5641 libs that the dynamic linker won't relocate. */
5642 if ((sec->flags & SEC_ALLOC) == 0)
5645 BFD_ASSERT (is_ppc64_elf (abfd));
5647 htab = ppc_hash_table (info);
5651 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5652 FALSE, FALSE, TRUE);
5653 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5654 FALSE, FALSE, TRUE);
5655 symtab_hdr = &elf_symtab_hdr (abfd);
5656 sym_hashes = elf_sym_hashes (abfd);
5658 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5659 rel_end = relocs + sec->reloc_count;
5660 for (rel = relocs; rel < rel_end; rel++)
5662 unsigned long r_symndx;
5663 struct elf_link_hash_entry *h;
5664 enum elf_ppc64_reloc_type r_type;
5666 struct _ppc64_elf_section_data *ppc64_sec;
5667 struct plt_entry **ifunc, **plt_list;
5669 r_symndx = ELF64_R_SYM (rel->r_info);
5670 if (r_symndx < symtab_hdr->sh_info)
5674 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5675 h = elf_follow_link (h);
5677 if (h == htab->elf.hgot)
5678 sec->has_toc_reloc = 1;
5685 if (h->type == STT_GNU_IFUNC)
5688 ifunc = &h->plt.plist;
5693 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5698 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5700 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5702 NON_GOT | PLT_IFUNC);
5708 r_type = ELF64_R_TYPE (rel->r_info);
5713 /* These special tls relocs tie a call to __tls_get_addr with
5714 its parameter symbol. */
5716 ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5718 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5720 NON_GOT | TLS_TLS | TLS_MARK))
5722 sec->has_tls_reloc = 1;
5725 case R_PPC64_GOT_TLSLD16:
5726 case R_PPC64_GOT_TLSLD16_LO:
5727 case R_PPC64_GOT_TLSLD16_HI:
5728 case R_PPC64_GOT_TLSLD16_HA:
5729 tls_type = TLS_TLS | TLS_LD;
5732 case R_PPC64_GOT_TLSGD16:
5733 case R_PPC64_GOT_TLSGD16_LO:
5734 case R_PPC64_GOT_TLSGD16_HI:
5735 case R_PPC64_GOT_TLSGD16_HA:
5736 tls_type = TLS_TLS | TLS_GD;
5739 case R_PPC64_GOT_TPREL16_DS:
5740 case R_PPC64_GOT_TPREL16_LO_DS:
5741 case R_PPC64_GOT_TPREL16_HI:
5742 case R_PPC64_GOT_TPREL16_HA:
5743 if (bfd_link_dll (info))
5744 info->flags |= DF_STATIC_TLS;
5745 tls_type = TLS_TLS | TLS_TPREL;
5748 case R_PPC64_GOT_DTPREL16_DS:
5749 case R_PPC64_GOT_DTPREL16_LO_DS:
5750 case R_PPC64_GOT_DTPREL16_HI:
5751 case R_PPC64_GOT_DTPREL16_HA:
5752 tls_type = TLS_TLS | TLS_DTPREL;
5754 sec->has_tls_reloc = 1;
5758 case R_PPC64_GOT16_DS:
5759 case R_PPC64_GOT16_HA:
5760 case R_PPC64_GOT16_HI:
5761 case R_PPC64_GOT16_LO:
5762 case R_PPC64_GOT16_LO_DS:
5763 /* This symbol requires a global offset table entry. */
5764 sec->has_toc_reloc = 1;
5765 if (r_type == R_PPC64_GOT_TLSLD16
5766 || r_type == R_PPC64_GOT_TLSGD16
5767 || r_type == R_PPC64_GOT_TPREL16_DS
5768 || r_type == R_PPC64_GOT_DTPREL16_DS
5769 || r_type == R_PPC64_GOT16
5770 || r_type == R_PPC64_GOT16_DS)
5772 htab->do_multi_toc = 1;
5773 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5776 if (ppc64_elf_tdata (abfd)->got == NULL
5777 && !create_got_section (abfd, info))
5782 struct ppc_link_hash_entry *eh;
5783 struct got_entry *ent;
5785 eh = (struct ppc_link_hash_entry *) h;
5786 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5787 if (ent->addend == rel->r_addend
5788 && ent->owner == abfd
5789 && ent->tls_type == tls_type)
5793 bfd_size_type amt = sizeof (*ent);
5794 ent = bfd_alloc (abfd, amt);
5797 ent->next = eh->elf.got.glist;
5798 ent->addend = rel->r_addend;
5800 ent->tls_type = tls_type;
5801 ent->is_indirect = FALSE;
5802 ent->got.refcount = 0;
5803 eh->elf.got.glist = ent;
5805 ent->got.refcount += 1;
5806 eh->tls_mask |= tls_type;
5809 /* This is a global offset table entry for a local symbol. */
5810 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5811 rel->r_addend, tls_type))
5814 /* We may also need a plt entry if the symbol turns out to be
5816 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5818 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5823 case R_PPC64_PLT16_HA:
5824 case R_PPC64_PLT16_HI:
5825 case R_PPC64_PLT16_LO:
5826 case R_PPC64_PLT16_LO_DS:
5829 /* This symbol requires a procedure linkage table entry. */
5834 if (h->root.root.string[0] == '.'
5835 && h->root.root.string[1] != '\0')
5836 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5837 ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5838 plt_list = &h->plt.plist;
5840 if (plt_list == NULL)
5841 plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5843 NON_GOT | PLT_KEEP);
5844 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5848 /* The following relocations don't need to propagate the
5849 relocation if linking a shared object since they are
5850 section relative. */
5851 case R_PPC64_SECTOFF:
5852 case R_PPC64_SECTOFF_LO:
5853 case R_PPC64_SECTOFF_HI:
5854 case R_PPC64_SECTOFF_HA:
5855 case R_PPC64_SECTOFF_DS:
5856 case R_PPC64_SECTOFF_LO_DS:
5857 case R_PPC64_DTPREL16:
5858 case R_PPC64_DTPREL16_LO:
5859 case R_PPC64_DTPREL16_HI:
5860 case R_PPC64_DTPREL16_HA:
5861 case R_PPC64_DTPREL16_DS:
5862 case R_PPC64_DTPREL16_LO_DS:
5863 case R_PPC64_DTPREL16_HIGH:
5864 case R_PPC64_DTPREL16_HIGHA:
5865 case R_PPC64_DTPREL16_HIGHER:
5866 case R_PPC64_DTPREL16_HIGHERA:
5867 case R_PPC64_DTPREL16_HIGHEST:
5868 case R_PPC64_DTPREL16_HIGHESTA:
5873 case R_PPC64_REL16_LO:
5874 case R_PPC64_REL16_HI:
5875 case R_PPC64_REL16_HA:
5876 case R_PPC64_REL16DX_HA:
5879 /* Not supported as a dynamic relocation. */
5880 case R_PPC64_ADDR64_LOCAL:
5881 if (bfd_link_pic (info))
5883 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5885 /* xgettext:c-format */
5886 info->callbacks->einfo (_("%H: %s reloc unsupported "
5887 "in shared libraries and PIEs\n"),
5888 abfd, sec, rel->r_offset,
5889 ppc64_elf_howto_table[r_type]->name);
5890 bfd_set_error (bfd_error_bad_value);
5896 case R_PPC64_TOC16_DS:
5897 htab->do_multi_toc = 1;
5898 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5900 case R_PPC64_TOC16_LO:
5901 case R_PPC64_TOC16_HI:
5902 case R_PPC64_TOC16_HA:
5903 case R_PPC64_TOC16_LO_DS:
5904 sec->has_toc_reloc = 1;
5911 /* This relocation describes the C++ object vtable hierarchy.
5912 Reconstruct it for later use during GC. */
5913 case R_PPC64_GNU_VTINHERIT:
5914 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5918 /* This relocation describes which C++ vtable entries are actually
5919 used. Record for later use during GC. */
5920 case R_PPC64_GNU_VTENTRY:
5921 BFD_ASSERT (h != NULL);
5923 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5928 case R_PPC64_REL14_BRTAKEN:
5929 case R_PPC64_REL14_BRNTAKEN:
5931 asection *dest = NULL;
5933 /* Heuristic: If jumping outside our section, chances are
5934 we are going to need a stub. */
5937 /* If the sym is weak it may be overridden later, so
5938 don't assume we know where a weak sym lives. */
5939 if (h->root.type == bfd_link_hash_defined)
5940 dest = h->root.u.def.section;
5944 Elf_Internal_Sym *isym;
5946 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5951 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5955 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5959 case R_PPC64_PLTCALL:
5960 ppc64_elf_section_data (sec)->has_pltcall = 1;
5964 case R_PPC64_REL24_NOTOC:
5970 if (h->root.root.string[0] == '.'
5971 && h->root.root.string[1] != '\0')
5972 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5974 if (h == tga || h == dottga)
5976 sec->has_tls_reloc = 1;
5978 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5979 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5980 /* We have a new-style __tls_get_addr call with
5984 /* Mark this section as having an old-style call. */
5985 sec->has_tls_get_addr_call = 1;
5987 plt_list = &h->plt.plist;
5990 /* We may need a .plt entry if the function this reloc
5991 refers to is in a shared lib. */
5993 && !update_plt_info (abfd, plt_list, rel->r_addend))
5997 case R_PPC64_ADDR14:
5998 case R_PPC64_ADDR14_BRNTAKEN:
5999 case R_PPC64_ADDR14_BRTAKEN:
6000 case R_PPC64_ADDR24:
6003 case R_PPC64_TPREL64:
6004 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
6005 if (bfd_link_dll (info))
6006 info->flags |= DF_STATIC_TLS;
6009 case R_PPC64_DTPMOD64:
6010 if (rel + 1 < rel_end
6011 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
6012 && rel[1].r_offset == rel->r_offset + 8)
6013 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
6015 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
6018 case R_PPC64_DTPREL64:
6019 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
6021 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
6022 && rel[-1].r_offset == rel->r_offset - 8)
6023 /* This is the second reloc of a dtpmod, dtprel pair.
6024 Don't mark with TLS_DTPREL. */
6028 sec->has_tls_reloc = 1;
6031 struct ppc_link_hash_entry *eh;
6032 eh = (struct ppc_link_hash_entry *) h;
6033 eh->tls_mask |= tls_type;
6036 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
6037 rel->r_addend, tls_type))
6040 ppc64_sec = ppc64_elf_section_data (sec);
6041 if (ppc64_sec->sec_type != sec_toc)
6045 /* One extra to simplify get_tls_mask. */
6046 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
6047 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
6048 if (ppc64_sec->u.toc.symndx == NULL)
6050 amt = sec->size * sizeof (bfd_vma) / 8;
6051 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
6052 if (ppc64_sec->u.toc.add == NULL)
6054 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
6055 ppc64_sec->sec_type = sec_toc;
6057 BFD_ASSERT (rel->r_offset % 8 == 0);
6058 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
6059 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
6061 /* Mark the second slot of a GD or LD entry.
6062 -1 to indicate GD and -2 to indicate LD. */
6063 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
6064 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
6065 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
6066 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
6069 case R_PPC64_TPREL16:
6070 case R_PPC64_TPREL16_LO:
6071 case R_PPC64_TPREL16_HI:
6072 case R_PPC64_TPREL16_HA:
6073 case R_PPC64_TPREL16_DS:
6074 case R_PPC64_TPREL16_LO_DS:
6075 case R_PPC64_TPREL16_HIGH:
6076 case R_PPC64_TPREL16_HIGHA:
6077 case R_PPC64_TPREL16_HIGHER:
6078 case R_PPC64_TPREL16_HIGHERA:
6079 case R_PPC64_TPREL16_HIGHEST:
6080 case R_PPC64_TPREL16_HIGHESTA:
6081 if (bfd_link_dll (info))
6082 info->flags |= DF_STATIC_TLS;
6085 case R_PPC64_ADDR64:
6087 && rel + 1 < rel_end
6088 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
6091 ((struct ppc_link_hash_entry *) h)->is_func = 1;
6095 case R_PPC64_ADDR16:
6096 case R_PPC64_ADDR16_DS:
6097 case R_PPC64_ADDR16_HA:
6098 case R_PPC64_ADDR16_HI:
6099 case R_PPC64_ADDR16_HIGH:
6100 case R_PPC64_ADDR16_HIGHA:
6101 case R_PPC64_ADDR16_HIGHER:
6102 case R_PPC64_ADDR16_HIGHERA:
6103 case R_PPC64_ADDR16_HIGHEST:
6104 case R_PPC64_ADDR16_HIGHESTA:
6105 case R_PPC64_ADDR16_LO:
6106 case R_PPC64_ADDR16_LO_DS:
6107 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6108 && rel->r_addend == 0)
6110 /* We may need a .plt entry if this reloc refers to a
6111 function in a shared lib. */
6112 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
6114 h->pointer_equality_needed = 1;
6121 case R_PPC64_ADDR32:
6122 case R_PPC64_UADDR16:
6123 case R_PPC64_UADDR32:
6124 case R_PPC64_UADDR64:
6126 if (h != NULL && !bfd_link_pic (info))
6127 /* We may need a copy reloc. */
6130 /* Don't propagate .opd relocs. */
6131 if (NO_OPD_RELOCS && is_opd)
6134 /* If we are creating a shared library, and this is a reloc
6135 against a global symbol, or a non PC relative reloc
6136 against a local symbol, then we need to copy the reloc
6137 into the shared library. However, if we are linking with
6138 -Bsymbolic, we do not need to copy a reloc against a
6139 global symbol which is defined in an object we are
6140 including in the link (i.e., DEF_REGULAR is set). At
6141 this point we have not seen all the input files, so it is
6142 possible that DEF_REGULAR is not set now but will be set
6143 later (it is never cleared). In case of a weak definition,
6144 DEF_REGULAR may be cleared later by a strong definition in
6145 a shared library. We account for that possibility below by
6146 storing information in the dyn_relocs field of the hash
6147 table entry. A similar situation occurs when creating
6148 shared libraries and symbol visibility changes render the
6151 If on the other hand, we are creating an executable, we
6152 may need to keep relocations for symbols satisfied by a
6153 dynamic library if we manage to avoid copy relocs for the
6156 if ((bfd_link_pic (info)
6157 && (must_be_dyn_reloc (info, r_type)
6159 && (!SYMBOLIC_BIND (info, h)
6160 || h->root.type == bfd_link_hash_defweak
6161 || !h->def_regular))))
6162 || (ELIMINATE_COPY_RELOCS
6163 && !bfd_link_pic (info)
6165 && (h->root.type == bfd_link_hash_defweak
6166 || !h->def_regular))
6167 || (!bfd_link_pic (info)
6170 /* We must copy these reloc types into the output file.
6171 Create a reloc section in dynobj and make room for
6175 sreloc = _bfd_elf_make_dynamic_reloc_section
6176 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6182 /* If this is a global symbol, we count the number of
6183 relocations we need for this symbol. */
6186 struct elf_dyn_relocs *p;
6187 struct elf_dyn_relocs **head;
6189 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6191 if (p == NULL || p->sec != sec)
6193 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6203 if (!must_be_dyn_reloc (info, r_type))
6208 /* Track dynamic relocs needed for local syms too.
6209 We really need local syms available to do this
6211 struct ppc_dyn_relocs *p;
6212 struct ppc_dyn_relocs **head;
6213 bfd_boolean is_ifunc;
6216 Elf_Internal_Sym *isym;
6218 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6223 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6227 vpp = &elf_section_data (s)->local_dynrel;
6228 head = (struct ppc_dyn_relocs **) vpp;
6229 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6231 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6233 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6235 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6241 p->ifunc = is_ifunc;
6257 /* Merge backend specific data from an object file to the output
6258 object file when linking. */
6261 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6263 bfd *obfd = info->output_bfd;
6264 unsigned long iflags, oflags;
6266 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6269 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6272 if (!_bfd_generic_verify_endian_match (ibfd, info))
6275 iflags = elf_elfheader (ibfd)->e_flags;
6276 oflags = elf_elfheader (obfd)->e_flags;
6278 if (iflags & ~EF_PPC64_ABI)
6281 /* xgettext:c-format */
6282 (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6283 bfd_set_error (bfd_error_bad_value);
6286 else if (iflags != oflags && iflags != 0)
6289 /* xgettext:c-format */
6290 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6291 ibfd, iflags, oflags);
6292 bfd_set_error (bfd_error_bad_value);
6296 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
6299 /* Merge Tag_compatibility attributes and any common GNU ones. */
6300 return _bfd_elf_merge_object_attributes (ibfd, info);
6304 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6306 /* Print normal ELF private data. */
6307 _bfd_elf_print_private_bfd_data (abfd, ptr);
6309 if (elf_elfheader (abfd)->e_flags != 0)
6313 fprintf (file, _("private flags = 0x%lx:"),
6314 elf_elfheader (abfd)->e_flags);
6316 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6317 fprintf (file, _(" [abiv%ld]"),
6318 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6325 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6326 of the code entry point, and its section, which must be in the same
6327 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6330 opd_entry_value (asection *opd_sec,
6332 asection **code_sec,
6334 bfd_boolean in_code_sec)
6336 bfd *opd_bfd = opd_sec->owner;
6337 Elf_Internal_Rela *relocs;
6338 Elf_Internal_Rela *lo, *hi, *look;
6341 /* No relocs implies we are linking a --just-symbols object, or looking
6342 at a final linked executable with addr2line or somesuch. */
6343 if (opd_sec->reloc_count == 0)
6345 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6347 if (contents == NULL)
6349 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6350 return (bfd_vma) -1;
6351 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6354 /* PR 17512: file: 64b9dfbb. */
6355 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6356 return (bfd_vma) -1;
6358 val = bfd_get_64 (opd_bfd, contents + offset);
6359 if (code_sec != NULL)
6361 asection *sec, *likely = NULL;
6367 && val < sec->vma + sec->size)
6373 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6375 && (sec->flags & SEC_LOAD) != 0
6376 && (sec->flags & SEC_ALLOC) != 0)
6381 if (code_off != NULL)
6382 *code_off = val - likely->vma;
6388 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6390 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6392 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6393 /* PR 17512: file: df8e1fd6. */
6395 return (bfd_vma) -1;
6397 /* Go find the opd reloc at the sym address. */
6399 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6403 look = lo + (hi - lo) / 2;
6404 if (look->r_offset < offset)
6406 else if (look->r_offset > offset)
6410 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6412 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6413 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6415 unsigned long symndx = ELF64_R_SYM (look->r_info);
6416 asection *sec = NULL;
6418 if (symndx >= symtab_hdr->sh_info
6419 && elf_sym_hashes (opd_bfd) != NULL)
6421 struct elf_link_hash_entry **sym_hashes;
6422 struct elf_link_hash_entry *rh;
6424 sym_hashes = elf_sym_hashes (opd_bfd);
6425 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6428 rh = elf_follow_link (rh);
6429 if (rh->root.type != bfd_link_hash_defined
6430 && rh->root.type != bfd_link_hash_defweak)
6432 if (rh->root.u.def.section->owner == opd_bfd)
6434 val = rh->root.u.def.value;
6435 sec = rh->root.u.def.section;
6442 Elf_Internal_Sym *sym;
6444 if (symndx < symtab_hdr->sh_info)
6446 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6449 size_t symcnt = symtab_hdr->sh_info;
6450 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6455 symtab_hdr->contents = (bfd_byte *) sym;
6461 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6467 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6470 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6471 val = sym->st_value;
6474 val += look->r_addend;
6475 if (code_off != NULL)
6477 if (code_sec != NULL)
6479 if (in_code_sec && *code_sec != sec)
6484 if (sec->output_section != NULL)
6485 val += sec->output_section->vma + sec->output_offset;
6494 /* If the ELF symbol SYM might be a function in SEC, return the
6495 function size and set *CODE_OFF to the function's entry point,
6496 otherwise return zero. */
6498 static bfd_size_type
6499 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6504 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6505 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6509 if (!(sym->flags & BSF_SYNTHETIC))
6510 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6512 if (strcmp (sym->section->name, ".opd") == 0)
6514 struct _opd_sec_data *opd = get_opd_info (sym->section);
6515 bfd_vma symval = sym->value;
6518 && opd->adjust != NULL
6519 && elf_section_data (sym->section)->relocs != NULL)
6521 /* opd_entry_value will use cached relocs that have been
6522 adjusted, but with raw symbols. That means both local
6523 and global symbols need adjusting. */
6524 long adjust = opd->adjust[OPD_NDX (symval)];
6530 if (opd_entry_value (sym->section, symval,
6531 &sec, code_off, TRUE) == (bfd_vma) -1)
6533 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6534 symbol. This size has nothing to do with the code size of the
6535 function, which is what we're supposed to return, but the
6536 code size isn't available without looking up the dot-sym.
6537 However, doing that would be a waste of time particularly
6538 since elf_find_function will look at the dot-sym anyway.
6539 Now, elf_find_function will keep the largest size of any
6540 function sym found at the code address of interest, so return
6541 1 here to avoid it incorrectly caching a larger function size
6542 for a small function. This does mean we return the wrong
6543 size for a new-ABI function of size 24, but all that does is
6544 disable caching for such functions. */
6550 if (sym->section != sec)
6552 *code_off = sym->value;
6559 /* Return true if symbol is a strong function defined in an ELFv2
6560 object with st_other localentry bits of zero, ie. its local entry
6561 point coincides with its global entry point. */
6564 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6567 && h->type == STT_FUNC
6568 && h->root.type == bfd_link_hash_defined
6569 && (STO_PPC64_LOCAL_MASK & h->other) == 0
6570 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6571 && is_ppc64_elf (h->root.u.def.section->owner)
6572 && abiversion (h->root.u.def.section->owner) >= 2);
6575 /* Return true if symbol is defined in a regular object file. */
6578 is_static_defined (struct elf_link_hash_entry *h)
6580 return ((h->root.type == bfd_link_hash_defined
6581 || h->root.type == bfd_link_hash_defweak)
6582 && h->root.u.def.section != NULL
6583 && h->root.u.def.section->output_section != NULL);
6586 /* If FDH is a function descriptor symbol, return the associated code
6587 entry symbol if it is defined. Return NULL otherwise. */
6589 static struct ppc_link_hash_entry *
6590 defined_code_entry (struct ppc_link_hash_entry *fdh)
6592 if (fdh->is_func_descriptor)
6594 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6595 if (fh->elf.root.type == bfd_link_hash_defined
6596 || fh->elf.root.type == bfd_link_hash_defweak)
6602 /* If FH is a function code entry symbol, return the associated
6603 function descriptor symbol if it is defined. Return NULL otherwise. */
6605 static struct ppc_link_hash_entry *
6606 defined_func_desc (struct ppc_link_hash_entry *fh)
6609 && fh->oh->is_func_descriptor)
6611 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6612 if (fdh->elf.root.type == bfd_link_hash_defined
6613 || fdh->elf.root.type == bfd_link_hash_defweak)
6619 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6621 /* Garbage collect sections, after first dealing with dot-symbols. */
6624 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6626 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6628 if (htab != NULL && htab->need_func_desc_adj)
6630 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6631 htab->need_func_desc_adj = 0;
6633 return bfd_elf_gc_sections (abfd, info);
6636 /* Mark all our entry sym sections, both opd and code section. */
6639 ppc64_elf_gc_keep (struct bfd_link_info *info)
6641 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6642 struct bfd_sym_chain *sym;
6647 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6649 struct ppc_link_hash_entry *eh, *fh;
6652 eh = (struct ppc_link_hash_entry *)
6653 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6656 if (eh->elf.root.type != bfd_link_hash_defined
6657 && eh->elf.root.type != bfd_link_hash_defweak)
6660 fh = defined_code_entry (eh);
6663 sec = fh->elf.root.u.def.section;
6664 sec->flags |= SEC_KEEP;
6666 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6667 && opd_entry_value (eh->elf.root.u.def.section,
6668 eh->elf.root.u.def.value,
6669 &sec, NULL, FALSE) != (bfd_vma) -1)
6670 sec->flags |= SEC_KEEP;
6672 sec = eh->elf.root.u.def.section;
6673 sec->flags |= SEC_KEEP;
6677 /* Mark sections containing dynamically referenced symbols. When
6678 building shared libraries, we must assume that any visible symbol is
6682 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6684 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6685 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6686 struct ppc_link_hash_entry *fdh;
6687 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6689 /* Dynamic linking info is on the func descriptor sym. */
6690 fdh = defined_func_desc (eh);
6694 if ((eh->elf.root.type == bfd_link_hash_defined
6695 || eh->elf.root.type == bfd_link_hash_defweak)
6696 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6697 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6698 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6699 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6700 && (!bfd_link_executable (info)
6701 || info->gc_keep_exported
6702 || info->export_dynamic
6705 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6706 && (eh->elf.versioned >= versioned
6707 || !bfd_hide_sym_by_version (info->version_info,
6708 eh->elf.root.root.string)))))
6711 struct ppc_link_hash_entry *fh;
6713 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6715 /* Function descriptor syms cause the associated
6716 function code sym section to be marked. */
6717 fh = defined_code_entry (eh);
6720 code_sec = fh->elf.root.u.def.section;
6721 code_sec->flags |= SEC_KEEP;
6723 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6724 && opd_entry_value (eh->elf.root.u.def.section,
6725 eh->elf.root.u.def.value,
6726 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6727 code_sec->flags |= SEC_KEEP;
6733 /* Return the section that should be marked against GC for a given
6737 ppc64_elf_gc_mark_hook (asection *sec,
6738 struct bfd_link_info *info,
6739 Elf_Internal_Rela *rel,
6740 struct elf_link_hash_entry *h,
6741 Elf_Internal_Sym *sym)
6745 /* Syms return NULL if we're marking .opd, so we avoid marking all
6746 function sections, as all functions are referenced in .opd. */
6748 if (get_opd_info (sec) != NULL)
6753 enum elf_ppc64_reloc_type r_type;
6754 struct ppc_link_hash_entry *eh, *fh, *fdh;
6756 r_type = ELF64_R_TYPE (rel->r_info);
6759 case R_PPC64_GNU_VTINHERIT:
6760 case R_PPC64_GNU_VTENTRY:
6764 switch (h->root.type)
6766 case bfd_link_hash_defined:
6767 case bfd_link_hash_defweak:
6768 eh = (struct ppc_link_hash_entry *) h;
6769 fdh = defined_func_desc (eh);
6772 /* -mcall-aixdesc code references the dot-symbol on
6773 a call reloc. Mark the function descriptor too
6774 against garbage collection. */
6776 if (fdh->elf.is_weakalias)
6777 weakdef (&fdh->elf)->mark = 1;
6781 /* Function descriptor syms cause the associated
6782 function code sym section to be marked. */
6783 fh = defined_code_entry (eh);
6786 /* They also mark their opd section. */
6787 eh->elf.root.u.def.section->gc_mark = 1;
6789 rsec = fh->elf.root.u.def.section;
6791 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6792 && opd_entry_value (eh->elf.root.u.def.section,
6793 eh->elf.root.u.def.value,
6794 &rsec, NULL, FALSE) != (bfd_vma) -1)
6795 eh->elf.root.u.def.section->gc_mark = 1;
6797 rsec = h->root.u.def.section;
6800 case bfd_link_hash_common:
6801 rsec = h->root.u.c.p->section;
6805 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6811 struct _opd_sec_data *opd;
6813 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6814 opd = get_opd_info (rsec);
6815 if (opd != NULL && opd->func_sec != NULL)
6819 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6826 /* The maximum size of .sfpr. */
6827 #define SFPR_MAX (218*4)
6829 struct sfpr_def_parms
6831 const char name[12];
6832 unsigned char lo, hi;
6833 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6834 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6837 /* Auto-generate _save*, _rest* functions in .sfpr.
6838 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6842 sfpr_define (struct bfd_link_info *info,
6843 const struct sfpr_def_parms *parm,
6846 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6848 size_t len = strlen (parm->name);
6849 bfd_boolean writing = FALSE;
6855 memcpy (sym, parm->name, len);
6858 for (i = parm->lo; i <= parm->hi; i++)
6860 struct ppc_link_hash_entry *h;
6862 sym[len + 0] = i / 10 + '0';
6863 sym[len + 1] = i % 10 + '0';
6864 h = (struct ppc_link_hash_entry *)
6865 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6866 if (stub_sec != NULL)
6869 && h->elf.root.type == bfd_link_hash_defined
6870 && h->elf.root.u.def.section == htab->sfpr)
6872 struct elf_link_hash_entry *s;
6874 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6875 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6878 if (s->root.type == bfd_link_hash_new
6879 || (s->root.type = bfd_link_hash_defined
6880 && s->root.u.def.section == stub_sec))
6882 s->root.type = bfd_link_hash_defined;
6883 s->root.u.def.section = stub_sec;
6884 s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6885 + h->elf.root.u.def.value);
6888 s->ref_regular_nonweak = 1;
6889 s->forced_local = 1;
6891 s->root.linker_def = 1;
6899 if (!h->elf.def_regular)
6901 h->elf.root.type = bfd_link_hash_defined;
6902 h->elf.root.u.def.section = htab->sfpr;
6903 h->elf.root.u.def.value = htab->sfpr->size;
6904 h->elf.type = STT_FUNC;
6905 h->elf.def_regular = 1;
6907 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6909 if (htab->sfpr->contents == NULL)
6911 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6912 if (htab->sfpr->contents == NULL)
6919 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6921 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6923 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6924 htab->sfpr->size = p - htab->sfpr->contents;
6932 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6934 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6939 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6941 p = savegpr0 (abfd, p, r);
6942 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6944 bfd_put_32 (abfd, BLR, p);
6949 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6951 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6956 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6958 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6960 p = restgpr0 (abfd, p, r);
6961 bfd_put_32 (abfd, MTLR_R0, p);
6965 p = restgpr0 (abfd, p, 30);
6966 p = restgpr0 (abfd, p, 31);
6968 bfd_put_32 (abfd, BLR, p);
6973 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6975 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6980 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6982 p = savegpr1 (abfd, p, r);
6983 bfd_put_32 (abfd, BLR, p);
6988 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6990 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6995 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6997 p = restgpr1 (abfd, p, r);
6998 bfd_put_32 (abfd, BLR, p);
7003 savefpr (bfd *abfd, bfd_byte *p, int r)
7005 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7010 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
7012 p = savefpr (abfd, p, r);
7013 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
7015 bfd_put_32 (abfd, BLR, p);
7020 restfpr (bfd *abfd, bfd_byte *p, int r)
7022 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7027 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
7029 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
7031 p = restfpr (abfd, p, r);
7032 bfd_put_32 (abfd, MTLR_R0, p);
7036 p = restfpr (abfd, p, 30);
7037 p = restfpr (abfd, p, 31);
7039 bfd_put_32 (abfd, BLR, p);
7044 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7046 p = savefpr (abfd, p, r);
7047 bfd_put_32 (abfd, BLR, p);
7052 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7054 p = restfpr (abfd, p, r);
7055 bfd_put_32 (abfd, BLR, p);
7060 savevr (bfd *abfd, bfd_byte *p, int r)
7062 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7064 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7069 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7071 p = savevr (abfd, p, r);
7072 bfd_put_32 (abfd, BLR, p);
7077 restvr (bfd *abfd, bfd_byte *p, int r)
7079 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7081 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7086 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7088 p = restvr (abfd, p, r);
7089 bfd_put_32 (abfd, BLR, p);
7093 /* Called via elf_link_hash_traverse to transfer dynamic linking
7094 information on function code symbol entries to their corresponding
7095 function descriptor symbol entries. */
7098 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7100 struct bfd_link_info *info;
7101 struct ppc_link_hash_table *htab;
7102 struct ppc_link_hash_entry *fh;
7103 struct ppc_link_hash_entry *fdh;
7104 bfd_boolean force_local;
7106 fh = (struct ppc_link_hash_entry *) h;
7107 if (fh->elf.root.type == bfd_link_hash_indirect)
7113 if (fh->elf.root.root.string[0] != '.'
7114 || fh->elf.root.root.string[1] == '\0')
7118 htab = ppc_hash_table (info);
7122 /* Find the corresponding function descriptor symbol. */
7123 fdh = lookup_fdh (fh, htab);
7125 /* Resolve undefined references to dot-symbols as the value
7126 in the function descriptor, if we have one in a regular object.
7127 This is to satisfy cases like ".quad .foo". Calls to functions
7128 in dynamic objects are handled elsewhere. */
7129 if ((fh->elf.root.type == bfd_link_hash_undefined
7130 || fh->elf.root.type == bfd_link_hash_undefweak)
7131 && (fdh->elf.root.type == bfd_link_hash_defined
7132 || fdh->elf.root.type == bfd_link_hash_defweak)
7133 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7134 && opd_entry_value (fdh->elf.root.u.def.section,
7135 fdh->elf.root.u.def.value,
7136 &fh->elf.root.u.def.section,
7137 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7139 fh->elf.root.type = fdh->elf.root.type;
7140 fh->elf.forced_local = 1;
7141 fh->elf.def_regular = fdh->elf.def_regular;
7142 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7145 if (!fh->elf.dynamic)
7147 struct plt_entry *ent;
7149 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7150 if (ent->plt.refcount > 0)
7156 /* Create a descriptor as undefined if necessary. */
7158 && !bfd_link_executable (info)
7159 && (fh->elf.root.type == bfd_link_hash_undefined
7160 || fh->elf.root.type == bfd_link_hash_undefweak))
7162 fdh = make_fdh (info, fh);
7167 /* We can't support overriding of symbols on a fake descriptor. */
7170 && (fh->elf.root.type == bfd_link_hash_defined
7171 || fh->elf.root.type == bfd_link_hash_defweak))
7172 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7174 /* Transfer dynamic linking information to the function descriptor. */
7177 fdh->elf.ref_regular |= fh->elf.ref_regular;
7178 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7179 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7180 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7181 fdh->elf.dynamic |= fh->elf.dynamic;
7182 fdh->elf.needs_plt |= (fh->elf.needs_plt
7183 || fh->elf.type == STT_FUNC
7184 || fh->elf.type == STT_GNU_IFUNC);
7185 move_plt_plist (fh, fdh);
7187 if (!fdh->elf.forced_local
7188 && fh->elf.dynindx != -1)
7189 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7193 /* Now that the info is on the function descriptor, clear the
7194 function code sym info. Any function code syms for which we
7195 don't have a definition in a regular file, we force local.
7196 This prevents a shared library from exporting syms that have
7197 been imported from another library. Function code syms that
7198 are really in the library we must leave global to prevent the
7199 linker dragging in a definition from a static library. */
7200 force_local = (!fh->elf.def_regular
7202 || !fdh->elf.def_regular
7203 || fdh->elf.forced_local);
7204 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7209 static const struct sfpr_def_parms save_res_funcs[] =
7211 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7212 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7213 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7214 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7215 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7216 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7217 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7218 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7219 { "._savef", 14, 31, savefpr, savefpr1_tail },
7220 { "._restf", 14, 31, restfpr, restfpr1_tail },
7221 { "_savevr_", 20, 31, savevr, savevr_tail },
7222 { "_restvr_", 20, 31, restvr, restvr_tail }
7225 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7226 this hook to a) provide some gcc support functions, and b) transfer
7227 dynamic linking information gathered so far on function code symbol
7228 entries, to their corresponding function descriptor symbol entries. */
7231 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7232 struct bfd_link_info *info)
7234 struct ppc_link_hash_table *htab;
7236 htab = ppc_hash_table (info);
7240 /* Provide any missing _save* and _rest* functions. */
7241 if (htab->sfpr != NULL)
7245 htab->sfpr->size = 0;
7246 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7247 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7249 if (htab->sfpr->size == 0)
7250 htab->sfpr->flags |= SEC_EXCLUDE;
7253 if (bfd_link_relocatable (info))
7256 if (htab->elf.hgot != NULL)
7258 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7259 /* Make .TOC. defined so as to prevent it being made dynamic.
7260 The wrong value here is fixed later in ppc64_elf_set_toc. */
7261 if (!htab->elf.hgot->def_regular
7262 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7264 htab->elf.hgot->root.type = bfd_link_hash_defined;
7265 htab->elf.hgot->root.u.def.value = 0;
7266 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7267 htab->elf.hgot->def_regular = 1;
7268 htab->elf.hgot->root.linker_def = 1;
7270 htab->elf.hgot->type = STT_OBJECT;
7271 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7275 if (htab->need_func_desc_adj)
7277 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7278 htab->need_func_desc_adj = 0;
7284 /* Find dynamic relocs for H that apply to read-only sections. */
7287 readonly_dynrelocs (struct elf_link_hash_entry *h)
7289 struct ppc_link_hash_entry *eh;
7290 struct elf_dyn_relocs *p;
7292 eh = (struct ppc_link_hash_entry *) h;
7293 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7295 asection *s = p->sec->output_section;
7297 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7303 /* Return true if we have dynamic relocs against H or any of its weak
7304 aliases, that apply to read-only sections. Cannot be used after
7305 size_dynamic_sections. */
7308 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7310 struct ppc_link_hash_entry *eh;
7312 eh = (struct ppc_link_hash_entry *) h;
7315 if (readonly_dynrelocs (&eh->elf))
7317 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7318 } while (eh != NULL && &eh->elf != h);
7323 /* Return whether EH has pc-relative dynamic relocs. */
7326 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7328 struct elf_dyn_relocs *p;
7330 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7331 if (p->pc_count != 0)
7336 /* Return true if a global entry stub will be created for H. Valid
7337 for ELFv2 before plt entries have been allocated. */
7340 global_entry_stub (struct elf_link_hash_entry *h)
7342 struct plt_entry *pent;
7344 if (!h->pointer_equality_needed
7348 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7349 if (pent->plt.refcount > 0
7350 && pent->addend == 0)
7356 /* Adjust a symbol defined by a dynamic object and referenced by a
7357 regular object. The current definition is in some section of the
7358 dynamic object, but we're not including those sections. We have to
7359 change the definition to something the rest of the link can
7363 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7364 struct elf_link_hash_entry *h)
7366 struct ppc_link_hash_table *htab;
7369 htab = ppc_hash_table (info);
7373 /* Deal with function syms. */
7374 if (h->type == STT_FUNC
7375 || h->type == STT_GNU_IFUNC
7378 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7379 || SYMBOL_CALLS_LOCAL (info, h)
7380 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7381 /* Discard dyn_relocs when non-pic if we've decided that a
7382 function symbol is local and not an ifunc. We keep dynamic
7383 relocs for ifuncs when local rather than always emitting a
7384 plt call stub for them and defining the symbol on the call
7385 stub. We can't do that for ELFv1 anyway (a function symbol
7386 is defined on a descriptor, not code) and it can be faster at
7387 run-time due to not needing to bounce through a stub. The
7388 dyn_relocs for ifuncs will be applied even in a static
7390 if (!bfd_link_pic (info)
7391 && h->type != STT_GNU_IFUNC
7393 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7395 /* Clear procedure linkage table information for any symbol that
7396 won't need a .plt entry. */
7397 struct plt_entry *ent;
7398 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7399 if (ent->plt.refcount > 0)
7402 || (h->type != STT_GNU_IFUNC
7404 && (htab->can_convert_all_inline_plt
7405 || (((struct ppc_link_hash_entry *) h)->tls_mask
7406 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7408 h->plt.plist = NULL;
7410 h->pointer_equality_needed = 0;
7412 else if (abiversion (info->output_bfd) >= 2)
7414 /* Taking a function's address in a read/write section
7415 doesn't require us to define the function symbol in the
7416 executable on a global entry stub. A dynamic reloc can
7417 be used instead. The reason we prefer a few more dynamic
7418 relocs is that calling via a global entry stub costs a
7419 few more instructions, and pointer_equality_needed causes
7420 extra work in ld.so when resolving these symbols. */
7421 if (global_entry_stub (h))
7423 if (!readonly_dynrelocs (h))
7425 h->pointer_equality_needed = 0;
7426 /* If we haven't seen a branch reloc and the symbol
7427 isn't an ifunc then we don't need a plt entry. */
7429 h->plt.plist = NULL;
7431 else if (!bfd_link_pic (info))
7432 /* We are going to be defining the function symbol on the
7433 plt stub, so no dyn_relocs needed when non-pic. */
7434 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7437 /* ELFv2 function symbols can't have copy relocs. */
7440 else if (!h->needs_plt
7441 && !readonly_dynrelocs (h))
7443 /* If we haven't seen a branch reloc and the symbol isn't an
7444 ifunc then we don't need a plt entry. */
7445 h->plt.plist = NULL;
7446 h->pointer_equality_needed = 0;
7451 h->plt.plist = NULL;
7453 /* If this is a weak symbol, and there is a real definition, the
7454 processor independent code will have arranged for us to see the
7455 real definition first, and we can just use the same value. */
7456 if (h->is_weakalias)
7458 struct elf_link_hash_entry *def = weakdef (h);
7459 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7460 h->root.u.def.section = def->root.u.def.section;
7461 h->root.u.def.value = def->root.u.def.value;
7462 if (def->root.u.def.section == htab->elf.sdynbss
7463 || def->root.u.def.section == htab->elf.sdynrelro)
7464 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7468 /* If we are creating a shared library, we must presume that the
7469 only references to the symbol are via the global offset table.
7470 For such cases we need not do anything here; the relocations will
7471 be handled correctly by relocate_section. */
7472 if (bfd_link_pic (info))
7475 /* If there are no references to this symbol that do not use the
7476 GOT, we don't need to generate a copy reloc. */
7477 if (!h->non_got_ref)
7480 /* Don't generate a copy reloc for symbols defined in the executable. */
7481 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7483 /* If -z nocopyreloc was given, don't generate them either. */
7484 || info->nocopyreloc
7486 /* If we don't find any dynamic relocs in read-only sections, then
7487 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7488 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7490 /* Protected variables do not work with .dynbss. The copy in
7491 .dynbss won't be used by the shared library with the protected
7492 definition for the variable. Text relocations are preferable
7493 to an incorrect program. */
7494 || h->protected_def)
7497 if (h->plt.plist != NULL)
7499 /* We should never get here, but unfortunately there are versions
7500 of gcc out there that improperly (for this ABI) put initialized
7501 function pointers, vtable refs and suchlike in read-only
7502 sections. Allow them to proceed, but warn that this might
7503 break at runtime. */
7504 info->callbacks->einfo
7505 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7506 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7507 h->root.root.string);
7510 /* This is a reference to a symbol defined by a dynamic object which
7511 is not a function. */
7513 /* We must allocate the symbol in our .dynbss section, which will
7514 become part of the .bss section of the executable. There will be
7515 an entry for this symbol in the .dynsym section. The dynamic
7516 object will contain position independent code, so all references
7517 from the dynamic object to this symbol will go through the global
7518 offset table. The dynamic linker will use the .dynsym entry to
7519 determine the address it must put in the global offset table, so
7520 both the dynamic object and the regular object will refer to the
7521 same memory location for the variable. */
7522 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7524 s = htab->elf.sdynrelro;
7525 srel = htab->elf.sreldynrelro;
7529 s = htab->elf.sdynbss;
7530 srel = htab->elf.srelbss;
7532 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7534 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7535 linker to copy the initial value out of the dynamic object
7536 and into the runtime process image. */
7537 srel->size += sizeof (Elf64_External_Rela);
7541 /* We no longer want dyn_relocs. */
7542 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7543 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7546 /* If given a function descriptor symbol, hide both the function code
7547 sym and the descriptor. */
7549 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7550 struct elf_link_hash_entry *h,
7551 bfd_boolean force_local)
7553 struct ppc_link_hash_entry *eh;
7554 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7556 eh = (struct ppc_link_hash_entry *) h;
7557 if (eh->is_func_descriptor)
7559 struct ppc_link_hash_entry *fh = eh->oh;
7564 struct elf_link_hash_table *htab = elf_hash_table (info);
7567 /* We aren't supposed to use alloca in BFD because on
7568 systems which do not have alloca the version in libiberty
7569 calls xmalloc, which might cause the program to crash
7570 when it runs out of memory. This function doesn't have a
7571 return status, so there's no way to gracefully return an
7572 error. So cheat. We know that string[-1] can be safely
7573 accessed; It's either a string in an ELF string table,
7574 or allocated in an objalloc structure. */
7576 p = eh->elf.root.root.string - 1;
7579 fh = (struct ppc_link_hash_entry *)
7580 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7583 /* Unfortunately, if it so happens that the string we were
7584 looking for was allocated immediately before this string,
7585 then we overwrote the string terminator. That's the only
7586 reason the lookup should fail. */
7589 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7590 while (q >= eh->elf.root.root.string && *q == *p)
7592 if (q < eh->elf.root.root.string && *p == '.')
7593 fh = (struct ppc_link_hash_entry *)
7594 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7603 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7608 get_sym_h (struct elf_link_hash_entry **hp,
7609 Elf_Internal_Sym **symp,
7611 unsigned char **tls_maskp,
7612 Elf_Internal_Sym **locsymsp,
7613 unsigned long r_symndx,
7616 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7618 if (r_symndx >= symtab_hdr->sh_info)
7620 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7621 struct elf_link_hash_entry *h;
7623 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7624 h = elf_follow_link (h);
7632 if (symsecp != NULL)
7634 asection *symsec = NULL;
7635 if (h->root.type == bfd_link_hash_defined
7636 || h->root.type == bfd_link_hash_defweak)
7637 symsec = h->root.u.def.section;
7641 if (tls_maskp != NULL)
7643 struct ppc_link_hash_entry *eh;
7645 eh = (struct ppc_link_hash_entry *) h;
7646 *tls_maskp = &eh->tls_mask;
7651 Elf_Internal_Sym *sym;
7652 Elf_Internal_Sym *locsyms = *locsymsp;
7654 if (locsyms == NULL)
7656 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7657 if (locsyms == NULL)
7658 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7659 symtab_hdr->sh_info,
7660 0, NULL, NULL, NULL);
7661 if (locsyms == NULL)
7663 *locsymsp = locsyms;
7665 sym = locsyms + r_symndx;
7673 if (symsecp != NULL)
7674 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7676 if (tls_maskp != NULL)
7678 struct got_entry **lgot_ents;
7679 unsigned char *tls_mask;
7682 lgot_ents = elf_local_got_ents (ibfd);
7683 if (lgot_ents != NULL)
7685 struct plt_entry **local_plt = (struct plt_entry **)
7686 (lgot_ents + symtab_hdr->sh_info);
7687 unsigned char *lgot_masks = (unsigned char *)
7688 (local_plt + symtab_hdr->sh_info);
7689 tls_mask = &lgot_masks[r_symndx];
7691 *tls_maskp = tls_mask;
7697 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7698 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7699 type suitable for optimization, and 1 otherwise. */
7702 get_tls_mask (unsigned char **tls_maskp,
7703 unsigned long *toc_symndx,
7704 bfd_vma *toc_addend,
7705 Elf_Internal_Sym **locsymsp,
7706 const Elf_Internal_Rela *rel,
7709 unsigned long r_symndx;
7711 struct elf_link_hash_entry *h;
7712 Elf_Internal_Sym *sym;
7716 r_symndx = ELF64_R_SYM (rel->r_info);
7717 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7720 if ((*tls_maskp != NULL
7721 && (**tls_maskp & TLS_TLS) != 0
7722 && **tls_maskp != (TLS_TLS | TLS_MARK))
7724 || ppc64_elf_section_data (sec) == NULL
7725 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7728 /* Look inside a TOC section too. */
7731 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7732 off = h->root.u.def.value;
7735 off = sym->st_value;
7736 off += rel->r_addend;
7737 BFD_ASSERT (off % 8 == 0);
7738 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7739 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7740 if (toc_symndx != NULL)
7741 *toc_symndx = r_symndx;
7742 if (toc_addend != NULL)
7743 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7744 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7746 if ((h == NULL || is_static_defined (h))
7747 && (next_r == -1 || next_r == -2))
7752 /* Find (or create) an entry in the tocsave hash table. */
7754 static struct tocsave_entry *
7755 tocsave_find (struct ppc_link_hash_table *htab,
7756 enum insert_option insert,
7757 Elf_Internal_Sym **local_syms,
7758 const Elf_Internal_Rela *irela,
7761 unsigned long r_indx;
7762 struct elf_link_hash_entry *h;
7763 Elf_Internal_Sym *sym;
7764 struct tocsave_entry ent, *p;
7766 struct tocsave_entry **slot;
7768 r_indx = ELF64_R_SYM (irela->r_info);
7769 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7771 if (ent.sec == NULL || ent.sec->output_section == NULL)
7774 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7779 ent.offset = h->root.u.def.value;
7781 ent.offset = sym->st_value;
7782 ent.offset += irela->r_addend;
7784 hash = tocsave_htab_hash (&ent);
7785 slot = ((struct tocsave_entry **)
7786 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7792 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7801 /* Adjust all global syms defined in opd sections. In gcc generated
7802 code for the old ABI, these will already have been done. */
7805 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7807 struct ppc_link_hash_entry *eh;
7809 struct _opd_sec_data *opd;
7811 if (h->root.type == bfd_link_hash_indirect)
7814 if (h->root.type != bfd_link_hash_defined
7815 && h->root.type != bfd_link_hash_defweak)
7818 eh = (struct ppc_link_hash_entry *) h;
7819 if (eh->adjust_done)
7822 sym_sec = eh->elf.root.u.def.section;
7823 opd = get_opd_info (sym_sec);
7824 if (opd != NULL && opd->adjust != NULL)
7826 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7829 /* This entry has been deleted. */
7830 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7833 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7834 if (discarded_section (dsec))
7836 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7840 eh->elf.root.u.def.value = 0;
7841 eh->elf.root.u.def.section = dsec;
7844 eh->elf.root.u.def.value += adjust;
7845 eh->adjust_done = 1;
7850 /* Handles decrementing dynamic reloc counts for the reloc specified by
7851 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7852 have already been determined. */
7855 dec_dynrel_count (bfd_vma r_info,
7857 struct bfd_link_info *info,
7858 Elf_Internal_Sym **local_syms,
7859 struct elf_link_hash_entry *h,
7860 Elf_Internal_Sym *sym)
7862 enum elf_ppc64_reloc_type r_type;
7863 asection *sym_sec = NULL;
7865 /* Can this reloc be dynamic? This switch, and later tests here
7866 should be kept in sync with the code in check_relocs. */
7867 r_type = ELF64_R_TYPE (r_info);
7873 case R_PPC64_TPREL16:
7874 case R_PPC64_TPREL16_LO:
7875 case R_PPC64_TPREL16_HI:
7876 case R_PPC64_TPREL16_HA:
7877 case R_PPC64_TPREL16_DS:
7878 case R_PPC64_TPREL16_LO_DS:
7879 case R_PPC64_TPREL16_HIGH:
7880 case R_PPC64_TPREL16_HIGHA:
7881 case R_PPC64_TPREL16_HIGHER:
7882 case R_PPC64_TPREL16_HIGHERA:
7883 case R_PPC64_TPREL16_HIGHEST:
7884 case R_PPC64_TPREL16_HIGHESTA:
7885 case R_PPC64_TPREL64:
7886 case R_PPC64_DTPMOD64:
7887 case R_PPC64_DTPREL64:
7888 case R_PPC64_ADDR64:
7892 case R_PPC64_ADDR14:
7893 case R_PPC64_ADDR14_BRNTAKEN:
7894 case R_PPC64_ADDR14_BRTAKEN:
7895 case R_PPC64_ADDR16:
7896 case R_PPC64_ADDR16_DS:
7897 case R_PPC64_ADDR16_HA:
7898 case R_PPC64_ADDR16_HI:
7899 case R_PPC64_ADDR16_HIGH:
7900 case R_PPC64_ADDR16_HIGHA:
7901 case R_PPC64_ADDR16_HIGHER:
7902 case R_PPC64_ADDR16_HIGHERA:
7903 case R_PPC64_ADDR16_HIGHEST:
7904 case R_PPC64_ADDR16_HIGHESTA:
7905 case R_PPC64_ADDR16_LO:
7906 case R_PPC64_ADDR16_LO_DS:
7907 case R_PPC64_ADDR24:
7908 case R_PPC64_ADDR32:
7909 case R_PPC64_UADDR16:
7910 case R_PPC64_UADDR32:
7911 case R_PPC64_UADDR64:
7916 if (local_syms != NULL)
7918 unsigned long r_symndx;
7919 bfd *ibfd = sec->owner;
7921 r_symndx = ELF64_R_SYM (r_info);
7922 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7926 if ((bfd_link_pic (info)
7927 && (must_be_dyn_reloc (info, r_type)
7929 && (!SYMBOLIC_BIND (info, h)
7930 || h->root.type == bfd_link_hash_defweak
7931 || !h->def_regular))))
7932 || (ELIMINATE_COPY_RELOCS
7933 && !bfd_link_pic (info)
7935 && (h->root.type == bfd_link_hash_defweak
7936 || !h->def_regular)))
7943 struct elf_dyn_relocs *p;
7944 struct elf_dyn_relocs **pp;
7945 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7947 /* elf_gc_sweep may have already removed all dyn relocs associated
7948 with local syms for a given section. Also, symbol flags are
7949 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7950 report a dynreloc miscount. */
7951 if (*pp == NULL && info->gc_sections)
7954 while ((p = *pp) != NULL)
7958 if (!must_be_dyn_reloc (info, r_type))
7970 struct ppc_dyn_relocs *p;
7971 struct ppc_dyn_relocs **pp;
7973 bfd_boolean is_ifunc;
7975 if (local_syms == NULL)
7976 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7977 if (sym_sec == NULL)
7980 vpp = &elf_section_data (sym_sec)->local_dynrel;
7981 pp = (struct ppc_dyn_relocs **) vpp;
7983 if (*pp == NULL && info->gc_sections)
7986 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7987 while ((p = *pp) != NULL)
7989 if (p->sec == sec && p->ifunc == is_ifunc)
8000 /* xgettext:c-format */
8001 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
8003 bfd_set_error (bfd_error_bad_value);
8007 /* Remove unused Official Procedure Descriptor entries. Currently we
8008 only remove those associated with functions in discarded link-once
8009 sections, or weakly defined functions that have been overridden. It
8010 would be possible to remove many more entries for statically linked
8014 ppc64_elf_edit_opd (struct bfd_link_info *info)
8017 bfd_boolean some_edited = FALSE;
8018 asection *need_pad = NULL;
8019 struct ppc_link_hash_table *htab;
8021 htab = ppc_hash_table (info);
8025 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8028 Elf_Internal_Rela *relstart, *rel, *relend;
8029 Elf_Internal_Shdr *symtab_hdr;
8030 Elf_Internal_Sym *local_syms;
8031 struct _opd_sec_data *opd;
8032 bfd_boolean need_edit, add_aux_fields, broken;
8033 bfd_size_type cnt_16b = 0;
8035 if (!is_ppc64_elf (ibfd))
8038 sec = bfd_get_section_by_name (ibfd, ".opd");
8039 if (sec == NULL || sec->size == 0)
8042 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
8045 if (sec->output_section == bfd_abs_section_ptr)
8048 /* Look through the section relocs. */
8049 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
8053 symtab_hdr = &elf_symtab_hdr (ibfd);
8055 /* Read the relocations. */
8056 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8058 if (relstart == NULL)
8061 /* First run through the relocs to check they are sane, and to
8062 determine whether we need to edit this opd section. */
8066 relend = relstart + sec->reloc_count;
8067 for (rel = relstart; rel < relend; )
8069 enum elf_ppc64_reloc_type r_type;
8070 unsigned long r_symndx;
8072 struct elf_link_hash_entry *h;
8073 Elf_Internal_Sym *sym;
8076 /* .opd contains an array of 16 or 24 byte entries. We're
8077 only interested in the reloc pointing to a function entry
8079 offset = rel->r_offset;
8080 if (rel + 1 == relend
8081 || rel[1].r_offset != offset + 8)
8083 /* If someone messes with .opd alignment then after a
8084 "ld -r" we might have padding in the middle of .opd.
8085 Also, there's nothing to prevent someone putting
8086 something silly in .opd with the assembler. No .opd
8087 optimization for them! */
8090 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
8095 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8096 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8099 /* xgettext:c-format */
8100 (_("%pB: unexpected reloc type %u in .opd section"),
8106 r_symndx = ELF64_R_SYM (rel->r_info);
8107 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8111 if (sym_sec == NULL || sym_sec->owner == NULL)
8113 const char *sym_name;
8115 sym_name = h->root.root.string;
8117 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8121 /* xgettext:c-format */
8122 (_("%pB: undefined sym `%s' in .opd section"),
8128 /* opd entries are always for functions defined in the
8129 current input bfd. If the symbol isn't defined in the
8130 input bfd, then we won't be using the function in this
8131 bfd; It must be defined in a linkonce section in another
8132 bfd, or is weak. It's also possible that we are
8133 discarding the function due to a linker script /DISCARD/,
8134 which we test for via the output_section. */
8135 if (sym_sec->owner != ibfd
8136 || sym_sec->output_section == bfd_abs_section_ptr)
8140 if (rel + 1 == relend
8141 || (rel + 2 < relend
8142 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8147 if (sec->size == offset + 24)
8152 if (sec->size == offset + 16)
8159 else if (rel + 1 < relend
8160 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8161 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8163 if (rel[0].r_offset == offset + 16)
8165 else if (rel[0].r_offset != offset + 24)
8172 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8174 if (!broken && (need_edit || add_aux_fields))
8176 Elf_Internal_Rela *write_rel;
8177 Elf_Internal_Shdr *rel_hdr;
8178 bfd_byte *rptr, *wptr;
8179 bfd_byte *new_contents;
8182 new_contents = NULL;
8183 amt = OPD_NDX (sec->size) * sizeof (long);
8184 opd = &ppc64_elf_section_data (sec)->u.opd;
8185 opd->adjust = bfd_zalloc (sec->owner, amt);
8186 if (opd->adjust == NULL)
8189 /* This seems a waste of time as input .opd sections are all
8190 zeros as generated by gcc, but I suppose there's no reason
8191 this will always be so. We might start putting something in
8192 the third word of .opd entries. */
8193 if ((sec->flags & SEC_IN_MEMORY) == 0)
8196 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8201 if (local_syms != NULL
8202 && symtab_hdr->contents != (unsigned char *) local_syms)
8204 if (elf_section_data (sec)->relocs != relstart)
8208 sec->contents = loc;
8209 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8212 elf_section_data (sec)->relocs = relstart;
8214 new_contents = sec->contents;
8217 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8218 if (new_contents == NULL)
8222 wptr = new_contents;
8223 rptr = sec->contents;
8224 write_rel = relstart;
8225 for (rel = relstart; rel < relend; )
8227 unsigned long r_symndx;
8229 struct elf_link_hash_entry *h;
8230 struct ppc_link_hash_entry *fdh = NULL;
8231 Elf_Internal_Sym *sym;
8233 Elf_Internal_Rela *next_rel;
8236 r_symndx = ELF64_R_SYM (rel->r_info);
8237 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8242 if (next_rel + 1 == relend
8243 || (next_rel + 2 < relend
8244 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8247 /* See if the .opd entry is full 24 byte or
8248 16 byte (with fd_aux entry overlapped with next
8251 if (next_rel == relend)
8253 if (sec->size == rel->r_offset + 16)
8256 else if (next_rel->r_offset == rel->r_offset + 16)
8260 && h->root.root.string[0] == '.')
8262 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8265 fdh = ppc_follow_link (fdh);
8266 if (fdh->elf.root.type != bfd_link_hash_defined
8267 && fdh->elf.root.type != bfd_link_hash_defweak)
8272 skip = (sym_sec->owner != ibfd
8273 || sym_sec->output_section == bfd_abs_section_ptr);
8276 if (fdh != NULL && sym_sec->owner == ibfd)
8278 /* Arrange for the function descriptor sym
8280 fdh->elf.root.u.def.value = 0;
8281 fdh->elf.root.u.def.section = sym_sec;
8283 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8285 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8290 if (!dec_dynrel_count (rel->r_info, sec, info,
8294 if (++rel == next_rel)
8297 r_symndx = ELF64_R_SYM (rel->r_info);
8298 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8305 /* We'll be keeping this opd entry. */
8310 /* Redefine the function descriptor symbol to
8311 this location in the opd section. It is
8312 necessary to update the value here rather
8313 than using an array of adjustments as we do
8314 for local symbols, because various places
8315 in the generic ELF code use the value
8316 stored in u.def.value. */
8317 fdh->elf.root.u.def.value = wptr - new_contents;
8318 fdh->adjust_done = 1;
8321 /* Local syms are a bit tricky. We could
8322 tweak them as they can be cached, but
8323 we'd need to look through the local syms
8324 for the function descriptor sym which we
8325 don't have at the moment. So keep an
8326 array of adjustments. */
8327 adjust = (wptr - new_contents) - (rptr - sec->contents);
8328 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8331 memcpy (wptr, rptr, opd_ent_size);
8332 wptr += opd_ent_size;
8333 if (add_aux_fields && opd_ent_size == 16)
8335 memset (wptr, '\0', 8);
8339 /* We need to adjust any reloc offsets to point to the
8341 for ( ; rel != next_rel; ++rel)
8343 rel->r_offset += adjust;
8344 if (write_rel != rel)
8345 memcpy (write_rel, rel, sizeof (*rel));
8350 rptr += opd_ent_size;
8353 sec->size = wptr - new_contents;
8354 sec->reloc_count = write_rel - relstart;
8357 free (sec->contents);
8358 sec->contents = new_contents;
8361 /* Fudge the header size too, as this is used later in
8362 elf_bfd_final_link if we are emitting relocs. */
8363 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8364 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8367 else if (elf_section_data (sec)->relocs != relstart)
8370 if (local_syms != NULL
8371 && symtab_hdr->contents != (unsigned char *) local_syms)
8373 if (!info->keep_memory)
8376 symtab_hdr->contents = (unsigned char *) local_syms;
8381 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8383 /* If we are doing a final link and the last .opd entry is just 16 byte
8384 long, add a 8 byte padding after it. */
8385 if (need_pad != NULL && !bfd_link_relocatable (info))
8389 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8391 BFD_ASSERT (need_pad->size > 0);
8393 p = bfd_malloc (need_pad->size + 8);
8397 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8398 p, 0, need_pad->size))
8401 need_pad->contents = p;
8402 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8406 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8410 need_pad->contents = p;
8413 memset (need_pad->contents + need_pad->size, 0, 8);
8414 need_pad->size += 8;
8420 /* Analyze inline PLT call relocations to see whether calls to locally
8421 defined functions can be converted to direct calls. */
8424 ppc64_elf_inline_plt (struct bfd_link_info *info)
8426 struct ppc_link_hash_table *htab;
8429 bfd_vma low_vma, high_vma, limit;
8431 htab = ppc_hash_table (info);
8435 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
8436 reduced somewhat to cater for possible stubs that might be added
8437 between the call and its destination. */
8438 if (htab->params->group_size < 0)
8440 limit = -htab->params->group_size;
8446 limit = htab->params->group_size;
8453 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8454 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8456 if (low_vma > sec->vma)
8458 if (high_vma < sec->vma + sec->size)
8459 high_vma = sec->vma + sec->size;
8462 /* If a "bl" can reach anywhere in local code sections, then we can
8463 convert all inline PLT sequences to direct calls when the symbol
8465 if (high_vma - low_vma < limit)
8467 htab->can_convert_all_inline_plt = 1;
8471 /* Otherwise, go looking through relocs for cases where a direct
8472 call won't reach. Mark the symbol on any such reloc to disable
8473 the optimization and keep the PLT entry as it seems likely that
8474 this will be better than creating trampolines. Note that this
8475 will disable the optimization for all inline PLT calls to a
8476 particular symbol, not just those that won't reach. The
8477 difficulty in doing a more precise optimization is that the
8478 linker needs to make a decision depending on whether a
8479 particular R_PPC64_PLTCALL insn can be turned into a direct
8480 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8481 the sequence, and there is nothing that ties those relocs
8482 together except their symbol. */
8484 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8486 Elf_Internal_Shdr *symtab_hdr;
8487 Elf_Internal_Sym *local_syms;
8489 if (!is_ppc64_elf (ibfd))
8493 symtab_hdr = &elf_symtab_hdr (ibfd);
8495 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8496 if (ppc64_elf_section_data (sec)->has_pltcall
8497 && !bfd_is_abs_section (sec->output_section))
8499 Elf_Internal_Rela *relstart, *rel, *relend;
8501 /* Read the relocations. */
8502 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8504 if (relstart == NULL)
8507 relend = relstart + sec->reloc_count;
8508 for (rel = relstart; rel < relend; )
8510 enum elf_ppc64_reloc_type r_type;
8511 unsigned long r_symndx;
8513 struct elf_link_hash_entry *h;
8514 Elf_Internal_Sym *sym;
8515 unsigned char *tls_maskp;
8517 r_type = ELF64_R_TYPE (rel->r_info);
8518 if (r_type != R_PPC64_PLTCALL)
8521 r_symndx = ELF64_R_SYM (rel->r_info);
8522 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8525 if (elf_section_data (sec)->relocs != relstart)
8527 if (local_syms != NULL
8528 && symtab_hdr->contents != (unsigned char *) local_syms)
8533 if (sym_sec != NULL && sym_sec->output_section != NULL)
8537 to = h->root.u.def.value;
8540 to += (rel->r_addend
8541 + sym_sec->output_offset
8542 + sym_sec->output_section->vma);
8543 from = (rel->r_offset
8544 + sec->output_offset
8545 + sec->output_section->vma);
8546 if (to - from + limit < 2 * limit)
8547 *tls_maskp &= ~PLT_KEEP;
8550 if (elf_section_data (sec)->relocs != relstart)
8554 if (local_syms != NULL
8555 && symtab_hdr->contents != (unsigned char *) local_syms)
8557 if (!info->keep_memory)
8560 symtab_hdr->contents = (unsigned char *) local_syms;
8567 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8570 ppc64_elf_tls_setup (struct bfd_link_info *info)
8572 struct ppc_link_hash_table *htab;
8574 htab = ppc_hash_table (info);
8578 if (abiversion (info->output_bfd) == 1)
8581 if (htab->params->no_multi_toc)
8582 htab->do_multi_toc = 0;
8583 else if (!htab->do_multi_toc)
8584 htab->params->no_multi_toc = 1;
8586 /* Default to --no-plt-localentry, as this option can cause problems
8587 with symbol interposition. For example, glibc libpthread.so and
8588 libc.so duplicate many pthread symbols, with a fallback
8589 implementation in libc.so. In some cases the fallback does more
8590 work than the pthread implementation. __pthread_condattr_destroy
8591 is one such symbol: the libpthread.so implementation is
8592 localentry:0 while the libc.so implementation is localentry:8.
8593 An app that "cleverly" uses dlopen to only load necessary
8594 libraries at runtime may omit loading libpthread.so when not
8595 running multi-threaded, which then results in the libc.so
8596 fallback symbols being used and ld.so complaining. Now there
8597 are workarounds in ld (see non_zero_localentry) to detect the
8598 pthread situation, but that may not be the only case where
8599 --plt-localentry can cause trouble. */
8600 if (htab->params->plt_localentry0 < 0)
8601 htab->params->plt_localentry0 = 0;
8602 if (htab->params->plt_localentry0
8603 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8604 FALSE, FALSE, FALSE) == NULL)
8606 (_("warning: --plt-localentry is especially dangerous without "
8607 "ld.so support to detect ABI violations"));
8609 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8610 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8611 FALSE, FALSE, TRUE));
8612 /* Move dynamic linking info to the function descriptor sym. */
8613 if (htab->tls_get_addr != NULL)
8614 func_desc_adjust (&htab->tls_get_addr->elf, info);
8615 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8616 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8617 FALSE, FALSE, TRUE));
8618 if (htab->params->tls_get_addr_opt)
8620 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8622 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8623 FALSE, FALSE, TRUE);
8625 func_desc_adjust (opt, info);
8626 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8627 FALSE, FALSE, TRUE);
8629 && (opt_fd->root.type == bfd_link_hash_defined
8630 || opt_fd->root.type == bfd_link_hash_defweak))
8632 /* If glibc supports an optimized __tls_get_addr call stub,
8633 signalled by the presence of __tls_get_addr_opt, and we'll
8634 be calling __tls_get_addr via a plt call stub, then
8635 make __tls_get_addr point to __tls_get_addr_opt. */
8636 tga_fd = &htab->tls_get_addr_fd->elf;
8637 if (htab->elf.dynamic_sections_created
8639 && (tga_fd->type == STT_FUNC
8640 || tga_fd->needs_plt)
8641 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8642 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8644 struct plt_entry *ent;
8646 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8647 if (ent->plt.refcount > 0)
8651 tga_fd->root.type = bfd_link_hash_indirect;
8652 tga_fd->root.u.i.link = &opt_fd->root;
8653 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8655 if (opt_fd->dynindx != -1)
8657 /* Use __tls_get_addr_opt in dynamic relocations. */
8658 opt_fd->dynindx = -1;
8659 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8660 opt_fd->dynstr_index);
8661 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8664 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8665 tga = &htab->tls_get_addr->elf;
8666 if (opt != NULL && tga != NULL)
8668 tga->root.type = bfd_link_hash_indirect;
8669 tga->root.u.i.link = &opt->root;
8670 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8672 _bfd_elf_link_hash_hide_symbol (info, opt,
8674 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8676 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8677 htab->tls_get_addr_fd->is_func_descriptor = 1;
8678 if (htab->tls_get_addr != NULL)
8680 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8681 htab->tls_get_addr->is_func = 1;
8686 else if (htab->params->tls_get_addr_opt < 0)
8687 htab->params->tls_get_addr_opt = 0;
8689 return _bfd_elf_tls_setup (info->output_bfd, info);
8692 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8696 branch_reloc_hash_match (const bfd *ibfd,
8697 const Elf_Internal_Rela *rel,
8698 const struct ppc_link_hash_entry *hash1,
8699 const struct ppc_link_hash_entry *hash2)
8701 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8702 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8703 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8705 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8707 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8708 struct elf_link_hash_entry *h;
8710 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8711 h = elf_follow_link (h);
8712 if (h == &hash1->elf || h == &hash2->elf)
8718 /* Run through all the TLS relocs looking for optimization
8719 opportunities. The linker has been hacked (see ppc64elf.em) to do
8720 a preliminary section layout so that we know the TLS segment
8721 offsets. We can't optimize earlier because some optimizations need
8722 to know the tp offset, and we need to optimize before allocating
8723 dynamic relocations. */
8726 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8730 struct ppc_link_hash_table *htab;
8731 unsigned char *toc_ref;
8734 if (!bfd_link_executable (info))
8737 htab = ppc_hash_table (info);
8741 /* Make two passes over the relocs. On the first pass, mark toc
8742 entries involved with tls relocs, and check that tls relocs
8743 involved in setting up a tls_get_addr call are indeed followed by
8744 such a call. If they are not, we can't do any tls optimization.
8745 On the second pass twiddle tls_mask flags to notify
8746 relocate_section that optimization can be done, and adjust got
8747 and plt refcounts. */
8749 for (pass = 0; pass < 2; ++pass)
8750 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8752 Elf_Internal_Sym *locsyms = NULL;
8753 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8755 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8756 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8758 Elf_Internal_Rela *relstart, *rel, *relend;
8759 bfd_boolean found_tls_get_addr_arg = 0;
8761 /* Read the relocations. */
8762 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8764 if (relstart == NULL)
8770 relend = relstart + sec->reloc_count;
8771 for (rel = relstart; rel < relend; rel++)
8773 enum elf_ppc64_reloc_type r_type;
8774 unsigned long r_symndx;
8775 struct elf_link_hash_entry *h;
8776 Elf_Internal_Sym *sym;
8778 unsigned char *tls_mask;
8779 unsigned char tls_set, tls_clear, tls_type = 0;
8781 bfd_boolean ok_tprel, is_local;
8782 long toc_ref_index = 0;
8783 int expecting_tls_get_addr = 0;
8784 bfd_boolean ret = FALSE;
8786 r_symndx = ELF64_R_SYM (rel->r_info);
8787 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8791 if (elf_section_data (sec)->relocs != relstart)
8793 if (toc_ref != NULL)
8796 && (elf_symtab_hdr (ibfd).contents
8797 != (unsigned char *) locsyms))
8804 if (h->root.type == bfd_link_hash_defined
8805 || h->root.type == bfd_link_hash_defweak)
8806 value = h->root.u.def.value;
8807 else if (h->root.type == bfd_link_hash_undefweak)
8811 found_tls_get_addr_arg = 0;
8816 /* Symbols referenced by TLS relocs must be of type
8817 STT_TLS. So no need for .opd local sym adjust. */
8818 value = sym->st_value;
8827 && h->root.type == bfd_link_hash_undefweak)
8829 else if (sym_sec != NULL
8830 && sym_sec->output_section != NULL)
8832 value += sym_sec->output_offset;
8833 value += sym_sec->output_section->vma;
8834 value -= htab->elf.tls_sec->vma;
8835 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8836 < (bfd_vma) 1 << 32);
8840 r_type = ELF64_R_TYPE (rel->r_info);
8841 /* If this section has old-style __tls_get_addr calls
8842 without marker relocs, then check that each
8843 __tls_get_addr call reloc is preceded by a reloc
8844 that conceivably belongs to the __tls_get_addr arg
8845 setup insn. If we don't find matching arg setup
8846 relocs, don't do any tls optimization. */
8848 && sec->has_tls_get_addr_call
8850 && (h == &htab->tls_get_addr->elf
8851 || h == &htab->tls_get_addr_fd->elf)
8852 && !found_tls_get_addr_arg
8853 && is_branch_reloc (r_type))
8855 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8856 "TLS optimization disabled\n"),
8857 ibfd, sec, rel->r_offset);
8862 found_tls_get_addr_arg = 0;
8865 case R_PPC64_GOT_TLSLD16:
8866 case R_PPC64_GOT_TLSLD16_LO:
8867 expecting_tls_get_addr = 1;
8868 found_tls_get_addr_arg = 1;
8871 case R_PPC64_GOT_TLSLD16_HI:
8872 case R_PPC64_GOT_TLSLD16_HA:
8873 /* These relocs should never be against a symbol
8874 defined in a shared lib. Leave them alone if
8875 that turns out to be the case. */
8882 tls_type = TLS_TLS | TLS_LD;
8885 case R_PPC64_GOT_TLSGD16:
8886 case R_PPC64_GOT_TLSGD16_LO:
8887 expecting_tls_get_addr = 1;
8888 found_tls_get_addr_arg = 1;
8891 case R_PPC64_GOT_TLSGD16_HI:
8892 case R_PPC64_GOT_TLSGD16_HA:
8898 tls_set = TLS_TLS | TLS_TPRELGD;
8900 tls_type = TLS_TLS | TLS_GD;
8903 case R_PPC64_GOT_TPREL16_DS:
8904 case R_PPC64_GOT_TPREL16_LO_DS:
8905 case R_PPC64_GOT_TPREL16_HI:
8906 case R_PPC64_GOT_TPREL16_HA:
8911 tls_clear = TLS_TPREL;
8912 tls_type = TLS_TLS | TLS_TPREL;
8919 if (rel + 1 < relend
8920 && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8923 && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8925 r_symndx = ELF64_R_SYM (rel[1].r_info);
8926 if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8931 struct plt_entry *ent = NULL;
8933 for (ent = h->plt.plist;
8936 if (ent->addend == rel[1].r_addend)
8940 && ent->plt.refcount > 0)
8941 ent->plt.refcount -= 1;
8946 found_tls_get_addr_arg = 1;
8951 case R_PPC64_TOC16_LO:
8952 if (sym_sec == NULL || sym_sec != toc)
8955 /* Mark this toc entry as referenced by a TLS
8956 code sequence. We can do that now in the
8957 case of R_PPC64_TLS, and after checking for
8958 tls_get_addr for the TOC16 relocs. */
8959 if (toc_ref == NULL)
8960 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8961 if (toc_ref == NULL)
8965 value = h->root.u.def.value;
8967 value = sym->st_value;
8968 value += rel->r_addend;
8971 BFD_ASSERT (value < toc->size
8972 && toc->output_offset % 8 == 0);
8973 toc_ref_index = (value + toc->output_offset) / 8;
8974 if (r_type == R_PPC64_TLS
8975 || r_type == R_PPC64_TLSGD
8976 || r_type == R_PPC64_TLSLD)
8978 toc_ref[toc_ref_index] = 1;
8982 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8987 expecting_tls_get_addr = 2;
8990 case R_PPC64_TPREL64:
8994 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8999 tls_set = TLS_EXPLICIT;
9000 tls_clear = TLS_TPREL;
9005 case R_PPC64_DTPMOD64:
9009 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
9011 if (rel + 1 < relend
9013 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
9014 && rel[1].r_offset == rel->r_offset + 8)
9018 tls_set = TLS_EXPLICIT | TLS_GD;
9021 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
9030 tls_set = TLS_EXPLICIT;
9041 if (!expecting_tls_get_addr
9042 || !sec->has_tls_get_addr_call)
9045 if (rel + 1 < relend
9046 && branch_reloc_hash_match (ibfd, rel + 1,
9048 htab->tls_get_addr_fd))
9050 if (expecting_tls_get_addr == 2)
9052 /* Check for toc tls entries. */
9053 unsigned char *toc_tls;
9056 retval = get_tls_mask (&toc_tls, NULL, NULL,
9061 if (toc_tls != NULL)
9063 if ((*toc_tls & TLS_TLS) != 0
9064 && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
9065 found_tls_get_addr_arg = 1;
9067 toc_ref[toc_ref_index] = 1;
9073 /* Uh oh, we didn't find the expected call. We
9074 could just mark this symbol to exclude it
9075 from tls optimization but it's safer to skip
9076 the entire optimization. */
9077 /* xgettext:c-format */
9078 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
9079 "TLS optimization disabled\n"),
9080 ibfd, sec, rel->r_offset);
9085 /* If we don't have old-style __tls_get_addr calls
9086 without TLSGD/TLSLD marker relocs, and we haven't
9087 found a new-style __tls_get_addr call with a
9088 marker for this symbol, then we either have a
9089 broken object file or an -mlongcall style
9090 indirect call to __tls_get_addr without a marker.
9091 Disable optimization in this case. */
9092 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
9093 && (tls_set & TLS_EXPLICIT) == 0
9094 && !sec->has_tls_get_addr_call
9095 && ((*tls_mask & (TLS_TLS | TLS_MARK))
9096 != (TLS_TLS | TLS_MARK)))
9099 if (expecting_tls_get_addr)
9101 struct plt_entry *ent = NULL;
9103 if (htab->tls_get_addr != NULL)
9104 for (ent = htab->tls_get_addr->elf.plt.plist;
9107 if (ent->addend == 0)
9110 if (ent == NULL && htab->tls_get_addr_fd != NULL)
9111 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
9114 if (ent->addend == 0)
9118 && ent->plt.refcount > 0)
9119 ent->plt.refcount -= 1;
9125 if ((tls_set & TLS_EXPLICIT) == 0)
9127 struct got_entry *ent;
9129 /* Adjust got entry for this reloc. */
9133 ent = elf_local_got_ents (ibfd)[r_symndx];
9135 for (; ent != NULL; ent = ent->next)
9136 if (ent->addend == rel->r_addend
9137 && ent->owner == ibfd
9138 && ent->tls_type == tls_type)
9145 /* We managed to get rid of a got entry. */
9146 if (ent->got.refcount > 0)
9147 ent->got.refcount -= 1;
9152 /* If we got rid of a DTPMOD/DTPREL reloc pair then
9153 we'll lose one or two dyn relocs. */
9154 if (!dec_dynrel_count (rel->r_info, sec, info,
9158 if (tls_set == (TLS_EXPLICIT | TLS_GD))
9160 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9166 *tls_mask |= tls_set;
9167 *tls_mask &= ~tls_clear;
9170 if (elf_section_data (sec)->relocs != relstart)
9175 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9177 if (!info->keep_memory)
9180 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9184 if (toc_ref != NULL)
9186 htab->do_tls_opt = 1;
9190 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9191 the values of any global symbols in a toc section that has been
9192 edited. Globals in toc sections should be a rarity, so this function
9193 sets a flag if any are found in toc sections other than the one just
9194 edited, so that further hash table traversals can be avoided. */
9196 struct adjust_toc_info
9199 unsigned long *skip;
9200 bfd_boolean global_toc_syms;
9203 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9206 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9208 struct ppc_link_hash_entry *eh;
9209 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9212 if (h->root.type != bfd_link_hash_defined
9213 && h->root.type != bfd_link_hash_defweak)
9216 eh = (struct ppc_link_hash_entry *) h;
9217 if (eh->adjust_done)
9220 if (eh->elf.root.u.def.section == toc_inf->toc)
9222 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9223 i = toc_inf->toc->rawsize >> 3;
9225 i = eh->elf.root.u.def.value >> 3;
9227 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9230 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9233 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9234 eh->elf.root.u.def.value = (bfd_vma) i << 3;
9237 eh->elf.root.u.def.value -= toc_inf->skip[i];
9238 eh->adjust_done = 1;
9240 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9241 toc_inf->global_toc_syms = TRUE;
9246 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9247 on a _LO variety toc/got reloc. */
9250 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9252 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9253 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9254 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9255 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9256 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9257 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9258 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9259 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9260 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9261 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9262 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9263 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9264 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9265 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9266 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9267 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9268 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9269 /* Exclude lfqu by testing reloc. If relocs are ever
9270 defined for the reduced D field in psq_lu then those
9271 will need testing too. */
9272 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9273 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9275 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9276 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9277 /* Exclude stfqu. psq_stu as above for psq_lu. */
9278 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9279 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9280 && (insn & 1) == 0));
9283 /* Examine all relocs referencing .toc sections in order to remove
9284 unused .toc entries. */
9287 ppc64_elf_edit_toc (struct bfd_link_info *info)
9290 struct adjust_toc_info toc_inf;
9291 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9293 htab->do_toc_opt = 1;
9294 toc_inf.global_toc_syms = TRUE;
9295 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9297 asection *toc, *sec;
9298 Elf_Internal_Shdr *symtab_hdr;
9299 Elf_Internal_Sym *local_syms;
9300 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9301 unsigned long *skip, *drop;
9302 unsigned char *used;
9303 unsigned char *keep, last, some_unused;
9305 if (!is_ppc64_elf (ibfd))
9308 toc = bfd_get_section_by_name (ibfd, ".toc");
9311 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9312 || discarded_section (toc))
9317 symtab_hdr = &elf_symtab_hdr (ibfd);
9319 /* Look at sections dropped from the final link. */
9322 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9324 if (sec->reloc_count == 0
9325 || !discarded_section (sec)
9326 || get_opd_info (sec)
9327 || (sec->flags & SEC_ALLOC) == 0
9328 || (sec->flags & SEC_DEBUGGING) != 0)
9331 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9332 if (relstart == NULL)
9335 /* Run through the relocs to see which toc entries might be
9337 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9339 enum elf_ppc64_reloc_type r_type;
9340 unsigned long r_symndx;
9342 struct elf_link_hash_entry *h;
9343 Elf_Internal_Sym *sym;
9346 r_type = ELF64_R_TYPE (rel->r_info);
9353 case R_PPC64_TOC16_LO:
9354 case R_PPC64_TOC16_HI:
9355 case R_PPC64_TOC16_HA:
9356 case R_PPC64_TOC16_DS:
9357 case R_PPC64_TOC16_LO_DS:
9361 r_symndx = ELF64_R_SYM (rel->r_info);
9362 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9370 val = h->root.u.def.value;
9372 val = sym->st_value;
9373 val += rel->r_addend;
9375 if (val >= toc->size)
9378 /* Anything in the toc ought to be aligned to 8 bytes.
9379 If not, don't mark as unused. */
9385 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9390 skip[val >> 3] = ref_from_discarded;
9393 if (elf_section_data (sec)->relocs != relstart)
9397 /* For largetoc loads of address constants, we can convert
9398 . addis rx,2,addr@got@ha
9399 . ld ry,addr@got@l(rx)
9401 . addis rx,2,addr@toc@ha
9402 . addi ry,rx,addr@toc@l
9403 when addr is within 2G of the toc pointer. This then means
9404 that the word storing "addr" in the toc is no longer needed. */
9406 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9407 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9408 && toc->reloc_count != 0)
9410 /* Read toc relocs. */
9411 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9413 if (toc_relocs == NULL)
9416 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9418 enum elf_ppc64_reloc_type r_type;
9419 unsigned long r_symndx;
9421 struct elf_link_hash_entry *h;
9422 Elf_Internal_Sym *sym;
9425 r_type = ELF64_R_TYPE (rel->r_info);
9426 if (r_type != R_PPC64_ADDR64)
9429 r_symndx = ELF64_R_SYM (rel->r_info);
9430 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9435 || sym_sec->output_section == NULL
9436 || discarded_section (sym_sec))
9439 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9444 if (h->type == STT_GNU_IFUNC)
9446 val = h->root.u.def.value;
9450 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9452 val = sym->st_value;
9454 val += rel->r_addend;
9455 val += sym_sec->output_section->vma + sym_sec->output_offset;
9457 /* We don't yet know the exact toc pointer value, but we
9458 know it will be somewhere in the toc section. Don't
9459 optimize if the difference from any possible toc
9460 pointer is outside [ff..f80008000, 7fff7fff]. */
9461 addr = toc->output_section->vma + TOC_BASE_OFF;
9462 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9465 addr = toc->output_section->vma + toc->output_section->rawsize;
9466 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9471 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9476 skip[rel->r_offset >> 3]
9477 |= can_optimize | ((rel - toc_relocs) << 2);
9484 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9488 if (local_syms != NULL
9489 && symtab_hdr->contents != (unsigned char *) local_syms)
9493 && elf_section_data (sec)->relocs != relstart)
9495 if (toc_relocs != NULL
9496 && elf_section_data (toc)->relocs != toc_relocs)
9503 /* Now check all kept sections that might reference the toc.
9504 Check the toc itself last. */
9505 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9508 sec = (sec == toc ? NULL
9509 : sec->next == NULL ? toc
9510 : sec->next == toc && toc->next ? toc->next
9515 if (sec->reloc_count == 0
9516 || discarded_section (sec)
9517 || get_opd_info (sec)
9518 || (sec->flags & SEC_ALLOC) == 0
9519 || (sec->flags & SEC_DEBUGGING) != 0)
9522 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9524 if (relstart == NULL)
9530 /* Mark toc entries referenced as used. */
9534 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9536 enum elf_ppc64_reloc_type r_type;
9537 unsigned long r_symndx;
9539 struct elf_link_hash_entry *h;
9540 Elf_Internal_Sym *sym;
9542 enum {no_check, check_lo, check_ha} insn_check;
9544 r_type = ELF64_R_TYPE (rel->r_info);
9548 insn_check = no_check;
9551 case R_PPC64_GOT_TLSLD16_HA:
9552 case R_PPC64_GOT_TLSGD16_HA:
9553 case R_PPC64_GOT_TPREL16_HA:
9554 case R_PPC64_GOT_DTPREL16_HA:
9555 case R_PPC64_GOT16_HA:
9556 case R_PPC64_TOC16_HA:
9557 insn_check = check_ha;
9560 case R_PPC64_GOT_TLSLD16_LO:
9561 case R_PPC64_GOT_TLSGD16_LO:
9562 case R_PPC64_GOT_TPREL16_LO_DS:
9563 case R_PPC64_GOT_DTPREL16_LO_DS:
9564 case R_PPC64_GOT16_LO:
9565 case R_PPC64_GOT16_LO_DS:
9566 case R_PPC64_TOC16_LO:
9567 case R_PPC64_TOC16_LO_DS:
9568 insn_check = check_lo;
9572 if (insn_check != no_check)
9574 bfd_vma off = rel->r_offset & ~3;
9575 unsigned char buf[4];
9578 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9583 insn = bfd_get_32 (ibfd, buf);
9584 if (insn_check == check_lo
9585 ? !ok_lo_toc_insn (insn, r_type)
9586 : ((insn & ((0x3f << 26) | 0x1f << 16))
9587 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9591 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9592 sprintf (str, "%#08x", insn);
9593 info->callbacks->einfo
9594 /* xgettext:c-format */
9595 (_("%H: toc optimization is not supported for"
9596 " %s instruction\n"),
9597 ibfd, sec, rel->r_offset & ~3, str);
9604 case R_PPC64_TOC16_LO:
9605 case R_PPC64_TOC16_HI:
9606 case R_PPC64_TOC16_HA:
9607 case R_PPC64_TOC16_DS:
9608 case R_PPC64_TOC16_LO_DS:
9609 /* In case we're taking addresses of toc entries. */
9610 case R_PPC64_ADDR64:
9617 r_symndx = ELF64_R_SYM (rel->r_info);
9618 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9629 val = h->root.u.def.value;
9631 val = sym->st_value;
9632 val += rel->r_addend;
9634 if (val >= toc->size)
9637 if ((skip[val >> 3] & can_optimize) != 0)
9644 case R_PPC64_TOC16_HA:
9647 case R_PPC64_TOC16_LO_DS:
9648 off = rel->r_offset;
9649 off += (bfd_big_endian (ibfd) ? -2 : 3);
9650 if (!bfd_get_section_contents (ibfd, sec, &opc,
9656 if ((opc & (0x3f << 2)) == (58u << 2))
9661 /* Wrong sort of reloc, or not a ld. We may
9662 as well clear ref_from_discarded too. */
9669 /* For the toc section, we only mark as used if this
9670 entry itself isn't unused. */
9671 else if ((used[rel->r_offset >> 3]
9672 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9675 /* Do all the relocs again, to catch reference
9684 if (elf_section_data (sec)->relocs != relstart)
9688 /* Merge the used and skip arrays. Assume that TOC
9689 doublewords not appearing as either used or unused belong
9690 to an entry more than one doubleword in size. */
9691 for (drop = skip, keep = used, last = 0, some_unused = 0;
9692 drop < skip + (toc->size + 7) / 8;
9697 *drop &= ~ref_from_discarded;
9698 if ((*drop & can_optimize) != 0)
9702 else if ((*drop & ref_from_discarded) != 0)
9705 last = ref_from_discarded;
9715 bfd_byte *contents, *src;
9717 Elf_Internal_Sym *sym;
9718 bfd_boolean local_toc_syms = FALSE;
9720 /* Shuffle the toc contents, and at the same time convert the
9721 skip array from booleans into offsets. */
9722 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9725 elf_section_data (toc)->this_hdr.contents = contents;
9727 for (src = contents, off = 0, drop = skip;
9728 src < contents + toc->size;
9731 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9736 memcpy (src - off, src, 8);
9740 toc->rawsize = toc->size;
9741 toc->size = src - contents - off;
9743 /* Adjust addends for relocs against the toc section sym,
9744 and optimize any accesses we can. */
9745 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9747 if (sec->reloc_count == 0
9748 || discarded_section (sec))
9751 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9753 if (relstart == NULL)
9756 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9758 enum elf_ppc64_reloc_type r_type;
9759 unsigned long r_symndx;
9761 struct elf_link_hash_entry *h;
9764 r_type = ELF64_R_TYPE (rel->r_info);
9771 case R_PPC64_TOC16_LO:
9772 case R_PPC64_TOC16_HI:
9773 case R_PPC64_TOC16_HA:
9774 case R_PPC64_TOC16_DS:
9775 case R_PPC64_TOC16_LO_DS:
9776 case R_PPC64_ADDR64:
9780 r_symndx = ELF64_R_SYM (rel->r_info);
9781 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9789 val = h->root.u.def.value;
9792 val = sym->st_value;
9794 local_toc_syms = TRUE;
9797 val += rel->r_addend;
9799 if (val > toc->rawsize)
9801 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9803 else if ((skip[val >> 3] & can_optimize) != 0)
9805 Elf_Internal_Rela *tocrel
9806 = toc_relocs + (skip[val >> 3] >> 2);
9807 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9811 case R_PPC64_TOC16_HA:
9812 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9815 case R_PPC64_TOC16_LO_DS:
9816 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9820 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9822 info->callbacks->einfo
9823 /* xgettext:c-format */
9824 (_("%H: %s references "
9825 "optimized away TOC entry\n"),
9826 ibfd, sec, rel->r_offset,
9827 ppc64_elf_howto_table[r_type]->name);
9828 bfd_set_error (bfd_error_bad_value);
9831 rel->r_addend = tocrel->r_addend;
9832 elf_section_data (sec)->relocs = relstart;
9836 if (h != NULL || sym->st_value != 0)
9839 rel->r_addend -= skip[val >> 3];
9840 elf_section_data (sec)->relocs = relstart;
9843 if (elf_section_data (sec)->relocs != relstart)
9847 /* We shouldn't have local or global symbols defined in the TOC,
9848 but handle them anyway. */
9849 if (local_syms != NULL)
9850 for (sym = local_syms;
9851 sym < local_syms + symtab_hdr->sh_info;
9853 if (sym->st_value != 0
9854 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9858 if (sym->st_value > toc->rawsize)
9859 i = toc->rawsize >> 3;
9861 i = sym->st_value >> 3;
9863 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9867 (_("%s defined on removed toc entry"),
9868 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9871 while ((skip[i] & (ref_from_discarded | can_optimize)));
9872 sym->st_value = (bfd_vma) i << 3;
9875 sym->st_value -= skip[i];
9876 symtab_hdr->contents = (unsigned char *) local_syms;
9879 /* Adjust any global syms defined in this toc input section. */
9880 if (toc_inf.global_toc_syms)
9883 toc_inf.skip = skip;
9884 toc_inf.global_toc_syms = FALSE;
9885 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9889 if (toc->reloc_count != 0)
9891 Elf_Internal_Shdr *rel_hdr;
9892 Elf_Internal_Rela *wrel;
9895 /* Remove unused toc relocs, and adjust those we keep. */
9896 if (toc_relocs == NULL)
9897 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9899 if (toc_relocs == NULL)
9903 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9904 if ((skip[rel->r_offset >> 3]
9905 & (ref_from_discarded | can_optimize)) == 0)
9907 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9908 wrel->r_info = rel->r_info;
9909 wrel->r_addend = rel->r_addend;
9912 else if (!dec_dynrel_count (rel->r_info, toc, info,
9913 &local_syms, NULL, NULL))
9916 elf_section_data (toc)->relocs = toc_relocs;
9917 toc->reloc_count = wrel - toc_relocs;
9918 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9919 sz = rel_hdr->sh_entsize;
9920 rel_hdr->sh_size = toc->reloc_count * sz;
9923 else if (toc_relocs != NULL
9924 && elf_section_data (toc)->relocs != toc_relocs)
9927 if (local_syms != NULL
9928 && symtab_hdr->contents != (unsigned char *) local_syms)
9930 if (!info->keep_memory)
9933 symtab_hdr->contents = (unsigned char *) local_syms;
9941 /* Return true iff input section I references the TOC using
9942 instructions limited to +/-32k offsets. */
9945 ppc64_elf_has_small_toc_reloc (asection *i)
9947 return (is_ppc64_elf (i->owner)
9948 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9951 /* Allocate space for one GOT entry. */
9954 allocate_got (struct elf_link_hash_entry *h,
9955 struct bfd_link_info *info,
9956 struct got_entry *gent)
9958 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9959 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9960 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9962 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9963 ? 2 : 1) * sizeof (Elf64_External_Rela);
9964 asection *got = ppc64_elf_tdata (gent->owner)->got;
9966 gent->got.offset = got->size;
9967 got->size += entsize;
9969 if (h->type == STT_GNU_IFUNC)
9971 htab->elf.irelplt->size += rentsize;
9972 htab->got_reli_size += rentsize;
9974 else if (((bfd_link_pic (info)
9975 && !((gent->tls_type & TLS_TPREL) != 0
9976 && bfd_link_executable (info)
9977 && SYMBOL_REFERENCES_LOCAL (info, h)))
9978 || (htab->elf.dynamic_sections_created
9980 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9981 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9983 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9984 relgot->size += rentsize;
9988 /* This function merges got entries in the same toc group. */
9991 merge_got_entries (struct got_entry **pent)
9993 struct got_entry *ent, *ent2;
9995 for (ent = *pent; ent != NULL; ent = ent->next)
9996 if (!ent->is_indirect)
9997 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9998 if (!ent2->is_indirect
9999 && ent2->addend == ent->addend
10000 && ent2->tls_type == ent->tls_type
10001 && elf_gp (ent2->owner) == elf_gp (ent->owner))
10003 ent2->is_indirect = TRUE;
10004 ent2->got.ent = ent;
10008 /* If H is undefined, make it dynamic if that makes sense. */
10011 ensure_undef_dynamic (struct bfd_link_info *info,
10012 struct elf_link_hash_entry *h)
10014 struct elf_link_hash_table *htab = elf_hash_table (info);
10016 if (htab->dynamic_sections_created
10017 && ((info->dynamic_undefined_weak != 0
10018 && h->root.type == bfd_link_hash_undefweak)
10019 || h->root.type == bfd_link_hash_undefined)
10020 && h->dynindx == -1
10021 && !h->forced_local
10022 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
10023 return bfd_elf_link_record_dynamic_symbol (info, h);
10027 /* Allocate space in .plt, .got and associated reloc sections for
10031 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
10033 struct bfd_link_info *info;
10034 struct ppc_link_hash_table *htab;
10036 struct ppc_link_hash_entry *eh;
10037 struct got_entry **pgent, *gent;
10039 if (h->root.type == bfd_link_hash_indirect)
10042 info = (struct bfd_link_info *) inf;
10043 htab = ppc_hash_table (info);
10047 eh = (struct ppc_link_hash_entry *) h;
10048 /* Run through the TLS GD got entries first if we're changing them
10050 if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
10051 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10052 if (gent->got.refcount > 0
10053 && (gent->tls_type & TLS_GD) != 0)
10055 /* This was a GD entry that has been converted to TPREL. If
10056 there happens to be a TPREL entry we can use that one. */
10057 struct got_entry *ent;
10058 for (ent = h->got.glist; ent != NULL; ent = ent->next)
10059 if (ent->got.refcount > 0
10060 && (ent->tls_type & TLS_TPREL) != 0
10061 && ent->addend == gent->addend
10062 && ent->owner == gent->owner)
10064 gent->got.refcount = 0;
10068 /* If not, then we'll be using our own TPREL entry. */
10069 if (gent->got.refcount != 0)
10070 gent->tls_type = TLS_TLS | TLS_TPREL;
10073 /* Remove any list entry that won't generate a word in the GOT before
10074 we call merge_got_entries. Otherwise we risk merging to empty
10076 pgent = &h->got.glist;
10077 while ((gent = *pgent) != NULL)
10078 if (gent->got.refcount > 0)
10080 if ((gent->tls_type & TLS_LD) != 0
10081 && !h->def_dynamic)
10083 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
10084 *pgent = gent->next;
10087 pgent = &gent->next;
10090 *pgent = gent->next;
10092 if (!htab->do_multi_toc)
10093 merge_got_entries (&h->got.glist);
10095 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10096 if (!gent->is_indirect)
10098 /* Make sure this symbol is output as a dynamic symbol. */
10099 if (!ensure_undef_dynamic (info, h))
10102 if (!is_ppc64_elf (gent->owner))
10105 allocate_got (h, info, gent);
10108 /* If no dynamic sections we can't have dynamic relocs, except for
10109 IFUNCs which are handled even in static executables. */
10110 if (!htab->elf.dynamic_sections_created
10111 && h->type != STT_GNU_IFUNC)
10112 eh->dyn_relocs = NULL;
10114 /* Discard relocs on undefined symbols that must be local. */
10115 else if (h->root.type == bfd_link_hash_undefined
10116 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10117 eh->dyn_relocs = NULL;
10119 /* Also discard relocs on undefined weak syms with non-default
10120 visibility, or when dynamic_undefined_weak says so. */
10121 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10122 eh->dyn_relocs = NULL;
10124 if (eh->dyn_relocs != NULL)
10126 struct elf_dyn_relocs *p, **pp;
10128 /* In the shared -Bsymbolic case, discard space allocated for
10129 dynamic pc-relative relocs against symbols which turn out to
10130 be defined in regular objects. For the normal shared case,
10131 discard space for relocs that have become local due to symbol
10132 visibility changes. */
10134 if (bfd_link_pic (info))
10136 /* Relocs that use pc_count are those that appear on a call
10137 insn, or certain REL relocs (see must_be_dyn_reloc) that
10138 can be generated via assembly. We want calls to
10139 protected symbols to resolve directly to the function
10140 rather than going via the plt. If people want function
10141 pointer comparisons to work as expected then they should
10142 avoid writing weird assembly. */
10143 if (SYMBOL_CALLS_LOCAL (info, h))
10145 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10147 p->count -= p->pc_count;
10156 if (eh->dyn_relocs != NULL)
10158 /* Make sure this symbol is output as a dynamic symbol. */
10159 if (!ensure_undef_dynamic (info, h))
10163 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10165 /* For the non-pic case, discard space for relocs against
10166 symbols which turn out to need copy relocs or are not
10168 if (h->dynamic_adjusted
10170 && !ELF_COMMON_DEF_P (h))
10172 /* Make sure this symbol is output as a dynamic symbol. */
10173 if (!ensure_undef_dynamic (info, h))
10176 if (h->dynindx == -1)
10177 eh->dyn_relocs = NULL;
10180 eh->dyn_relocs = NULL;
10183 /* Finally, allocate space. */
10184 for (p = eh->dyn_relocs; p != NULL; p = p->next)
10186 asection *sreloc = elf_section_data (p->sec)->sreloc;
10187 if (eh->elf.type == STT_GNU_IFUNC)
10188 sreloc = htab->elf.irelplt;
10189 sreloc->size += p->count * sizeof (Elf64_External_Rela);
10193 /* We might need a PLT entry when the symbol
10196 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10197 d) has plt16 relocs and we are linking statically. */
10198 if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10199 || h->type == STT_GNU_IFUNC
10200 || (h->needs_plt && h->dynamic_adjusted)
10203 && !htab->elf.dynamic_sections_created
10204 && !htab->can_convert_all_inline_plt
10205 && (((struct ppc_link_hash_entry *) h)->tls_mask
10206 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10208 struct plt_entry *pent;
10209 bfd_boolean doneone = FALSE;
10210 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10211 if (pent->plt.refcount > 0)
10213 if (!htab->elf.dynamic_sections_created
10214 || h->dynindx == -1)
10216 if (h->type == STT_GNU_IFUNC)
10218 s = htab->elf.iplt;
10219 pent->plt.offset = s->size;
10220 s->size += PLT_ENTRY_SIZE (htab);
10221 s = htab->elf.irelplt;
10225 s = htab->pltlocal;
10226 pent->plt.offset = s->size;
10227 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10228 s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10233 /* If this is the first .plt entry, make room for the special
10235 s = htab->elf.splt;
10237 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10239 pent->plt.offset = s->size;
10241 /* Make room for this entry. */
10242 s->size += PLT_ENTRY_SIZE (htab);
10244 /* Make room for the .glink code. */
10247 s->size += GLINK_PLTRESOLVE_SIZE (htab);
10250 /* We need bigger stubs past index 32767. */
10251 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10258 /* We also need to make an entry in the .rela.plt section. */
10259 s = htab->elf.srelplt;
10262 s->size += sizeof (Elf64_External_Rela);
10266 pent->plt.offset = (bfd_vma) -1;
10269 h->plt.plist = NULL;
10275 h->plt.plist = NULL;
10282 #define PPC_LO(v) ((v) & 0xffff)
10283 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10284 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10286 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10287 to set up space for global entry stubs. These are put in glink,
10288 after the branch table. */
10291 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10293 struct bfd_link_info *info;
10294 struct ppc_link_hash_table *htab;
10295 struct plt_entry *pent;
10298 if (h->root.type == bfd_link_hash_indirect)
10301 if (!h->pointer_equality_needed)
10304 if (h->def_regular)
10308 htab = ppc_hash_table (info);
10312 s = htab->global_entry;
10313 plt = htab->elf.splt;
10314 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10315 if (pent->plt.offset != (bfd_vma) -1
10316 && pent->addend == 0)
10318 /* For ELFv2, if this symbol is not defined in a regular file
10319 and we are not generating a shared library or pie, then we
10320 need to define the symbol in the executable on a call stub.
10321 This is to avoid text relocations. */
10322 bfd_vma off, stub_align, stub_off, stub_size;
10323 unsigned int align_power;
10326 stub_off = s->size;
10327 if (htab->params->plt_stub_align >= 0)
10328 align_power = htab->params->plt_stub_align;
10330 align_power = -htab->params->plt_stub_align;
10331 /* Setting section alignment is delayed until we know it is
10332 non-empty. Otherwise the .text output section will be
10333 aligned at least to plt_stub_align even when no global
10334 entry stubs are needed. */
10335 if (s->alignment_power < align_power)
10336 s->alignment_power = align_power;
10337 stub_align = (bfd_vma) 1 << align_power;
10338 if (htab->params->plt_stub_align >= 0
10339 || ((((stub_off + stub_size - 1) & -stub_align)
10340 - (stub_off & -stub_align))
10341 > ((stub_size - 1) & -stub_align)))
10342 stub_off = (stub_off + stub_align - 1) & -stub_align;
10343 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10344 off -= stub_off + s->output_offset + s->output_section->vma;
10345 /* Note that for --plt-stub-align negative we have a possible
10346 dependency between stub offset and size. Break that
10347 dependency by assuming the max stub size when calculating
10348 the stub offset. */
10349 if (PPC_HA (off) == 0)
10351 h->root.type = bfd_link_hash_defined;
10352 h->root.u.def.section = s;
10353 h->root.u.def.value = stub_off;
10354 s->size = stub_off + stub_size;
10360 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10361 read-only sections. */
10364 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10368 if (h->root.type == bfd_link_hash_indirect)
10371 sec = readonly_dynrelocs (h);
10374 struct bfd_link_info *info = (struct bfd_link_info *) inf;
10376 info->flags |= DF_TEXTREL;
10377 info->callbacks->minfo
10378 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10379 sec->owner, h->root.root.string, sec);
10381 /* Not an error, just cut short the traversal. */
10387 /* Set the sizes of the dynamic sections. */
10390 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10391 struct bfd_link_info *info)
10393 struct ppc_link_hash_table *htab;
10396 bfd_boolean relocs;
10398 struct got_entry *first_tlsld;
10400 htab = ppc_hash_table (info);
10404 dynobj = htab->elf.dynobj;
10405 if (dynobj == NULL)
10408 if (htab->elf.dynamic_sections_created)
10410 /* Set the contents of the .interp section to the interpreter. */
10411 if (bfd_link_executable (info) && !info->nointerp)
10413 s = bfd_get_linker_section (dynobj, ".interp");
10416 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10417 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10421 /* Set up .got offsets for local syms, and space for local dynamic
10423 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10425 struct got_entry **lgot_ents;
10426 struct got_entry **end_lgot_ents;
10427 struct plt_entry **local_plt;
10428 struct plt_entry **end_local_plt;
10429 unsigned char *lgot_masks;
10430 bfd_size_type locsymcount;
10431 Elf_Internal_Shdr *symtab_hdr;
10433 if (!is_ppc64_elf (ibfd))
10436 for (s = ibfd->sections; s != NULL; s = s->next)
10438 struct ppc_dyn_relocs *p;
10440 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10442 if (!bfd_is_abs_section (p->sec)
10443 && bfd_is_abs_section (p->sec->output_section))
10445 /* Input section has been discarded, either because
10446 it is a copy of a linkonce section or due to
10447 linker script /DISCARD/, so we'll be discarding
10450 else if (p->count != 0)
10452 asection *srel = elf_section_data (p->sec)->sreloc;
10454 srel = htab->elf.irelplt;
10455 srel->size += p->count * sizeof (Elf64_External_Rela);
10456 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10457 info->flags |= DF_TEXTREL;
10462 lgot_ents = elf_local_got_ents (ibfd);
10466 symtab_hdr = &elf_symtab_hdr (ibfd);
10467 locsymcount = symtab_hdr->sh_info;
10468 end_lgot_ents = lgot_ents + locsymcount;
10469 local_plt = (struct plt_entry **) end_lgot_ents;
10470 end_local_plt = local_plt + locsymcount;
10471 lgot_masks = (unsigned char *) end_local_plt;
10472 s = ppc64_elf_tdata (ibfd)->got;
10473 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10475 struct got_entry **pent, *ent;
10478 while ((ent = *pent) != NULL)
10479 if (ent->got.refcount > 0)
10481 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10483 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10488 unsigned int ent_size = 8;
10489 unsigned int rel_size = sizeof (Elf64_External_Rela);
10491 ent->got.offset = s->size;
10492 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10497 s->size += ent_size;
10498 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10500 htab->elf.irelplt->size += rel_size;
10501 htab->got_reli_size += rel_size;
10503 else if (bfd_link_pic (info)
10504 && !((ent->tls_type & TLS_TPREL) != 0
10505 && bfd_link_executable (info)))
10507 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10508 srel->size += rel_size;
10517 /* Allocate space for plt calls to local syms. */
10518 lgot_masks = (unsigned char *) end_local_plt;
10519 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10521 struct plt_entry *ent;
10523 for (ent = *local_plt; ent != NULL; ent = ent->next)
10524 if (ent->plt.refcount > 0)
10526 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10528 s = htab->elf.iplt;
10529 ent->plt.offset = s->size;
10530 s->size += PLT_ENTRY_SIZE (htab);
10531 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10533 else if (htab->can_convert_all_inline_plt
10534 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10535 ent->plt.offset = (bfd_vma) -1;
10538 s = htab->pltlocal;
10539 ent->plt.offset = s->size;
10540 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10541 if (bfd_link_pic (info))
10542 htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10546 ent->plt.offset = (bfd_vma) -1;
10550 /* Allocate global sym .plt and .got entries, and space for global
10551 sym dynamic relocs. */
10552 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10554 if (!htab->opd_abi && !bfd_link_pic (info))
10555 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10557 first_tlsld = NULL;
10558 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10560 struct got_entry *ent;
10562 if (!is_ppc64_elf (ibfd))
10565 ent = ppc64_tlsld_got (ibfd);
10566 if (ent->got.refcount > 0)
10568 if (!htab->do_multi_toc && first_tlsld != NULL)
10570 ent->is_indirect = TRUE;
10571 ent->got.ent = first_tlsld;
10575 if (first_tlsld == NULL)
10577 s = ppc64_elf_tdata (ibfd)->got;
10578 ent->got.offset = s->size;
10581 if (bfd_link_pic (info))
10583 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10584 srel->size += sizeof (Elf64_External_Rela);
10589 ent->got.offset = (bfd_vma) -1;
10592 /* We now have determined the sizes of the various dynamic sections.
10593 Allocate memory for them. */
10595 for (s = dynobj->sections; s != NULL; s = s->next)
10597 if ((s->flags & SEC_LINKER_CREATED) == 0)
10600 if (s == htab->brlt || s == htab->relbrlt)
10601 /* These haven't been allocated yet; don't strip. */
10603 else if (s == htab->elf.sgot
10604 || s == htab->elf.splt
10605 || s == htab->elf.iplt
10606 || s == htab->pltlocal
10607 || s == htab->glink
10608 || s == htab->global_entry
10609 || s == htab->elf.sdynbss
10610 || s == htab->elf.sdynrelro)
10612 /* Strip this section if we don't need it; see the
10615 else if (s == htab->glink_eh_frame)
10617 if (!bfd_is_abs_section (s->output_section))
10618 /* Not sized yet. */
10621 else if (CONST_STRNEQ (s->name, ".rela"))
10625 if (s != htab->elf.srelplt)
10628 /* We use the reloc_count field as a counter if we need
10629 to copy relocs into the output file. */
10630 s->reloc_count = 0;
10635 /* It's not one of our sections, so don't allocate space. */
10641 /* If we don't need this section, strip it from the
10642 output file. This is mostly to handle .rela.bss and
10643 .rela.plt. We must create both sections in
10644 create_dynamic_sections, because they must be created
10645 before the linker maps input sections to output
10646 sections. The linker does that before
10647 adjust_dynamic_symbol is called, and it is that
10648 function which decides whether anything needs to go
10649 into these sections. */
10650 s->flags |= SEC_EXCLUDE;
10654 if (bfd_is_abs_section (s->output_section))
10655 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10658 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10661 /* Allocate memory for the section contents. We use bfd_zalloc
10662 here in case unused entries are not reclaimed before the
10663 section's contents are written out. This should not happen,
10664 but this way if it does we get a R_PPC64_NONE reloc in .rela
10665 sections instead of garbage.
10666 We also rely on the section contents being zero when writing
10667 the GOT and .dynrelro. */
10668 s->contents = bfd_zalloc (dynobj, s->size);
10669 if (s->contents == NULL)
10673 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10675 if (!is_ppc64_elf (ibfd))
10678 s = ppc64_elf_tdata (ibfd)->got;
10679 if (s != NULL && s != htab->elf.sgot)
10682 s->flags |= SEC_EXCLUDE;
10685 s->contents = bfd_zalloc (ibfd, s->size);
10686 if (s->contents == NULL)
10690 s = ppc64_elf_tdata (ibfd)->relgot;
10694 s->flags |= SEC_EXCLUDE;
10697 s->contents = bfd_zalloc (ibfd, s->size);
10698 if (s->contents == NULL)
10701 s->reloc_count = 0;
10706 if (htab->elf.dynamic_sections_created)
10708 bfd_boolean tls_opt;
10710 /* Add some entries to the .dynamic section. We fill in the
10711 values later, in ppc64_elf_finish_dynamic_sections, but we
10712 must add the entries now so that we get the correct size for
10713 the .dynamic section. The DT_DEBUG entry is filled in by the
10714 dynamic linker and used by the debugger. */
10715 #define add_dynamic_entry(TAG, VAL) \
10716 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10718 if (bfd_link_executable (info))
10720 if (!add_dynamic_entry (DT_DEBUG, 0))
10724 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10726 if (!add_dynamic_entry (DT_PLTGOT, 0)
10727 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10728 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10729 || !add_dynamic_entry (DT_JMPREL, 0)
10730 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10734 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10736 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10737 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10741 tls_opt = (htab->params->tls_get_addr_opt
10742 && htab->tls_get_addr_fd != NULL
10743 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10744 if (tls_opt || !htab->opd_abi)
10746 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10752 if (!add_dynamic_entry (DT_RELA, 0)
10753 || !add_dynamic_entry (DT_RELASZ, 0)
10754 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10757 /* If any dynamic relocs apply to a read-only section,
10758 then we need a DT_TEXTREL entry. */
10759 if ((info->flags & DF_TEXTREL) == 0)
10760 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10762 if ((info->flags & DF_TEXTREL) != 0)
10764 if (!add_dynamic_entry (DT_TEXTREL, 0))
10769 #undef add_dynamic_entry
10774 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10777 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10779 if (h->plt.plist != NULL
10781 && !h->pointer_equality_needed)
10784 return _bfd_elf_hash_symbol (h);
10787 /* Determine the type of stub needed, if any, for a call. */
10789 static inline enum ppc_stub_type
10790 ppc_type_of_stub (asection *input_sec,
10791 const Elf_Internal_Rela *rel,
10792 struct ppc_link_hash_entry **hash,
10793 struct plt_entry **plt_ent,
10794 bfd_vma destination,
10795 unsigned long local_off)
10797 struct ppc_link_hash_entry *h = *hash;
10799 bfd_vma branch_offset;
10800 bfd_vma max_branch_offset;
10801 enum elf_ppc64_reloc_type r_type;
10805 struct plt_entry *ent;
10806 struct ppc_link_hash_entry *fdh = h;
10808 && h->oh->is_func_descriptor)
10810 fdh = ppc_follow_link (h->oh);
10814 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10815 if (ent->addend == rel->r_addend
10816 && ent->plt.offset != (bfd_vma) -1)
10819 return ppc_stub_plt_call;
10822 /* Here, we know we don't have a plt entry. If we don't have a
10823 either a defined function descriptor or a defined entry symbol
10824 in a regular object file, then it is pointless trying to make
10825 any other type of stub. */
10826 if (!is_static_defined (&fdh->elf)
10827 && !is_static_defined (&h->elf))
10828 return ppc_stub_none;
10830 else if (elf_local_got_ents (input_sec->owner) != NULL)
10832 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10833 struct plt_entry **local_plt = (struct plt_entry **)
10834 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10835 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10837 if (local_plt[r_symndx] != NULL)
10839 struct plt_entry *ent;
10841 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10842 if (ent->addend == rel->r_addend
10843 && ent->plt.offset != (bfd_vma) -1)
10846 return ppc_stub_plt_call;
10851 /* Determine where the call point is. */
10852 location = (input_sec->output_offset
10853 + input_sec->output_section->vma
10856 branch_offset = destination - location;
10857 r_type = ELF64_R_TYPE (rel->r_info);
10859 /* Determine if a long branch stub is needed. */
10860 max_branch_offset = 1 << 25;
10861 if (r_type == R_PPC64_REL14
10862 || r_type == R_PPC64_REL14_BRTAKEN
10863 || r_type == R_PPC64_REL14_BRNTAKEN)
10864 max_branch_offset = 1 << 15;
10866 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10867 /* We need a stub. Figure out whether a long_branch or plt_branch
10868 is needed later. */
10869 return ppc_stub_long_branch;
10871 return ppc_stub_none;
10874 /* Builds a 64-bit offset in r12 then adds it to r11 (LOAD false) or
10875 loads r12 from r11+r12 (LOAD true).
10876 . lis %r12,xxx-1b@highest
10877 . ori %r12,xxx-1b@higher
10878 . sldi %r12,%r12,32
10879 . oris %r12,%r12,xxx-1b@hi
10880 . ori %r12,%r12,xxx-1b@l
10881 . add %r12,%r11,%r12 */
10884 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10886 if (off + 0x8000 < 0x10000)
10889 bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10891 bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10894 else if (off + 0x80008000ULL < 0x100000000ULL)
10896 bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10899 bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10901 bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10906 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10908 bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10913 bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10915 if (((off >> 32) & 0xffff) != 0)
10917 bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10921 if (((off >> 32) & 0xffffffffULL) != 0)
10923 bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10926 if (PPC_HI (off) != 0)
10928 bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10931 if (PPC_LO (off) != 0)
10933 bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10937 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10939 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10945 static unsigned int
10946 size_offset (bfd_vma off)
10949 if (off + 0x8000 < 0x10000)
10951 else if (off + 0x80008000ULL < 0x100000000ULL)
10955 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10960 if (((off >> 32) & 0xffff) != 0)
10963 if (((off >> 32) & 0xffffffffULL) != 0)
10965 if (PPC_HI (off) != 0)
10967 if (PPC_LO (off) != 0)
10974 /* Emit .eh_frame opcode to advance pc by DELTA. */
10977 eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
10981 *eh++ = DW_CFA_advance_loc + delta;
10982 else if (delta < 256)
10984 *eh++ = DW_CFA_advance_loc1;
10987 else if (delta < 65536)
10989 *eh++ = DW_CFA_advance_loc2;
10990 bfd_put_16 (abfd, delta, eh);
10995 *eh++ = DW_CFA_advance_loc4;
10996 bfd_put_32 (abfd, delta, eh);
11002 /* Size of required .eh_frame opcode to advance pc by DELTA. */
11004 static unsigned int
11005 eh_advance_size (unsigned int delta)
11007 if (delta < 64 * 4)
11008 /* DW_CFA_advance_loc+[1..63]. */
11010 if (delta < 256 * 4)
11011 /* DW_CFA_advance_loc1, byte. */
11013 if (delta < 65536 * 4)
11014 /* DW_CFA_advance_loc2, 2 bytes. */
11016 /* DW_CFA_advance_loc4, 4 bytes. */
11020 /* With power7 weakly ordered memory model, it is possible for ld.so
11021 to update a plt entry in one thread and have another thread see a
11022 stale zero toc entry. To avoid this we need some sort of acquire
11023 barrier in the call stub. One solution is to make the load of the
11024 toc word seem to appear to depend on the load of the function entry
11025 word. Another solution is to test for r2 being zero, and branch to
11026 the appropriate glink entry if so.
11028 . fake dep barrier compare
11029 . ld 12,xxx(2) ld 12,xxx(2)
11030 . mtctr 12 mtctr 12
11031 . xor 11,12,12 ld 2,xxx+8(2)
11032 . add 2,2,11 cmpldi 2,0
11033 . ld 2,xxx+8(2) bnectr+
11034 . bctr b <glink_entry>
11036 The solution involving the compare turns out to be faster, so
11037 that's what we use unless the branch won't reach. */
11039 #define ALWAYS_USE_FAKE_DEP 0
11040 #define ALWAYS_EMIT_R2SAVE 0
11042 static inline unsigned int
11043 plt_stub_size (struct ppc_link_hash_table *htab,
11044 struct ppc_stub_hash_entry *stub_entry,
11049 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11051 size = 24 + size_offset (off);
11052 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11058 if (ALWAYS_EMIT_R2SAVE
11059 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11061 if (PPC_HA (off) != 0)
11066 if (htab->params->plt_static_chain)
11068 if (htab->params->plt_thread_safe
11069 && htab->elf.dynamic_sections_created
11070 && stub_entry->h != NULL
11071 && stub_entry->h->elf.dynindx != -1)
11073 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
11076 if (stub_entry->h != NULL
11077 && (stub_entry->h == htab->tls_get_addr_fd
11078 || stub_entry->h == htab->tls_get_addr)
11079 && htab->params->tls_get_addr_opt)
11082 if (stub_entry->stub_type == ppc_stub_plt_call_r2save)
11088 /* Depending on the sign of plt_stub_align:
11089 If positive, return the padding to align to a 2**plt_stub_align
11091 If negative, if this stub would cross fewer 2**plt_stub_align
11092 boundaries if we align, then return the padding needed to do so. */
11094 static inline unsigned int
11095 plt_stub_pad (struct ppc_link_hash_table *htab,
11096 struct ppc_stub_hash_entry *stub_entry,
11100 unsigned stub_size;
11101 bfd_vma stub_off = stub_entry->group->stub_sec->size;
11103 if (htab->params->plt_stub_align >= 0)
11105 stub_align = 1 << htab->params->plt_stub_align;
11106 if ((stub_off & (stub_align - 1)) != 0)
11107 return stub_align - (stub_off & (stub_align - 1));
11111 stub_align = 1 << -htab->params->plt_stub_align;
11112 stub_size = plt_stub_size (htab, stub_entry, plt_off);
11113 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11114 > ((stub_size - 1) & -stub_align))
11115 return stub_align - (stub_off & (stub_align - 1));
11119 /* Build a .plt call stub. */
11121 static inline bfd_byte *
11122 build_plt_stub (struct ppc_link_hash_table *htab,
11123 struct ppc_stub_hash_entry *stub_entry,
11124 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11126 bfd *obfd = htab->params->stub_bfd;
11127 bfd_boolean plt_load_toc = htab->opd_abi;
11128 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
11129 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
11130 && htab->elf.dynamic_sections_created
11131 && stub_entry->h != NULL
11132 && stub_entry->h->elf.dynindx != -1);
11133 bfd_boolean use_fake_dep = plt_thread_safe;
11134 bfd_vma cmp_branch_off = 0;
11136 if (!ALWAYS_USE_FAKE_DEP
11139 && !((stub_entry->h == htab->tls_get_addr_fd
11140 || stub_entry->h == htab->tls_get_addr)
11141 && htab->params->tls_get_addr_opt))
11143 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11144 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11145 / PLT_ENTRY_SIZE (htab));
11146 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11149 if (pltindex > 32768)
11150 glinkoff += (pltindex - 32768) * 4;
11152 + htab->glink->output_offset
11153 + htab->glink->output_section->vma);
11154 from = (p - stub_entry->group->stub_sec->contents
11155 + 4 * (ALWAYS_EMIT_R2SAVE
11156 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11157 + 4 * (PPC_HA (offset) != 0)
11158 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11159 != PPC_HA (offset))
11160 + 4 * (plt_static_chain != 0)
11162 + stub_entry->group->stub_sec->output_offset
11163 + stub_entry->group->stub_sec->output_section->vma);
11164 cmp_branch_off = to - from;
11165 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11168 if (PPC_HA (offset) != 0)
11172 if (ALWAYS_EMIT_R2SAVE
11173 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11174 r[0].r_offset += 4;
11175 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11176 r[1].r_offset = r[0].r_offset + 4;
11177 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11178 r[1].r_addend = r[0].r_addend;
11181 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11183 r[2].r_offset = r[1].r_offset + 4;
11184 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11185 r[2].r_addend = r[0].r_addend;
11189 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11190 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11191 r[2].r_addend = r[0].r_addend + 8;
11192 if (plt_static_chain)
11194 r[3].r_offset = r[2].r_offset + 4;
11195 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11196 r[3].r_addend = r[0].r_addend + 16;
11201 if (ALWAYS_EMIT_R2SAVE
11202 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11203 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11206 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11207 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
11211 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11212 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
11215 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11217 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11220 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11225 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
11226 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
11228 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11229 if (plt_static_chain)
11230 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11237 if (ALWAYS_EMIT_R2SAVE
11238 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11239 r[0].r_offset += 4;
11240 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11243 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11245 r[1].r_offset = r[0].r_offset + 4;
11246 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11247 r[1].r_addend = r[0].r_addend;
11251 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11252 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11253 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11254 if (plt_static_chain)
11256 r[2].r_offset = r[1].r_offset + 4;
11257 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11258 r[2].r_addend = r[0].r_addend + 8;
11263 if (ALWAYS_EMIT_R2SAVE
11264 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11265 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11266 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
11268 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11270 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
11273 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11278 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
11279 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
11281 if (plt_static_chain)
11282 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11283 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11286 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11288 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
11289 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
11290 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11293 bfd_put_32 (obfd, BCTR, p), p += 4;
11297 /* Build a special .plt call stub for __tls_get_addr. */
11299 #define LD_R11_0R3 0xe9630000
11300 #define LD_R12_0R3 0xe9830000
11301 #define MR_R0_R3 0x7c601b78
11302 #define CMPDI_R11_0 0x2c2b0000
11303 #define ADD_R3_R12_R13 0x7c6c6a14
11304 #define BEQLR 0x4d820020
11305 #define MR_R3_R0 0x7c030378
11306 #define STD_R11_0R1 0xf9610000
11307 #define BCTRL 0x4e800421
11308 #define LD_R11_0R1 0xe9610000
11309 #define MTLR_R11 0x7d6803a6
11311 static inline bfd_byte *
11312 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11313 struct ppc_stub_hash_entry *stub_entry,
11314 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11316 bfd *obfd = htab->params->stub_bfd;
11319 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
11320 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
11321 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
11322 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
11323 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
11324 bfd_put_32 (obfd, BEQLR, p), p += 4;
11325 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
11327 r[0].r_offset += 7 * 4;
11328 if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
11329 return build_plt_stub (htab, stub_entry, p, offset, r);
11331 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
11332 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11335 r[0].r_offset += 2 * 4;
11336 p = build_plt_stub (htab, stub_entry, p, offset, r);
11337 bfd_put_32 (obfd, BCTRL, p - 4);
11339 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
11340 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11341 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
11342 bfd_put_32 (obfd, BLR, p), p += 4;
11344 if (htab->glink_eh_frame != NULL
11345 && htab->glink_eh_frame->size != 0)
11347 bfd_byte *base, *eh;
11348 unsigned int lr_used, delta;
11350 base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
11351 eh = base + stub_entry->group->eh_size;
11352 lr_used = stub_entry->stub_offset + (p - 20 - loc);
11353 delta = lr_used - stub_entry->group->lr_restore;
11354 stub_entry->group->lr_restore = lr_used + 16;
11355 eh = eh_advance (htab->elf.dynobj, eh, delta);
11356 *eh++ = DW_CFA_offset_extended_sf;
11358 *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
11359 *eh++ = DW_CFA_advance_loc + 4;
11360 *eh++ = DW_CFA_restore_extended;
11362 stub_entry->group->eh_size = eh - base;
11367 static Elf_Internal_Rela *
11368 get_relocs (asection *sec, int count)
11370 Elf_Internal_Rela *relocs;
11371 struct bfd_elf_section_data *elfsec_data;
11373 elfsec_data = elf_section_data (sec);
11374 relocs = elfsec_data->relocs;
11375 if (relocs == NULL)
11377 bfd_size_type relsize;
11378 relsize = sec->reloc_count * sizeof (*relocs);
11379 relocs = bfd_alloc (sec->owner, relsize);
11380 if (relocs == NULL)
11382 elfsec_data->relocs = relocs;
11383 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11384 sizeof (Elf_Internal_Shdr));
11385 if (elfsec_data->rela.hdr == NULL)
11387 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11388 * sizeof (Elf64_External_Rela));
11389 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11390 sec->reloc_count = 0;
11392 relocs += sec->reloc_count;
11393 sec->reloc_count += count;
11398 get_r2off (struct bfd_link_info *info,
11399 struct ppc_stub_hash_entry *stub_entry)
11401 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11402 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11406 /* Support linking -R objects. Get the toc pointer from the
11409 if (!htab->opd_abi)
11411 asection *opd = stub_entry->h->elf.root.u.def.section;
11412 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11414 if (strcmp (opd->name, ".opd") != 0
11415 || opd->reloc_count != 0)
11417 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11418 stub_entry->h->elf.root.root.string);
11419 bfd_set_error (bfd_error_bad_value);
11420 return (bfd_vma) -1;
11422 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11423 return (bfd_vma) -1;
11424 r2off = bfd_get_64 (opd->owner, buf);
11425 r2off -= elf_gp (info->output_bfd);
11427 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11432 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11434 struct ppc_stub_hash_entry *stub_entry;
11435 struct ppc_branch_hash_entry *br_entry;
11436 struct bfd_link_info *info;
11437 struct ppc_link_hash_table *htab;
11441 Elf_Internal_Rela *r;
11444 /* Massage our args to the form they really have. */
11445 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11448 htab = ppc_hash_table (info);
11452 BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11453 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11455 htab->stub_count[stub_entry->stub_type - 1] += 1;
11456 switch (stub_entry->stub_type)
11458 case ppc_stub_long_branch:
11459 case ppc_stub_long_branch_r2off:
11460 /* Branches are relative. This is where we are going to. */
11461 targ = (stub_entry->target_value
11462 + stub_entry->target_section->output_offset
11463 + stub_entry->target_section->output_section->vma);
11464 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11466 /* And this is where we are coming from. */
11467 off = (stub_entry->stub_offset
11468 + stub_entry->group->stub_sec->output_offset
11469 + stub_entry->group->stub_sec->output_section->vma);
11473 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11475 bfd_vma r2off = get_r2off (info, stub_entry);
11477 if (r2off == (bfd_vma) -1)
11479 htab->stub_error = TRUE;
11482 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11484 if (PPC_HA (r2off) != 0)
11486 bfd_put_32 (htab->params->stub_bfd,
11487 ADDIS_R2_R2 | PPC_HA (r2off), p);
11490 if (PPC_LO (r2off) != 0)
11492 bfd_put_32 (htab->params->stub_bfd,
11493 ADDI_R2_R2 | PPC_LO (r2off), p);
11498 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11501 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11504 (_("long branch stub `%s' offset overflow"),
11505 stub_entry->root.string);
11506 htab->stub_error = TRUE;
11510 if (info->emitrelocations)
11512 r = get_relocs (stub_entry->group->stub_sec, 1);
11515 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11516 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11517 r->r_addend = targ;
11518 if (stub_entry->h != NULL)
11520 struct elf_link_hash_entry **hashes;
11521 unsigned long symndx;
11522 struct ppc_link_hash_entry *h;
11524 hashes = elf_sym_hashes (htab->params->stub_bfd);
11525 if (hashes == NULL)
11527 bfd_size_type hsize;
11529 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11530 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11531 if (hashes == NULL)
11533 elf_sym_hashes (htab->params->stub_bfd) = hashes;
11534 htab->stub_globals = 1;
11536 symndx = htab->stub_globals++;
11538 hashes[symndx] = &h->elf;
11539 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11540 if (h->oh != NULL && h->oh->is_func)
11541 h = ppc_follow_link (h->oh);
11542 if (h->elf.root.u.def.section != stub_entry->target_section)
11543 /* H is an opd symbol. The addend must be zero. */
11547 off = (h->elf.root.u.def.value
11548 + h->elf.root.u.def.section->output_offset
11549 + h->elf.root.u.def.section->output_section->vma);
11550 r->r_addend -= off;
11556 case ppc_stub_plt_branch:
11557 case ppc_stub_plt_branch_r2off:
11558 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11559 stub_entry->root.string + 9,
11561 if (br_entry == NULL)
11563 _bfd_error_handler (_("can't find branch stub `%s'"),
11564 stub_entry->root.string);
11565 htab->stub_error = TRUE;
11569 targ = (stub_entry->target_value
11570 + stub_entry->target_section->output_offset
11571 + stub_entry->target_section->output_section->vma);
11572 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11573 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11575 bfd_put_64 (htab->brlt->owner, targ,
11576 htab->brlt->contents + br_entry->offset);
11578 if (br_entry->iter == htab->stub_iteration)
11580 br_entry->iter = 0;
11582 if (htab->relbrlt != NULL)
11584 /* Create a reloc for the branch lookup table entry. */
11585 Elf_Internal_Rela rela;
11588 rela.r_offset = (br_entry->offset
11589 + htab->brlt->output_offset
11590 + htab->brlt->output_section->vma);
11591 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11592 rela.r_addend = targ;
11594 rl = htab->relbrlt->contents;
11595 rl += (htab->relbrlt->reloc_count++
11596 * sizeof (Elf64_External_Rela));
11597 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11599 else if (info->emitrelocations)
11601 r = get_relocs (htab->brlt, 1);
11604 /* brlt, being SEC_LINKER_CREATED does not go through the
11605 normal reloc processing. Symbols and offsets are not
11606 translated from input file to output file form, so
11607 set up the offset per the output file. */
11608 r->r_offset = (br_entry->offset
11609 + htab->brlt->output_offset
11610 + htab->brlt->output_section->vma);
11611 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11612 r->r_addend = targ;
11616 targ = (br_entry->offset
11617 + htab->brlt->output_offset
11618 + htab->brlt->output_section->vma);
11620 off = (elf_gp (info->output_bfd)
11621 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11624 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11626 info->callbacks->einfo
11627 (_("%P: linkage table error against `%pT'\n"),
11628 stub_entry->root.string);
11629 bfd_set_error (bfd_error_bad_value);
11630 htab->stub_error = TRUE;
11634 if (info->emitrelocations)
11636 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11639 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11640 if (bfd_big_endian (info->output_bfd))
11641 r[0].r_offset += 2;
11642 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11643 r[0].r_offset += 4;
11644 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11645 r[0].r_addend = targ;
11646 if (PPC_HA (off) != 0)
11648 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11649 r[1].r_offset = r[0].r_offset + 4;
11650 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11651 r[1].r_addend = r[0].r_addend;
11656 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11658 if (PPC_HA (off) != 0)
11660 bfd_put_32 (htab->params->stub_bfd,
11661 ADDIS_R12_R2 | PPC_HA (off), p);
11663 bfd_put_32 (htab->params->stub_bfd,
11664 LD_R12_0R12 | PPC_LO (off), p);
11667 bfd_put_32 (htab->params->stub_bfd,
11668 LD_R12_0R2 | PPC_LO (off), p);
11672 bfd_vma r2off = get_r2off (info, stub_entry);
11674 if (r2off == (bfd_vma) -1)
11676 htab->stub_error = TRUE;
11680 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11682 if (PPC_HA (off) != 0)
11684 bfd_put_32 (htab->params->stub_bfd,
11685 ADDIS_R12_R2 | PPC_HA (off), p);
11687 bfd_put_32 (htab->params->stub_bfd,
11688 LD_R12_0R12 | PPC_LO (off), p);
11691 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11693 if (PPC_HA (r2off) != 0)
11696 bfd_put_32 (htab->params->stub_bfd,
11697 ADDIS_R2_R2 | PPC_HA (r2off), p);
11699 if (PPC_LO (r2off) != 0)
11702 bfd_put_32 (htab->params->stub_bfd,
11703 ADDI_R2_R2 | PPC_LO (r2off), p);
11707 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11709 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11713 case ppc_stub_long_branch_notoc:
11714 case ppc_stub_long_branch_both:
11715 case ppc_stub_plt_branch_notoc:
11716 case ppc_stub_plt_branch_both:
11717 case ppc_stub_plt_call_notoc:
11718 case ppc_stub_plt_call_both:
11720 off = (8 + stub_entry->stub_offset
11721 + stub_entry->group->stub_sec->output_offset
11722 + stub_entry->group->stub_sec->output_section->vma);
11723 if (stub_entry->stub_type == ppc_stub_long_branch_both
11724 || stub_entry->stub_type == ppc_stub_plt_branch_both
11725 || stub_entry->stub_type == ppc_stub_plt_call_both)
11728 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11731 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11733 targ = stub_entry->plt_ent->plt.offset & ~1;
11734 if (targ >= (bfd_vma) -2)
11737 plt = htab->elf.splt;
11738 if (!htab->elf.dynamic_sections_created
11739 || stub_entry->h == NULL
11740 || stub_entry->h->elf.dynindx == -1)
11742 if (stub_entry->symtype == STT_GNU_IFUNC)
11743 plt = htab->elf.iplt;
11745 plt = htab->pltlocal;
11747 targ += plt->output_offset + plt->output_section->vma;
11750 targ = (stub_entry->target_value
11751 + stub_entry->target_section->output_offset
11752 + stub_entry->target_section->output_section->vma);
11754 bfd_put_32 (htab->params->stub_bfd, MFLR_R12, p);
11756 bfd_put_32 (htab->params->stub_bfd, BCL_20_31, p);
11758 bfd_put_32 (htab->params->stub_bfd, MFLR_R11, p);
11760 bfd_put_32 (htab->params->stub_bfd, MTLR_R12, p);
11762 p = build_offset (htab->params->stub_bfd, p, off,
11763 stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11764 if (stub_entry->stub_type == ppc_stub_long_branch_notoc)
11767 bfd_put_32 (htab->params->stub_bfd,
11768 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11770 else if (stub_entry->stub_type == ppc_stub_long_branch_both)
11773 bfd_put_32 (htab->params->stub_bfd,
11774 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11778 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11780 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11784 if (htab->glink_eh_frame != NULL
11785 && htab->glink_eh_frame->size != 0)
11787 bfd_byte *base, *eh;
11788 unsigned int lr_used, delta;
11790 base = (htab->glink_eh_frame->contents
11791 + stub_entry->group->eh_base + 17);
11792 eh = base + stub_entry->group->eh_size;
11793 lr_used = stub_entry->stub_offset + 8;
11794 if (stub_entry->stub_type == ppc_stub_long_branch_both
11795 || stub_entry->stub_type == ppc_stub_plt_branch_both
11796 || stub_entry->stub_type == ppc_stub_plt_call_both)
11798 delta = lr_used - stub_entry->group->lr_restore;
11799 stub_entry->group->lr_restore = lr_used + 8;
11800 eh = eh_advance (htab->elf.dynobj, eh, delta);
11801 *eh++ = DW_CFA_register;
11804 *eh++ = DW_CFA_advance_loc + 2;
11805 *eh++ = DW_CFA_restore_extended;
11807 stub_entry->group->eh_size = eh - base;
11811 case ppc_stub_plt_call:
11812 case ppc_stub_plt_call_r2save:
11813 if (stub_entry->h != NULL
11814 && stub_entry->h->is_func_descriptor
11815 && stub_entry->h->oh != NULL)
11817 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11819 /* If the old-ABI "dot-symbol" is undefined make it weak so
11820 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11821 if (fh->elf.root.type == bfd_link_hash_undefined
11822 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11823 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11824 fh->elf.root.type = bfd_link_hash_undefweak;
11827 /* Now build the stub. */
11828 targ = stub_entry->plt_ent->plt.offset & ~1;
11829 if (targ >= (bfd_vma) -2)
11832 plt = htab->elf.splt;
11833 if (!htab->elf.dynamic_sections_created
11834 || stub_entry->h == NULL
11835 || stub_entry->h->elf.dynindx == -1)
11837 if (stub_entry->symtype == STT_GNU_IFUNC)
11838 plt = htab->elf.iplt;
11840 plt = htab->pltlocal;
11842 targ += plt->output_offset + plt->output_section->vma;
11844 off = (elf_gp (info->output_bfd)
11845 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11848 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11850 info->callbacks->einfo
11851 /* xgettext:c-format */
11852 (_("%P: linkage table error against `%pT'\n"),
11853 stub_entry->h != NULL
11854 ? stub_entry->h->elf.root.root.string
11856 bfd_set_error (bfd_error_bad_value);
11857 htab->stub_error = TRUE;
11862 if (info->emitrelocations)
11864 r = get_relocs (stub_entry->group->stub_sec,
11865 ((PPC_HA (off) != 0)
11867 ? 2 + (htab->params->plt_static_chain
11868 && PPC_HA (off + 16) == PPC_HA (off))
11872 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11873 if (bfd_big_endian (info->output_bfd))
11874 r[0].r_offset += 2;
11875 r[0].r_addend = targ;
11877 if (stub_entry->h != NULL
11878 && (stub_entry->h == htab->tls_get_addr_fd
11879 || stub_entry->h == htab->tls_get_addr)
11880 && htab->params->tls_get_addr_opt)
11881 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11883 p = build_plt_stub (htab, stub_entry, loc, off, r);
11886 case ppc_stub_save_res:
11894 stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11896 if (htab->params->emit_stub_syms)
11898 struct elf_link_hash_entry *h;
11901 const char *const stub_str[] = { "long_branch",
11914 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11915 len2 = strlen (stub_entry->root.string);
11916 name = bfd_malloc (len1 + len2 + 2);
11919 memcpy (name, stub_entry->root.string, 9);
11920 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11921 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11922 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11925 if (h->root.type == bfd_link_hash_new)
11927 h->root.type = bfd_link_hash_defined;
11928 h->root.u.def.section = stub_entry->group->stub_sec;
11929 h->root.u.def.value = stub_entry->stub_offset;
11930 h->ref_regular = 1;
11931 h->def_regular = 1;
11932 h->ref_regular_nonweak = 1;
11933 h->forced_local = 1;
11935 h->root.linker_def = 1;
11942 /* As above, but don't actually build the stub. Just bump offset so
11943 we know stub section sizes, and select plt_branch stubs where
11944 long_branch stubs won't do. */
11947 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11949 struct ppc_stub_hash_entry *stub_entry;
11950 struct bfd_link_info *info;
11951 struct ppc_link_hash_table *htab;
11955 /* Massage our args to the form they really have. */
11956 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11959 htab = ppc_hash_table (info);
11963 /* Make a note of the offset within the stubs for this entry. */
11964 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11966 if (stub_entry->h != NULL
11967 && stub_entry->h->save_res
11968 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11969 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11971 /* Don't make stubs to out-of-line register save/restore
11972 functions. Instead, emit copies of the functions. */
11973 stub_entry->group->needs_save_res = 1;
11974 stub_entry->stub_type = ppc_stub_save_res;
11978 if (stub_entry->stub_type >= ppc_stub_plt_call
11979 && stub_entry->stub_type <= ppc_stub_plt_call_both)
11982 targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11983 if (targ >= (bfd_vma) -2)
11985 plt = htab->elf.splt;
11986 if (!htab->elf.dynamic_sections_created
11987 || stub_entry->h == NULL
11988 || stub_entry->h->elf.dynindx == -1)
11990 if (stub_entry->symtype == STT_GNU_IFUNC)
11991 plt = htab->elf.iplt;
11993 plt = htab->pltlocal;
11995 targ += plt->output_offset + plt->output_section->vma;
11997 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11999 off = (8 + stub_entry->stub_offset
12000 + stub_entry->group->stub_sec->output_offset
12001 + stub_entry->group->stub_sec->output_section->vma);
12002 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12006 off = (elf_gp (info->output_bfd)
12007 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12009 if (htab->params->plt_stub_align != 0)
12011 unsigned pad = plt_stub_pad (htab, stub_entry, targ - off);
12013 stub_entry->group->stub_sec->size += pad;
12014 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
12015 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12020 size = plt_stub_size (htab, stub_entry, off);
12022 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12024 /* After the bcl, lr has been modified so we need to emit
12025 .eh_frame info saying the return address is in r12. */
12026 unsigned int lr_used = stub_entry->stub_offset + 8;
12027 unsigned int delta;
12028 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12030 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12031 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12032 DW_CFA_restore_extended 65. */
12033 delta = lr_used - stub_entry->group->lr_restore;
12034 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12035 stub_entry->group->lr_restore = lr_used + 8;
12039 if (stub_entry->h != NULL
12040 && (stub_entry->h == htab->tls_get_addr_fd
12041 || stub_entry->h == htab->tls_get_addr)
12042 && htab->params->tls_get_addr_opt
12043 && stub_entry->stub_type == ppc_stub_plt_call_r2save)
12045 /* After the bctrl, lr has been modified so we need to
12046 emit .eh_frame info saying the return address is
12047 on the stack. In fact we put the EH info specifying
12048 that the return address is on the stack *at* the
12049 call rather than after it, because the EH info for a
12050 call needs to be specified by that point.
12051 See libgcc/unwind-dw2.c execute_cfa_program. */
12052 unsigned int lr_used = stub_entry->stub_offset + size - 20;
12053 unsigned int delta;
12054 /* The eh_frame info will consist of a DW_CFA_advance_loc
12055 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12056 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12057 delta = lr_used - stub_entry->group->lr_restore;
12058 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12059 stub_entry->group->lr_restore = size - 4;
12062 if (info->emitrelocations)
12064 stub_entry->group->stub_sec->reloc_count
12065 += ((PPC_HA (off) != 0)
12067 ? 2 + (htab->params->plt_static_chain
12068 && PPC_HA (off + 16) == PPC_HA (off))
12070 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12076 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
12079 bfd_vma local_off = 0;
12081 targ = (stub_entry->target_value
12082 + stub_entry->target_section->output_offset
12083 + stub_entry->target_section->output_section->vma);
12084 off = (stub_entry->stub_offset
12085 + stub_entry->group->stub_sec->output_offset
12086 + stub_entry->group->stub_sec->output_section->vma);
12088 /* Reset the stub type from the plt variant in case we now
12089 can reach with a shorter stub. */
12090 if (stub_entry->stub_type >= ppc_stub_plt_branch)
12091 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
12094 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
12096 r2off = get_r2off (info, stub_entry);
12097 if (r2off == (bfd_vma) -1)
12099 htab->stub_error = TRUE;
12103 if (PPC_HA (r2off) != 0)
12105 if (PPC_LO (r2off) != 0)
12109 else if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12111 size = 20 + size_offset (targ - (off + 8));
12112 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12118 if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12120 /* After the bcl, lr has been modified so we need to emit
12121 .eh_frame info saying the return address is in r12. */
12122 unsigned int lr_used = stub_entry->stub_offset + 8;
12123 unsigned int delta;
12124 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12126 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12127 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12128 DW_CFA_restore_extended 65. */
12129 delta = lr_used - stub_entry->group->lr_restore;
12130 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12131 stub_entry->group->lr_restore = lr_used + 8;
12133 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
12135 stub_entry->stub_type += (ppc_stub_plt_branch_notoc
12136 - ppc_stub_long_branch_notoc);
12142 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12144 /* If the branch offset is too big, use a ppc_stub_plt_branch.
12145 Do the same for -R objects without function descriptors. */
12146 if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
12148 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12149 || off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off)
12151 struct ppc_branch_hash_entry *br_entry;
12153 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12154 stub_entry->root.string + 9,
12156 if (br_entry == NULL)
12158 _bfd_error_handler (_("can't build branch stub `%s'"),
12159 stub_entry->root.string);
12160 htab->stub_error = TRUE;
12164 if (br_entry->iter != htab->stub_iteration)
12166 br_entry->iter = htab->stub_iteration;
12167 br_entry->offset = htab->brlt->size;
12168 htab->brlt->size += 8;
12170 if (htab->relbrlt != NULL)
12171 htab->relbrlt->size += sizeof (Elf64_External_Rela);
12172 else if (info->emitrelocations)
12174 htab->brlt->reloc_count += 1;
12175 htab->brlt->flags |= SEC_RELOC;
12179 targ = (br_entry->offset
12180 + htab->brlt->output_offset
12181 + htab->brlt->output_section->vma);
12182 off = (elf_gp (info->output_bfd)
12183 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12186 if (info->emitrelocations)
12188 stub_entry->group->stub_sec->reloc_count
12189 += 1 + (PPC_HA (off) != 0);
12190 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12193 stub_entry->stub_type
12194 += ppc_stub_plt_branch - ppc_stub_long_branch;
12195 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
12198 if (PPC_HA (off) != 0)
12204 if (PPC_HA (off) != 0)
12207 if (PPC_HA (r2off) != 0)
12209 if (PPC_LO (r2off) != 0)
12213 else if (info->emitrelocations)
12215 stub_entry->group->stub_sec->reloc_count += 1;
12216 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12221 stub_entry->group->stub_sec->size += size;
12225 /* Set up various things so that we can make a list of input sections
12226 for each output section included in the link. Returns -1 on error,
12227 0 when no stubs will be needed, and 1 on success. */
12230 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12234 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12239 htab->sec_info_arr_size = _bfd_section_id;
12240 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12241 htab->sec_info = bfd_zmalloc (amt);
12242 if (htab->sec_info == NULL)
12245 /* Set toc_off for com, und, abs and ind sections. */
12246 for (id = 0; id < 3; id++)
12247 htab->sec_info[id].toc_off = TOC_BASE_OFF;
12252 /* Set up for first pass at multitoc partitioning. */
12255 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12257 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12259 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12260 htab->toc_bfd = NULL;
12261 htab->toc_first_sec = NULL;
12264 /* The linker repeatedly calls this function for each TOC input section
12265 and linker generated GOT section. Group input bfds such that the toc
12266 within a group is less than 64k in size. */
12269 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12271 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12272 bfd_vma addr, off, limit;
12277 if (!htab->second_toc_pass)
12279 /* Keep track of the first .toc or .got section for this input bfd. */
12280 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
12284 htab->toc_bfd = isec->owner;
12285 htab->toc_first_sec = isec;
12288 addr = isec->output_offset + isec->output_section->vma;
12289 off = addr - htab->toc_curr;
12290 limit = 0x80008000;
12291 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12293 if (off + isec->size > limit)
12295 addr = (htab->toc_first_sec->output_offset
12296 + htab->toc_first_sec->output_section->vma);
12297 htab->toc_curr = addr;
12298 htab->toc_curr &= -TOC_BASE_ALIGN;
12301 /* toc_curr is the base address of this toc group. Set elf_gp
12302 for the input section to be the offset relative to the
12303 output toc base plus 0x8000. Making the input elf_gp an
12304 offset allows us to move the toc as a whole without
12305 recalculating input elf_gp. */
12306 off = htab->toc_curr - elf_gp (info->output_bfd);
12307 off += TOC_BASE_OFF;
12309 /* Die if someone uses a linker script that doesn't keep input
12310 file .toc and .got together. */
12312 && elf_gp (isec->owner) != 0
12313 && elf_gp (isec->owner) != off)
12316 elf_gp (isec->owner) = off;
12320 /* During the second pass toc_first_sec points to the start of
12321 a toc group, and toc_curr is used to track the old elf_gp.
12322 We use toc_bfd to ensure we only look at each bfd once. */
12323 if (htab->toc_bfd == isec->owner)
12325 htab->toc_bfd = isec->owner;
12327 if (htab->toc_first_sec == NULL
12328 || htab->toc_curr != elf_gp (isec->owner))
12330 htab->toc_curr = elf_gp (isec->owner);
12331 htab->toc_first_sec = isec;
12333 addr = (htab->toc_first_sec->output_offset
12334 + htab->toc_first_sec->output_section->vma);
12335 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12336 elf_gp (isec->owner) = off;
12341 /* Called via elf_link_hash_traverse to merge GOT entries for global
12345 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12347 if (h->root.type == bfd_link_hash_indirect)
12350 merge_got_entries (&h->got.glist);
12355 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12359 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12361 struct got_entry *gent;
12363 if (h->root.type == bfd_link_hash_indirect)
12366 for (gent = h->got.glist; gent != NULL; gent = gent->next)
12367 if (!gent->is_indirect)
12368 allocate_got (h, (struct bfd_link_info *) inf, gent);
12372 /* Called on the first multitoc pass after the last call to
12373 ppc64_elf_next_toc_section. This function removes duplicate GOT
12377 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12379 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12380 struct bfd *ibfd, *ibfd2;
12381 bfd_boolean done_something;
12383 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12385 if (!htab->do_multi_toc)
12388 /* Merge global sym got entries within a toc group. */
12389 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12391 /* And tlsld_got. */
12392 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12394 struct got_entry *ent, *ent2;
12396 if (!is_ppc64_elf (ibfd))
12399 ent = ppc64_tlsld_got (ibfd);
12400 if (!ent->is_indirect
12401 && ent->got.offset != (bfd_vma) -1)
12403 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12405 if (!is_ppc64_elf (ibfd2))
12408 ent2 = ppc64_tlsld_got (ibfd2);
12409 if (!ent2->is_indirect
12410 && ent2->got.offset != (bfd_vma) -1
12411 && elf_gp (ibfd2) == elf_gp (ibfd))
12413 ent2->is_indirect = TRUE;
12414 ent2->got.ent = ent;
12420 /* Zap sizes of got sections. */
12421 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12422 htab->elf.irelplt->size -= htab->got_reli_size;
12423 htab->got_reli_size = 0;
12425 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12427 asection *got, *relgot;
12429 if (!is_ppc64_elf (ibfd))
12432 got = ppc64_elf_tdata (ibfd)->got;
12435 got->rawsize = got->size;
12437 relgot = ppc64_elf_tdata (ibfd)->relgot;
12438 relgot->rawsize = relgot->size;
12443 /* Now reallocate the got, local syms first. We don't need to
12444 allocate section contents again since we never increase size. */
12445 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12447 struct got_entry **lgot_ents;
12448 struct got_entry **end_lgot_ents;
12449 struct plt_entry **local_plt;
12450 struct plt_entry **end_local_plt;
12451 unsigned char *lgot_masks;
12452 bfd_size_type locsymcount;
12453 Elf_Internal_Shdr *symtab_hdr;
12456 if (!is_ppc64_elf (ibfd))
12459 lgot_ents = elf_local_got_ents (ibfd);
12463 symtab_hdr = &elf_symtab_hdr (ibfd);
12464 locsymcount = symtab_hdr->sh_info;
12465 end_lgot_ents = lgot_ents + locsymcount;
12466 local_plt = (struct plt_entry **) end_lgot_ents;
12467 end_local_plt = local_plt + locsymcount;
12468 lgot_masks = (unsigned char *) end_local_plt;
12469 s = ppc64_elf_tdata (ibfd)->got;
12470 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12472 struct got_entry *ent;
12474 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12476 unsigned int ent_size = 8;
12477 unsigned int rel_size = sizeof (Elf64_External_Rela);
12479 ent->got.offset = s->size;
12480 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12485 s->size += ent_size;
12486 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12488 htab->elf.irelplt->size += rel_size;
12489 htab->got_reli_size += rel_size;
12491 else if (bfd_link_pic (info)
12492 && !((ent->tls_type & TLS_TPREL) != 0
12493 && bfd_link_executable (info)))
12495 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12496 srel->size += rel_size;
12502 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12504 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12506 struct got_entry *ent;
12508 if (!is_ppc64_elf (ibfd))
12511 ent = ppc64_tlsld_got (ibfd);
12512 if (!ent->is_indirect
12513 && ent->got.offset != (bfd_vma) -1)
12515 asection *s = ppc64_elf_tdata (ibfd)->got;
12516 ent->got.offset = s->size;
12518 if (bfd_link_pic (info))
12520 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12521 srel->size += sizeof (Elf64_External_Rela);
12526 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12527 if (!done_something)
12528 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12532 if (!is_ppc64_elf (ibfd))
12535 got = ppc64_elf_tdata (ibfd)->got;
12538 done_something = got->rawsize != got->size;
12539 if (done_something)
12544 if (done_something)
12545 (*htab->params->layout_sections_again) ();
12547 /* Set up for second pass over toc sections to recalculate elf_gp
12548 on input sections. */
12549 htab->toc_bfd = NULL;
12550 htab->toc_first_sec = NULL;
12551 htab->second_toc_pass = TRUE;
12552 return done_something;
12555 /* Called after second pass of multitoc partitioning. */
12558 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12560 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12562 /* After the second pass, toc_curr tracks the TOC offset used
12563 for code sections below in ppc64_elf_next_input_section. */
12564 htab->toc_curr = TOC_BASE_OFF;
12567 /* No toc references were found in ISEC. If the code in ISEC makes no
12568 calls, then there's no need to use toc adjusting stubs when branching
12569 into ISEC. Actually, indirect calls from ISEC are OK as they will
12570 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12571 needed, and 2 if a cyclical call-graph was found but no other reason
12572 for a stub was detected. If called from the top level, a return of
12573 2 means the same as a return of 0. */
12576 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12580 /* Mark this section as checked. */
12581 isec->call_check_done = 1;
12583 /* We know none of our code bearing sections will need toc stubs. */
12584 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12587 if (isec->size == 0)
12590 if (isec->output_section == NULL)
12594 if (isec->reloc_count != 0)
12596 Elf_Internal_Rela *relstart, *rel;
12597 Elf_Internal_Sym *local_syms;
12598 struct ppc_link_hash_table *htab;
12600 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12601 info->keep_memory);
12602 if (relstart == NULL)
12605 /* Look for branches to outside of this section. */
12607 htab = ppc_hash_table (info);
12611 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12613 enum elf_ppc64_reloc_type r_type;
12614 unsigned long r_symndx;
12615 struct elf_link_hash_entry *h;
12616 struct ppc_link_hash_entry *eh;
12617 Elf_Internal_Sym *sym;
12619 struct _opd_sec_data *opd;
12623 r_type = ELF64_R_TYPE (rel->r_info);
12624 if (r_type != R_PPC64_REL24
12625 && r_type != R_PPC64_REL24_NOTOC
12626 && r_type != R_PPC64_REL14
12627 && r_type != R_PPC64_REL14_BRTAKEN
12628 && r_type != R_PPC64_REL14_BRNTAKEN
12629 && r_type != R_PPC64_PLTCALL)
12632 r_symndx = ELF64_R_SYM (rel->r_info);
12633 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12640 /* Calls to dynamic lib functions go through a plt call stub
12642 eh = (struct ppc_link_hash_entry *) h;
12644 && (eh->elf.plt.plist != NULL
12646 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12652 if (sym_sec == NULL)
12653 /* Ignore other undefined symbols. */
12656 /* Assume branches to other sections not included in the
12657 link need stubs too, to cover -R and absolute syms. */
12658 if (sym_sec->output_section == NULL)
12665 sym_value = sym->st_value;
12668 if (h->root.type != bfd_link_hash_defined
12669 && h->root.type != bfd_link_hash_defweak)
12671 sym_value = h->root.u.def.value;
12673 sym_value += rel->r_addend;
12675 /* If this branch reloc uses an opd sym, find the code section. */
12676 opd = get_opd_info (sym_sec);
12679 if (h == NULL && opd->adjust != NULL)
12683 adjust = opd->adjust[OPD_NDX (sym_value)];
12685 /* Assume deleted functions won't ever be called. */
12687 sym_value += adjust;
12690 dest = opd_entry_value (sym_sec, sym_value,
12691 &sym_sec, NULL, FALSE);
12692 if (dest == (bfd_vma) -1)
12697 + sym_sec->output_offset
12698 + sym_sec->output_section->vma);
12700 /* Ignore branch to self. */
12701 if (sym_sec == isec)
12704 /* If the called function uses the toc, we need a stub. */
12705 if (sym_sec->has_toc_reloc
12706 || sym_sec->makes_toc_func_call)
12712 /* Assume any branch that needs a long branch stub might in fact
12713 need a plt_branch stub. A plt_branch stub uses r2. */
12714 else if (dest - (isec->output_offset
12715 + isec->output_section->vma
12716 + rel->r_offset) + (1 << 25)
12717 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12725 /* If calling back to a section in the process of being
12726 tested, we can't say for sure that no toc adjusting stubs
12727 are needed, so don't return zero. */
12728 else if (sym_sec->call_check_in_progress)
12731 /* Branches to another section that itself doesn't have any TOC
12732 references are OK. Recursively call ourselves to check. */
12733 else if (!sym_sec->call_check_done)
12737 /* Mark current section as indeterminate, so that other
12738 sections that call back to current won't be marked as
12740 isec->call_check_in_progress = 1;
12741 recur = toc_adjusting_stub_needed (info, sym_sec);
12742 isec->call_check_in_progress = 0;
12753 if (local_syms != NULL
12754 && (elf_symtab_hdr (isec->owner).contents
12755 != (unsigned char *) local_syms))
12757 if (elf_section_data (isec)->relocs != relstart)
12762 && isec->map_head.s != NULL
12763 && (strcmp (isec->output_section->name, ".init") == 0
12764 || strcmp (isec->output_section->name, ".fini") == 0))
12766 if (isec->map_head.s->has_toc_reloc
12767 || isec->map_head.s->makes_toc_func_call)
12769 else if (!isec->map_head.s->call_check_done)
12772 isec->call_check_in_progress = 1;
12773 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12774 isec->call_check_in_progress = 0;
12781 isec->makes_toc_func_call = 1;
12786 /* The linker repeatedly calls this function for each input section,
12787 in the order that input sections are linked into output sections.
12788 Build lists of input sections to determine groupings between which
12789 we may insert linker stubs. */
12792 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12794 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12799 if ((isec->output_section->flags & SEC_CODE) != 0
12800 && isec->output_section->id < htab->sec_info_arr_size)
12802 /* This happens to make the list in reverse order,
12803 which is what we want. */
12804 htab->sec_info[isec->id].u.list
12805 = htab->sec_info[isec->output_section->id].u.list;
12806 htab->sec_info[isec->output_section->id].u.list = isec;
12809 if (htab->multi_toc_needed)
12811 /* Analyse sections that aren't already flagged as needing a
12812 valid toc pointer. Exclude .fixup for the linux kernel.
12813 .fixup contains branches, but only back to the function that
12814 hit an exception. */
12815 if (!(isec->has_toc_reloc
12816 || (isec->flags & SEC_CODE) == 0
12817 || strcmp (isec->name, ".fixup") == 0
12818 || isec->call_check_done))
12820 if (toc_adjusting_stub_needed (info, isec) < 0)
12823 /* Make all sections use the TOC assigned for this object file.
12824 This will be wrong for pasted sections; We fix that in
12825 check_pasted_section(). */
12826 if (elf_gp (isec->owner) != 0)
12827 htab->toc_curr = elf_gp (isec->owner);
12830 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12834 /* Check that all .init and .fini sections use the same toc, if they
12835 have toc relocs. */
12838 check_pasted_section (struct bfd_link_info *info, const char *name)
12840 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12844 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12845 bfd_vma toc_off = 0;
12848 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12849 if (i->has_toc_reloc)
12852 toc_off = htab->sec_info[i->id].toc_off;
12853 else if (toc_off != htab->sec_info[i->id].toc_off)
12858 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12859 if (i->makes_toc_func_call)
12861 toc_off = htab->sec_info[i->id].toc_off;
12865 /* Make sure the whole pasted function uses the same toc offset. */
12867 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12868 htab->sec_info[i->id].toc_off = toc_off;
12874 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12876 return (check_pasted_section (info, ".init")
12877 & check_pasted_section (info, ".fini"));
12880 /* See whether we can group stub sections together. Grouping stub
12881 sections may result in fewer stubs. More importantly, we need to
12882 put all .init* and .fini* stubs at the beginning of the .init or
12883 .fini output sections respectively, because glibc splits the
12884 _init and _fini functions into multiple parts. Putting a stub in
12885 the middle of a function is not a good idea. */
12888 group_sections (struct bfd_link_info *info,
12889 bfd_size_type stub_group_size,
12890 bfd_boolean stubs_always_before_branch)
12892 struct ppc_link_hash_table *htab;
12894 bfd_boolean suppress_size_errors;
12896 htab = ppc_hash_table (info);
12900 suppress_size_errors = FALSE;
12901 if (stub_group_size == 1)
12903 /* Default values. */
12904 if (stubs_always_before_branch)
12905 stub_group_size = 0x1e00000;
12907 stub_group_size = 0x1c00000;
12908 suppress_size_errors = TRUE;
12911 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12915 if (osec->id >= htab->sec_info_arr_size)
12918 tail = htab->sec_info[osec->id].u.list;
12919 while (tail != NULL)
12923 bfd_size_type total;
12924 bfd_boolean big_sec;
12926 struct map_stub *group;
12927 bfd_size_type group_size;
12930 total = tail->size;
12931 group_size = (ppc64_elf_section_data (tail) != NULL
12932 && ppc64_elf_section_data (tail)->has_14bit_branch
12933 ? stub_group_size >> 10 : stub_group_size);
12935 big_sec = total > group_size;
12936 if (big_sec && !suppress_size_errors)
12937 /* xgettext:c-format */
12938 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12939 tail->owner, tail);
12940 curr_toc = htab->sec_info[tail->id].toc_off;
12942 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12943 && ((total += curr->output_offset - prev->output_offset)
12944 < (ppc64_elf_section_data (prev) != NULL
12945 && ppc64_elf_section_data (prev)->has_14bit_branch
12946 ? (group_size = stub_group_size >> 10) : group_size))
12947 && htab->sec_info[prev->id].toc_off == curr_toc)
12950 /* OK, the size from the start of CURR to the end is less
12951 than group_size and thus can be handled by one stub
12952 section. (or the tail section is itself larger than
12953 group_size, in which case we may be toast.) We should
12954 really be keeping track of the total size of stubs added
12955 here, as stubs contribute to the final output section
12956 size. That's a little tricky, and this way will only
12957 break if stubs added make the total size more than 2^25,
12958 ie. for the default stub_group_size, if stubs total more
12959 than 2097152 bytes, or nearly 75000 plt call stubs. */
12960 group = bfd_alloc (curr->owner, sizeof (*group));
12963 group->link_sec = curr;
12964 group->stub_sec = NULL;
12965 group->needs_save_res = 0;
12966 group->lr_restore = 0;
12967 group->eh_size = 0;
12968 group->eh_base = 0;
12969 group->next = htab->group;
12970 htab->group = group;
12973 prev = htab->sec_info[tail->id].u.list;
12974 /* Set up this stub group. */
12975 htab->sec_info[tail->id].u.group = group;
12977 while (tail != curr && (tail = prev) != NULL);
12979 /* But wait, there's more! Input sections up to group_size
12980 bytes before the stub section can be handled by it too.
12981 Don't do this if we have a really large section after the
12982 stubs, as adding more stubs increases the chance that
12983 branches may not reach into the stub section. */
12984 if (!stubs_always_before_branch && !big_sec)
12987 while (prev != NULL
12988 && ((total += tail->output_offset - prev->output_offset)
12989 < (ppc64_elf_section_data (prev) != NULL
12990 && ppc64_elf_section_data (prev)->has_14bit_branch
12991 ? (group_size = stub_group_size >> 10) : group_size))
12992 && htab->sec_info[prev->id].toc_off == curr_toc)
12995 prev = htab->sec_info[tail->id].u.list;
12996 htab->sec_info[tail->id].u.group = group;
13005 static const unsigned char glink_eh_frame_cie[] =
13007 0, 0, 0, 16, /* length. */
13008 0, 0, 0, 0, /* id. */
13009 1, /* CIE version. */
13010 'z', 'R', 0, /* Augmentation string. */
13011 4, /* Code alignment. */
13012 0x78, /* Data alignment. */
13014 1, /* Augmentation size. */
13015 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
13016 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
13019 /* Stripping output sections is normally done before dynamic section
13020 symbols have been allocated. This function is called later, and
13021 handles cases like htab->brlt which is mapped to its own output
13025 maybe_strip_output (struct bfd_link_info *info, asection *isec)
13027 if (isec->size == 0
13028 && isec->output_section->size == 0
13029 && !(isec->output_section->flags & SEC_KEEP)
13030 && !bfd_section_removed_from_list (info->output_bfd,
13031 isec->output_section)
13032 && elf_section_data (isec->output_section)->dynindx == 0)
13034 isec->output_section->flags |= SEC_EXCLUDE;
13035 bfd_section_list_remove (info->output_bfd, isec->output_section);
13036 info->output_bfd->section_count--;
13040 /* Determine and set the size of the stub section for a final link.
13042 The basic idea here is to examine all the relocations looking for
13043 PC-relative calls to a target that is unreachable with a "bl"
13047 ppc64_elf_size_stubs (struct bfd_link_info *info)
13049 bfd_size_type stub_group_size;
13050 bfd_boolean stubs_always_before_branch;
13051 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13056 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
13057 htab->params->plt_thread_safe = 1;
13058 if (!htab->opd_abi)
13059 htab->params->plt_thread_safe = 0;
13060 else if (htab->params->plt_thread_safe == -1)
13062 static const char *const thread_starter[] =
13066 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13068 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13069 "mq_notify", "create_timer",
13074 "GOMP_parallel_start",
13075 "GOMP_parallel_loop_static",
13076 "GOMP_parallel_loop_static_start",
13077 "GOMP_parallel_loop_dynamic",
13078 "GOMP_parallel_loop_dynamic_start",
13079 "GOMP_parallel_loop_guided",
13080 "GOMP_parallel_loop_guided_start",
13081 "GOMP_parallel_loop_runtime",
13082 "GOMP_parallel_loop_runtime_start",
13083 "GOMP_parallel_sections",
13084 "GOMP_parallel_sections_start",
13090 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
13092 struct elf_link_hash_entry *h;
13093 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
13094 FALSE, FALSE, TRUE);
13095 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
13096 if (htab->params->plt_thread_safe)
13100 stubs_always_before_branch = htab->params->group_size < 0;
13101 if (htab->params->group_size < 0)
13102 stub_group_size = -htab->params->group_size;
13104 stub_group_size = htab->params->group_size;
13106 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
13109 #define STUB_SHRINK_ITER 20
13110 /* Loop until no stubs added. After iteration 20 of this loop we may
13111 exit on a stub section shrinking. This is to break out of a
13112 pathological case where adding stubs on one iteration decreases
13113 section gaps (perhaps due to alignment), which then requires
13114 fewer or smaller stubs on the next iteration. */
13119 unsigned int bfd_indx;
13120 struct map_stub *group;
13122 htab->stub_iteration += 1;
13124 for (input_bfd = info->input_bfds, bfd_indx = 0;
13126 input_bfd = input_bfd->link.next, bfd_indx++)
13128 Elf_Internal_Shdr *symtab_hdr;
13130 Elf_Internal_Sym *local_syms = NULL;
13132 if (!is_ppc64_elf (input_bfd))
13135 /* We'll need the symbol table in a second. */
13136 symtab_hdr = &elf_symtab_hdr (input_bfd);
13137 if (symtab_hdr->sh_info == 0)
13140 /* Walk over each section attached to the input bfd. */
13141 for (section = input_bfd->sections;
13143 section = section->next)
13145 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13147 /* If there aren't any relocs, then there's nothing more
13149 if ((section->flags & SEC_RELOC) == 0
13150 || (section->flags & SEC_ALLOC) == 0
13151 || (section->flags & SEC_LOAD) == 0
13152 || (section->flags & SEC_CODE) == 0
13153 || section->reloc_count == 0)
13156 /* If this section is a link-once section that will be
13157 discarded, then don't create any stubs. */
13158 if (section->output_section == NULL
13159 || section->output_section->owner != info->output_bfd)
13162 /* Get the relocs. */
13164 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13165 info->keep_memory);
13166 if (internal_relocs == NULL)
13167 goto error_ret_free_local;
13169 /* Now examine each relocation. */
13170 irela = internal_relocs;
13171 irelaend = irela + section->reloc_count;
13172 for (; irela < irelaend; irela++)
13174 enum elf_ppc64_reloc_type r_type;
13175 unsigned int r_indx;
13176 enum ppc_stub_type stub_type;
13177 struct ppc_stub_hash_entry *stub_entry;
13178 asection *sym_sec, *code_sec;
13179 bfd_vma sym_value, code_value;
13180 bfd_vma destination;
13181 unsigned long local_off;
13182 bfd_boolean ok_dest;
13183 struct ppc_link_hash_entry *hash;
13184 struct ppc_link_hash_entry *fdh;
13185 struct elf_link_hash_entry *h;
13186 Elf_Internal_Sym *sym;
13188 const asection *id_sec;
13189 struct _opd_sec_data *opd;
13190 struct plt_entry *plt_ent;
13192 r_type = ELF64_R_TYPE (irela->r_info);
13193 r_indx = ELF64_R_SYM (irela->r_info);
13195 if (r_type >= R_PPC64_max)
13197 bfd_set_error (bfd_error_bad_value);
13198 goto error_ret_free_internal;
13201 /* Only look for stubs on branch instructions. */
13202 if (r_type != R_PPC64_REL24
13203 && r_type != R_PPC64_REL24_NOTOC
13204 && r_type != R_PPC64_REL14
13205 && r_type != R_PPC64_REL14_BRTAKEN
13206 && r_type != R_PPC64_REL14_BRNTAKEN)
13209 /* Now determine the call target, its name, value,
13211 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13212 r_indx, input_bfd))
13213 goto error_ret_free_internal;
13214 hash = (struct ppc_link_hash_entry *) h;
13221 sym_value = sym->st_value;
13222 if (sym_sec != NULL
13223 && sym_sec->output_section != NULL)
13226 else if (hash->elf.root.type == bfd_link_hash_defined
13227 || hash->elf.root.type == bfd_link_hash_defweak)
13229 sym_value = hash->elf.root.u.def.value;
13230 if (sym_sec->output_section != NULL)
13233 else if (hash->elf.root.type == bfd_link_hash_undefweak
13234 || hash->elf.root.type == bfd_link_hash_undefined)
13236 /* Recognise an old ABI func code entry sym, and
13237 use the func descriptor sym instead if it is
13239 if (hash->elf.root.root.string[0] == '.'
13240 && hash->oh != NULL)
13242 fdh = ppc_follow_link (hash->oh);
13243 if (fdh->elf.root.type == bfd_link_hash_defined
13244 || fdh->elf.root.type == bfd_link_hash_defweak)
13246 sym_sec = fdh->elf.root.u.def.section;
13247 sym_value = fdh->elf.root.u.def.value;
13248 if (sym_sec->output_section != NULL)
13257 bfd_set_error (bfd_error_bad_value);
13258 goto error_ret_free_internal;
13265 sym_value += irela->r_addend;
13266 destination = (sym_value
13267 + sym_sec->output_offset
13268 + sym_sec->output_section->vma);
13269 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
13274 code_sec = sym_sec;
13275 code_value = sym_value;
13276 opd = get_opd_info (sym_sec);
13281 if (hash == NULL && opd->adjust != NULL)
13283 long adjust = opd->adjust[OPD_NDX (sym_value)];
13286 code_value += adjust;
13287 sym_value += adjust;
13289 dest = opd_entry_value (sym_sec, sym_value,
13290 &code_sec, &code_value, FALSE);
13291 if (dest != (bfd_vma) -1)
13293 destination = dest;
13296 /* Fixup old ABI sym to point at code
13298 hash->elf.root.type = bfd_link_hash_defweak;
13299 hash->elf.root.u.def.section = code_sec;
13300 hash->elf.root.u.def.value = code_value;
13305 /* Determine what (if any) linker stub is needed. */
13307 stub_type = ppc_type_of_stub (section, irela, &hash,
13308 &plt_ent, destination,
13311 if (r_type == R_PPC64_REL24_NOTOC)
13313 if (stub_type == ppc_stub_plt_call)
13314 stub_type = ppc_stub_plt_call_notoc;
13315 else if (stub_type == ppc_stub_long_branch
13316 || (code_sec != NULL
13317 && code_sec->output_section != NULL
13318 && (((hash ? hash->elf.other : sym->st_other)
13319 & STO_PPC64_LOCAL_MASK)
13320 != 1 << STO_PPC64_LOCAL_BIT)))
13321 stub_type = ppc_stub_long_branch_notoc;
13323 else if (stub_type != ppc_stub_plt_call)
13325 /* Check whether we need a TOC adjusting stub.
13326 Since the linker pastes together pieces from
13327 different object files when creating the
13328 _init and _fini functions, it may be that a
13329 call to what looks like a local sym is in
13330 fact a call needing a TOC adjustment. */
13331 if ((code_sec != NULL
13332 && code_sec->output_section != NULL
13333 && (htab->sec_info[code_sec->id].toc_off
13334 != htab->sec_info[section->id].toc_off)
13335 && (code_sec->has_toc_reloc
13336 || code_sec->makes_toc_func_call))
13337 || (((hash ? hash->elf.other : sym->st_other)
13338 & STO_PPC64_LOCAL_MASK)
13339 == 1 << STO_PPC64_LOCAL_BIT))
13340 stub_type = ppc_stub_long_branch_r2off;
13343 if (stub_type == ppc_stub_none)
13346 /* __tls_get_addr calls might be eliminated. */
13347 if (stub_type != ppc_stub_plt_call
13348 && stub_type != ppc_stub_plt_call_notoc
13350 && (hash == htab->tls_get_addr
13351 || hash == htab->tls_get_addr_fd)
13352 && section->has_tls_reloc
13353 && irela != internal_relocs)
13355 /* Get tls info. */
13356 unsigned char *tls_mask;
13358 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13359 irela - 1, input_bfd))
13360 goto error_ret_free_internal;
13361 if ((*tls_mask & TLS_TLS) != 0)
13365 if (stub_type == ppc_stub_plt_call)
13368 && htab->params->plt_localentry0 != 0
13369 && is_elfv2_localentry0 (&hash->elf))
13370 htab->has_plt_localentry0 = 1;
13371 else if (irela + 1 < irelaend
13372 && irela[1].r_offset == irela->r_offset + 4
13373 && (ELF64_R_TYPE (irela[1].r_info)
13374 == R_PPC64_TOCSAVE))
13376 if (!tocsave_find (htab, INSERT,
13377 &local_syms, irela + 1, input_bfd))
13378 goto error_ret_free_internal;
13381 stub_type = ppc_stub_plt_call_r2save;
13384 /* Support for grouping stub sections. */
13385 id_sec = htab->sec_info[section->id].u.group->link_sec;
13387 /* Get the name of this stub. */
13388 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13390 goto error_ret_free_internal;
13392 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13393 stub_name, FALSE, FALSE);
13394 if (stub_entry != NULL)
13396 enum ppc_stub_type old_type;
13397 /* A stub has already been created, but it may
13398 not be the required type. We shouldn't be
13399 transitioning from plt_call to long_branch
13400 stubs or vice versa, but we might be
13401 upgrading from plt_call to plt_call_r2save or
13402 from long_branch to long_branch_r2off. */
13404 old_type = stub_entry->stub_type;
13410 case ppc_stub_save_res:
13413 case ppc_stub_plt_call:
13414 case ppc_stub_plt_call_r2save:
13415 case ppc_stub_plt_call_notoc:
13416 case ppc_stub_plt_call_both:
13417 if (stub_type == ppc_stub_plt_call)
13419 else if (stub_type == ppc_stub_plt_call_r2save)
13421 if (old_type == ppc_stub_plt_call_notoc)
13422 stub_type = ppc_stub_plt_call_both;
13424 else if (stub_type == ppc_stub_plt_call_notoc)
13426 if (old_type == ppc_stub_plt_call_r2save)
13427 stub_type = ppc_stub_plt_call_both;
13433 case ppc_stub_plt_branch:
13434 case ppc_stub_plt_branch_r2off:
13435 case ppc_stub_plt_branch_notoc:
13436 case ppc_stub_plt_branch_both:
13437 old_type += (ppc_stub_long_branch
13438 - ppc_stub_plt_branch);
13439 /* Fall through. */
13440 case ppc_stub_long_branch:
13441 case ppc_stub_long_branch_r2off:
13442 case ppc_stub_long_branch_notoc:
13443 case ppc_stub_long_branch_both:
13444 if (stub_type == ppc_stub_long_branch)
13446 else if (stub_type == ppc_stub_long_branch_r2off)
13448 if (old_type == ppc_stub_long_branch_notoc)
13449 stub_type = ppc_stub_long_branch_both;
13451 else if (stub_type == ppc_stub_long_branch_notoc)
13453 if (old_type == ppc_stub_long_branch_r2off)
13454 stub_type = ppc_stub_long_branch_both;
13460 if (old_type < stub_type)
13461 stub_entry->stub_type = stub_type;
13465 stub_entry = ppc_add_stub (stub_name, section, info);
13466 if (stub_entry == NULL)
13469 error_ret_free_internal:
13470 if (elf_section_data (section)->relocs == NULL)
13471 free (internal_relocs);
13472 error_ret_free_local:
13473 if (local_syms != NULL
13474 && (symtab_hdr->contents
13475 != (unsigned char *) local_syms))
13480 stub_entry->stub_type = stub_type;
13481 if (stub_type >= ppc_stub_plt_call
13482 && stub_type <= ppc_stub_plt_call_both)
13484 stub_entry->target_value = sym_value;
13485 stub_entry->target_section = sym_sec;
13489 stub_entry->target_value = code_value;
13490 stub_entry->target_section = code_sec;
13492 stub_entry->h = hash;
13493 stub_entry->plt_ent = plt_ent;
13494 stub_entry->symtype
13495 = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13496 stub_entry->other = hash ? hash->elf.other : sym->st_other;
13498 if (stub_entry->h != NULL)
13499 htab->stub_globals += 1;
13502 /* We're done with the internal relocs, free them. */
13503 if (elf_section_data (section)->relocs != internal_relocs)
13504 free (internal_relocs);
13507 if (local_syms != NULL
13508 && symtab_hdr->contents != (unsigned char *) local_syms)
13510 if (!info->keep_memory)
13513 symtab_hdr->contents = (unsigned char *) local_syms;
13517 /* We may have added some stubs. Find out the new size of the
13519 for (group = htab->group; group != NULL; group = group->next)
13521 group->lr_restore = 0;
13522 group->eh_size = 0;
13523 if (group->stub_sec != NULL)
13525 asection *stub_sec = group->stub_sec;
13527 if (htab->stub_iteration <= STUB_SHRINK_ITER
13528 || stub_sec->rawsize < stub_sec->size)
13529 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13530 stub_sec->rawsize = stub_sec->size;
13531 stub_sec->size = 0;
13532 stub_sec->reloc_count = 0;
13533 stub_sec->flags &= ~SEC_RELOC;
13537 if (htab->stub_iteration <= STUB_SHRINK_ITER
13538 || htab->brlt->rawsize < htab->brlt->size)
13539 htab->brlt->rawsize = htab->brlt->size;
13540 htab->brlt->size = 0;
13541 htab->brlt->reloc_count = 0;
13542 htab->brlt->flags &= ~SEC_RELOC;
13543 if (htab->relbrlt != NULL)
13544 htab->relbrlt->size = 0;
13546 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13548 for (group = htab->group; group != NULL; group = group->next)
13549 if (group->needs_save_res)
13550 group->stub_sec->size += htab->sfpr->size;
13552 if (info->emitrelocations
13553 && htab->glink != NULL && htab->glink->size != 0)
13555 htab->glink->reloc_count = 1;
13556 htab->glink->flags |= SEC_RELOC;
13559 if (htab->glink_eh_frame != NULL
13560 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13561 && htab->glink_eh_frame->output_section->size > 8)
13563 size_t size = 0, align = 4;
13565 for (group = htab->group; group != NULL; group = group->next)
13566 if (group->eh_size != 0)
13567 size += (group->eh_size + 17 + align - 1) & -align;
13568 if (htab->glink != NULL && htab->glink->size != 0)
13569 size += (24 + align - 1) & -align;
13571 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13572 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13573 size = (size + align - 1) & -align;
13574 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13575 htab->glink_eh_frame->size = size;
13578 if (htab->params->plt_stub_align != 0)
13579 for (group = htab->group; group != NULL; group = group->next)
13580 if (group->stub_sec != NULL)
13582 int align = abs (htab->params->plt_stub_align);
13583 group->stub_sec->size
13584 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13587 for (group = htab->group; group != NULL; group = group->next)
13588 if (group->stub_sec != NULL
13589 && group->stub_sec->rawsize != group->stub_sec->size
13590 && (htab->stub_iteration <= STUB_SHRINK_ITER
13591 || group->stub_sec->rawsize < group->stub_sec->size))
13595 && (htab->brlt->rawsize == htab->brlt->size
13596 || (htab->stub_iteration > STUB_SHRINK_ITER
13597 && htab->brlt->rawsize > htab->brlt->size))
13598 && (htab->glink_eh_frame == NULL
13599 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13602 /* Ask the linker to do its stuff. */
13603 (*htab->params->layout_sections_again) ();
13606 if (htab->glink_eh_frame != NULL
13607 && htab->glink_eh_frame->size != 0)
13610 bfd_byte *p, *last_fde;
13611 size_t last_fde_len, size, align, pad;
13612 struct map_stub *group;
13614 /* It is necessary to at least have a rough outline of the
13615 linker generated CIEs and FDEs written before
13616 bfd_elf_discard_info is run, in order for these FDEs to be
13617 indexed in .eh_frame_hdr. */
13618 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13621 htab->glink_eh_frame->contents = p;
13625 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13626 /* CIE length (rewrite in case little-endian). */
13627 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13628 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13629 p += last_fde_len + 4;
13631 for (group = htab->group; group != NULL; group = group->next)
13632 if (group->eh_size != 0)
13634 group->eh_base = p - htab->glink_eh_frame->contents;
13636 last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
13638 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13641 val = p - htab->glink_eh_frame->contents;
13642 bfd_put_32 (htab->elf.dynobj, val, p);
13644 /* Offset to stub section, written later. */
13646 /* stub section size. */
13647 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13649 /* Augmentation. */
13651 /* Make sure we don't have all nops. This is enough for
13652 elf-eh-frame.c to detect the last non-nop opcode. */
13653 p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
13654 p = last_fde + last_fde_len + 4;
13656 if (htab->glink != NULL && htab->glink->size != 0)
13659 last_fde_len = ((24 + align - 1) & -align) - 4;
13661 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13664 val = p - htab->glink_eh_frame->contents;
13665 bfd_put_32 (htab->elf.dynobj, val, p);
13667 /* Offset to .glink, written later. */
13670 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13672 /* Augmentation. */
13675 *p++ = DW_CFA_advance_loc + 1;
13676 *p++ = DW_CFA_register;
13678 *p++ = htab->opd_abi ? 12 : 0;
13679 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13680 *p++ = DW_CFA_restore_extended;
13682 p += ((24 + align - 1) & -align) - 24;
13684 /* Subsume any padding into the last FDE if user .eh_frame
13685 sections are aligned more than glink_eh_frame. Otherwise any
13686 zero padding will be seen as a terminator. */
13687 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13688 size = p - htab->glink_eh_frame->contents;
13689 pad = ((size + align - 1) & -align) - size;
13690 htab->glink_eh_frame->size = size + pad;
13691 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13694 maybe_strip_output (info, htab->brlt);
13695 if (htab->glink_eh_frame != NULL)
13696 maybe_strip_output (info, htab->glink_eh_frame);
13701 /* Called after we have determined section placement. If sections
13702 move, we'll be called again. Provide a value for TOCstart. */
13705 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13708 bfd_vma TOCstart, adjust;
13712 struct elf_link_hash_entry *h;
13713 struct elf_link_hash_table *htab = elf_hash_table (info);
13715 if (is_elf_hash_table (htab)
13716 && htab->hgot != NULL)
13720 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13721 if (is_elf_hash_table (htab))
13725 && h->root.type == bfd_link_hash_defined
13726 && !h->root.linker_def
13727 && (!is_elf_hash_table (htab)
13728 || h->def_regular))
13730 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13731 + h->root.u.def.section->output_offset
13732 + h->root.u.def.section->output_section->vma);
13733 _bfd_set_gp_value (obfd, TOCstart);
13738 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13739 order. The TOC starts where the first of these sections starts. */
13740 s = bfd_get_section_by_name (obfd, ".got");
13741 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13742 s = bfd_get_section_by_name (obfd, ".toc");
13743 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13744 s = bfd_get_section_by_name (obfd, ".tocbss");
13745 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13746 s = bfd_get_section_by_name (obfd, ".plt");
13747 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13749 /* This may happen for
13750 o references to TOC base (SYM@toc / TOC[tc0]) without a
13752 o bad linker script
13753 o --gc-sections and empty TOC sections
13755 FIXME: Warn user? */
13757 /* Look for a likely section. We probably won't even be
13759 for (s = obfd->sections; s != NULL; s = s->next)
13760 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13762 == (SEC_ALLOC | SEC_SMALL_DATA))
13765 for (s = obfd->sections; s != NULL; s = s->next)
13766 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13767 == (SEC_ALLOC | SEC_SMALL_DATA))
13770 for (s = obfd->sections; s != NULL; s = s->next)
13771 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13775 for (s = obfd->sections; s != NULL; s = s->next)
13776 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13782 TOCstart = s->output_section->vma + s->output_offset;
13784 /* Force alignment. */
13785 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13786 TOCstart -= adjust;
13787 _bfd_set_gp_value (obfd, TOCstart);
13789 if (info != NULL && s != NULL)
13791 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13795 if (htab->elf.hgot != NULL)
13797 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13798 htab->elf.hgot->root.u.def.section = s;
13803 struct bfd_link_hash_entry *bh = NULL;
13804 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13805 s, TOC_BASE_OFF - adjust,
13806 NULL, FALSE, FALSE, &bh);
13812 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13813 write out any global entry stubs, and PLT relocations. */
13816 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13818 struct bfd_link_info *info;
13819 struct ppc_link_hash_table *htab;
13820 struct plt_entry *ent;
13823 if (h->root.type == bfd_link_hash_indirect)
13827 htab = ppc_hash_table (info);
13831 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13832 if (ent->plt.offset != (bfd_vma) -1)
13834 /* This symbol has an entry in the procedure linkage
13835 table. Set it up. */
13836 Elf_Internal_Rela rela;
13837 asection *plt, *relplt;
13840 if (!htab->elf.dynamic_sections_created
13841 || h->dynindx == -1)
13843 if (!(h->def_regular
13844 && (h->root.type == bfd_link_hash_defined
13845 || h->root.type == bfd_link_hash_defweak)))
13847 if (h->type == STT_GNU_IFUNC)
13849 plt = htab->elf.iplt;
13850 relplt = htab->elf.irelplt;
13851 htab->local_ifunc_resolver = 1;
13853 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13855 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13859 plt = htab->pltlocal;
13860 if (bfd_link_pic (info))
13862 relplt = htab->relpltlocal;
13864 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13866 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13871 rela.r_addend = (h->root.u.def.value
13872 + h->root.u.def.section->output_offset
13873 + h->root.u.def.section->output_section->vma
13876 if (relplt == NULL)
13878 loc = plt->contents + ent->plt.offset;
13879 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13882 bfd_vma toc = elf_gp (info->output_bfd);
13883 toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13884 bfd_put_64 (info->output_bfd, toc, loc + 8);
13889 rela.r_offset = (plt->output_section->vma
13890 + plt->output_offset
13891 + ent->plt.offset);
13892 loc = relplt->contents + (relplt->reloc_count++
13893 * sizeof (Elf64_External_Rela));
13894 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13899 rela.r_offset = (htab->elf.splt->output_section->vma
13900 + htab->elf.splt->output_offset
13901 + ent->plt.offset);
13902 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13903 rela.r_addend = ent->addend;
13904 loc = (htab->elf.srelplt->contents
13905 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13906 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13907 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13908 htab->maybe_local_ifunc_resolver = 1;
13909 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13913 if (!h->pointer_equality_needed)
13916 if (h->def_regular)
13919 s = htab->global_entry;
13920 if (s == NULL || s->size == 0)
13923 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13924 if (ent->plt.offset != (bfd_vma) -1
13925 && ent->addend == 0)
13931 p = s->contents + h->root.u.def.value;
13932 plt = htab->elf.splt;
13933 if (!htab->elf.dynamic_sections_created
13934 || h->dynindx == -1)
13936 if (h->type == STT_GNU_IFUNC)
13937 plt = htab->elf.iplt;
13939 plt = htab->pltlocal;
13941 off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13942 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13944 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13946 info->callbacks->einfo
13947 (_("%P: linkage table error against `%pT'\n"),
13948 h->root.root.string);
13949 bfd_set_error (bfd_error_bad_value);
13950 htab->stub_error = TRUE;
13953 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13954 if (htab->params->emit_stub_syms)
13956 size_t len = strlen (h->root.root.string);
13957 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13962 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13963 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13966 if (h->root.type == bfd_link_hash_new)
13968 h->root.type = bfd_link_hash_defined;
13969 h->root.u.def.section = s;
13970 h->root.u.def.value = p - s->contents;
13971 h->ref_regular = 1;
13972 h->def_regular = 1;
13973 h->ref_regular_nonweak = 1;
13974 h->forced_local = 1;
13976 h->root.linker_def = 1;
13980 if (PPC_HA (off) != 0)
13982 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13985 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13987 bfd_put_32 (s->owner, MTCTR_R12, p);
13989 bfd_put_32 (s->owner, BCTR, p);
13995 /* Write PLT relocs for locals. */
13998 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
14000 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14003 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
14005 struct got_entry **lgot_ents, **end_lgot_ents;
14006 struct plt_entry **local_plt, **lplt, **end_local_plt;
14007 Elf_Internal_Shdr *symtab_hdr;
14008 bfd_size_type locsymcount;
14009 Elf_Internal_Sym *local_syms = NULL;
14010 struct plt_entry *ent;
14012 if (!is_ppc64_elf (ibfd))
14015 lgot_ents = elf_local_got_ents (ibfd);
14019 symtab_hdr = &elf_symtab_hdr (ibfd);
14020 locsymcount = symtab_hdr->sh_info;
14021 end_lgot_ents = lgot_ents + locsymcount;
14022 local_plt = (struct plt_entry **) end_lgot_ents;
14023 end_local_plt = local_plt + locsymcount;
14024 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
14025 for (ent = *lplt; ent != NULL; ent = ent->next)
14026 if (ent->plt.offset != (bfd_vma) -1)
14028 Elf_Internal_Sym *sym;
14030 asection *plt, *relplt;
14034 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
14035 lplt - local_plt, ibfd))
14037 if (local_syms != NULL
14038 && symtab_hdr->contents != (unsigned char *) local_syms)
14043 val = sym->st_value + ent->addend;
14044 val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
14045 if (sym_sec != NULL && sym_sec->output_section != NULL)
14046 val += sym_sec->output_offset + sym_sec->output_section->vma;
14048 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14050 htab->local_ifunc_resolver = 1;
14051 plt = htab->elf.iplt;
14052 relplt = htab->elf.irelplt;
14056 plt = htab->pltlocal;
14057 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
14060 if (relplt == NULL)
14062 loc = plt->contents + ent->plt.offset;
14063 bfd_put_64 (info->output_bfd, val, loc);
14066 bfd_vma toc = elf_gp (ibfd);
14067 bfd_put_64 (info->output_bfd, toc, loc + 8);
14072 Elf_Internal_Rela rela;
14073 rela.r_offset = (ent->plt.offset
14074 + plt->output_offset
14075 + plt->output_section->vma);
14076 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14079 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14081 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14086 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
14088 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14090 rela.r_addend = val;
14091 loc = relplt->contents + (relplt->reloc_count++
14092 * sizeof (Elf64_External_Rela));
14093 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
14097 if (local_syms != NULL
14098 && symtab_hdr->contents != (unsigned char *) local_syms)
14100 if (!info->keep_memory)
14103 symtab_hdr->contents = (unsigned char *) local_syms;
14109 /* Build all the stubs associated with the current output file.
14110 The stubs are kept in a hash table attached to the main linker
14111 hash table. This function is called via gldelf64ppc_finish. */
14114 ppc64_elf_build_stubs (struct bfd_link_info *info,
14117 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14118 struct map_stub *group;
14119 asection *stub_sec;
14121 int stub_sec_count = 0;
14126 /* Allocate memory to hold the linker stubs. */
14127 for (group = htab->group; group != NULL; group = group->next)
14129 group->eh_size = 0;
14130 group->lr_restore = 0;
14131 if ((stub_sec = group->stub_sec) != NULL
14132 && stub_sec->size != 0)
14134 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
14136 if (stub_sec->contents == NULL)
14138 stub_sec->size = 0;
14142 if (htab->glink != NULL && htab->glink->size != 0)
14147 /* Build the .glink plt call stub. */
14148 if (htab->params->emit_stub_syms)
14150 struct elf_link_hash_entry *h;
14151 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
14152 TRUE, FALSE, FALSE);
14155 if (h->root.type == bfd_link_hash_new)
14157 h->root.type = bfd_link_hash_defined;
14158 h->root.u.def.section = htab->glink;
14159 h->root.u.def.value = 8;
14160 h->ref_regular = 1;
14161 h->def_regular = 1;
14162 h->ref_regular_nonweak = 1;
14163 h->forced_local = 1;
14165 h->root.linker_def = 1;
14168 plt0 = (htab->elf.splt->output_section->vma
14169 + htab->elf.splt->output_offset
14171 if (info->emitrelocations)
14173 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
14176 r->r_offset = (htab->glink->output_offset
14177 + htab->glink->output_section->vma);
14178 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
14179 r->r_addend = plt0;
14181 p = htab->glink->contents;
14182 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
14183 bfd_put_64 (htab->glink->owner, plt0, p);
14187 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
14189 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14191 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14193 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14195 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
14197 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14199 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14201 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
14203 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14205 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
14210 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
14212 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14214 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14216 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
14218 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14220 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
14222 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
14224 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14226 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
14228 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14230 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
14232 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14234 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
14237 bfd_put_32 (htab->glink->owner, BCTR, p);
14239 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
14241 /* Build the .glink lazy link call stubs. */
14243 while (p < htab->glink->contents + htab->glink->size)
14249 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
14254 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
14256 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
14261 bfd_put_32 (htab->glink->owner,
14262 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
14268 /* Build .glink global entry stubs, and PLT relocs for globals. */
14269 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
14271 if (!write_plt_relocs_for_local_syms (info))
14274 if (htab->brlt != NULL && htab->brlt->size != 0)
14276 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
14278 if (htab->brlt->contents == NULL)
14281 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
14283 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
14284 htab->relbrlt->size);
14285 if (htab->relbrlt->contents == NULL)
14289 /* Build the stubs as directed by the stub hash table. */
14290 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
14292 for (group = htab->group; group != NULL; group = group->next)
14293 if (group->needs_save_res)
14294 group->stub_sec->size += htab->sfpr->size;
14296 if (htab->relbrlt != NULL)
14297 htab->relbrlt->reloc_count = 0;
14299 if (htab->params->plt_stub_align != 0)
14300 for (group = htab->group; group != NULL; group = group->next)
14301 if ((stub_sec = group->stub_sec) != NULL)
14303 int align = abs (htab->params->plt_stub_align);
14304 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
14307 for (group = htab->group; group != NULL; group = group->next)
14308 if (group->needs_save_res)
14310 stub_sec = group->stub_sec;
14311 memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
14312 htab->sfpr->contents, htab->sfpr->size);
14313 if (htab->params->emit_stub_syms)
14317 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
14318 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
14323 if (htab->glink_eh_frame != NULL
14324 && htab->glink_eh_frame->size != 0)
14329 p = htab->glink_eh_frame->contents;
14330 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
14332 for (group = htab->group; group != NULL; group = group->next)
14333 if (group->eh_size != 0)
14335 /* Offset to stub section. */
14336 val = (group->stub_sec->output_section->vma
14337 + group->stub_sec->output_offset);
14338 val -= (htab->glink_eh_frame->output_section->vma
14339 + htab->glink_eh_frame->output_offset
14340 + (p + 8 - htab->glink_eh_frame->contents));
14341 if (val + 0x80000000 > 0xffffffff)
14344 (_("%s offset too large for .eh_frame sdata4 encoding"),
14345 group->stub_sec->name);
14348 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14349 p += (group->eh_size + 17 + 3) & -4;
14351 if (htab->glink != NULL && htab->glink->size != 0)
14353 /* Offset to .glink. */
14354 val = (htab->glink->output_section->vma
14355 + htab->glink->output_offset
14357 val -= (htab->glink_eh_frame->output_section->vma
14358 + htab->glink_eh_frame->output_offset
14359 + (p + 8 - htab->glink_eh_frame->contents));
14360 if (val + 0x80000000 > 0xffffffff)
14363 (_("%s offset too large for .eh_frame sdata4 encoding"),
14364 htab->glink->name);
14367 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14368 p += (24 + align - 1) & -align;
14372 for (group = htab->group; group != NULL; group = group->next)
14373 if ((stub_sec = group->stub_sec) != NULL)
14375 stub_sec_count += 1;
14376 if (stub_sec->rawsize != stub_sec->size
14377 && (htab->stub_iteration <= STUB_SHRINK_ITER
14378 || stub_sec->rawsize < stub_sec->size))
14384 htab->stub_error = TRUE;
14385 _bfd_error_handler (_("stubs don't match calculated size"));
14388 if (htab->stub_error)
14394 *stats = bfd_malloc (500);
14395 if (*stats == NULL)
14398 len = sprintf (*stats,
14399 ngettext ("linker stubs in %u group\n",
14400 "linker stubs in %u groups\n",
14403 sprintf (*stats + len, _(" branch %lu\n"
14404 " branch toc adj %lu\n"
14405 " branch notoc %lu\n"
14406 " branch both %lu\n"
14407 " long branch %lu\n"
14408 " long toc adj %lu\n"
14409 " long notoc %lu\n"
14412 " plt call save %lu\n"
14413 " plt call notoc %lu\n"
14414 " plt call both %lu\n"
14415 " global entry %lu"),
14416 htab->stub_count[ppc_stub_long_branch - 1],
14417 htab->stub_count[ppc_stub_long_branch_r2off - 1],
14418 htab->stub_count[ppc_stub_long_branch_notoc - 1],
14419 htab->stub_count[ppc_stub_long_branch_both - 1],
14420 htab->stub_count[ppc_stub_plt_branch - 1],
14421 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14422 htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14423 htab->stub_count[ppc_stub_plt_branch_both - 1],
14424 htab->stub_count[ppc_stub_plt_call - 1],
14425 htab->stub_count[ppc_stub_plt_call_r2save - 1],
14426 htab->stub_count[ppc_stub_plt_call_notoc - 1],
14427 htab->stub_count[ppc_stub_plt_call_both - 1],
14428 htab->stub_count[ppc_stub_global_entry - 1]);
14433 /* What to do when ld finds relocations against symbols defined in
14434 discarded sections. */
14436 static unsigned int
14437 ppc64_elf_action_discarded (asection *sec)
14439 if (strcmp (".opd", sec->name) == 0)
14442 if (strcmp (".toc", sec->name) == 0)
14445 if (strcmp (".toc1", sec->name) == 0)
14448 return _bfd_elf_default_action_discarded (sec);
14451 /* The RELOCATE_SECTION function is called by the ELF backend linker
14452 to handle the relocations for a section.
14454 The relocs are always passed as Rela structures; if the section
14455 actually uses Rel structures, the r_addend field will always be
14458 This function is responsible for adjust the section contents as
14459 necessary, and (if using Rela relocs and generating a
14460 relocatable output file) adjusting the reloc addend as
14463 This function does not have to worry about setting the reloc
14464 address or the reloc symbol index.
14466 LOCAL_SYMS is a pointer to the swapped in local symbols.
14468 LOCAL_SECTIONS is an array giving the section in the input file
14469 corresponding to the st_shndx field of each local symbol.
14471 The global hash table entry for the global symbols can be found
14472 via elf_sym_hashes (input_bfd).
14474 When generating relocatable output, this function must handle
14475 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14476 going to be the section symbol corresponding to the output
14477 section, which means that the addend must be adjusted
14481 ppc64_elf_relocate_section (bfd *output_bfd,
14482 struct bfd_link_info *info,
14484 asection *input_section,
14485 bfd_byte *contents,
14486 Elf_Internal_Rela *relocs,
14487 Elf_Internal_Sym *local_syms,
14488 asection **local_sections)
14490 struct ppc_link_hash_table *htab;
14491 Elf_Internal_Shdr *symtab_hdr;
14492 struct elf_link_hash_entry **sym_hashes;
14493 Elf_Internal_Rela *rel;
14494 Elf_Internal_Rela *wrel;
14495 Elf_Internal_Rela *relend;
14496 Elf_Internal_Rela outrel;
14498 struct got_entry **local_got_ents;
14500 bfd_boolean ret = TRUE;
14501 bfd_boolean is_opd;
14502 /* Assume 'at' branch hints. */
14503 bfd_boolean is_isa_v2 = TRUE;
14504 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14506 /* Initialize howto table if needed. */
14507 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14510 htab = ppc_hash_table (info);
14514 /* Don't relocate stub sections. */
14515 if (input_section->owner == htab->params->stub_bfd)
14518 BFD_ASSERT (is_ppc64_elf (input_bfd));
14520 local_got_ents = elf_local_got_ents (input_bfd);
14521 TOCstart = elf_gp (output_bfd);
14522 symtab_hdr = &elf_symtab_hdr (input_bfd);
14523 sym_hashes = elf_sym_hashes (input_bfd);
14524 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14526 rel = wrel = relocs;
14527 relend = relocs + input_section->reloc_count;
14528 for (; rel < relend; wrel++, rel++)
14530 enum elf_ppc64_reloc_type r_type;
14532 bfd_reloc_status_type r;
14533 Elf_Internal_Sym *sym;
14535 struct elf_link_hash_entry *h_elf;
14536 struct ppc_link_hash_entry *h;
14537 struct ppc_link_hash_entry *fdh;
14538 const char *sym_name;
14539 unsigned long r_symndx, toc_symndx;
14540 bfd_vma toc_addend;
14541 unsigned char tls_mask, tls_gd, tls_type;
14542 unsigned char sym_type;
14543 bfd_vma relocation;
14544 bfd_boolean unresolved_reloc, save_unresolved_reloc;
14545 bfd_boolean warned;
14546 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14549 struct ppc_stub_hash_entry *stub_entry;
14550 bfd_vma max_br_offset;
14552 Elf_Internal_Rela orig_rel;
14553 reloc_howto_type *howto;
14554 struct reloc_howto_struct alt_howto;
14559 r_type = ELF64_R_TYPE (rel->r_info);
14560 r_symndx = ELF64_R_SYM (rel->r_info);
14562 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14563 symbol of the previous ADDR64 reloc. The symbol gives us the
14564 proper TOC base to use. */
14565 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14567 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14569 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14575 unresolved_reloc = FALSE;
14578 if (r_symndx < symtab_hdr->sh_info)
14580 /* It's a local symbol. */
14581 struct _opd_sec_data *opd;
14583 sym = local_syms + r_symndx;
14584 sec = local_sections[r_symndx];
14585 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14586 sym_type = ELF64_ST_TYPE (sym->st_info);
14587 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14588 opd = get_opd_info (sec);
14589 if (opd != NULL && opd->adjust != NULL)
14591 long adjust = opd->adjust[OPD_NDX (sym->st_value
14597 /* If this is a relocation against the opd section sym
14598 and we have edited .opd, adjust the reloc addend so
14599 that ld -r and ld --emit-relocs output is correct.
14600 If it is a reloc against some other .opd symbol,
14601 then the symbol value will be adjusted later. */
14602 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14603 rel->r_addend += adjust;
14605 relocation += adjust;
14611 bfd_boolean ignored;
14613 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14614 r_symndx, symtab_hdr, sym_hashes,
14615 h_elf, sec, relocation,
14616 unresolved_reloc, warned, ignored);
14617 sym_name = h_elf->root.root.string;
14618 sym_type = h_elf->type;
14620 && sec->owner == output_bfd
14621 && strcmp (sec->name, ".opd") == 0)
14623 /* This is a symbol defined in a linker script. All
14624 such are defined in output sections, even those
14625 defined by simple assignment from a symbol defined in
14626 an input section. Transfer the symbol to an
14627 appropriate input .opd section, so that a branch to
14628 this symbol will be mapped to the location specified
14629 by the opd entry. */
14630 struct bfd_link_order *lo;
14631 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14632 if (lo->type == bfd_indirect_link_order)
14634 asection *isec = lo->u.indirect.section;
14635 if (h_elf->root.u.def.value >= isec->output_offset
14636 && h_elf->root.u.def.value < (isec->output_offset
14639 h_elf->root.u.def.value -= isec->output_offset;
14640 h_elf->root.u.def.section = isec;
14647 h = (struct ppc_link_hash_entry *) h_elf;
14649 if (sec != NULL && discarded_section (sec))
14651 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14652 input_bfd, input_section,
14653 contents + rel->r_offset);
14654 wrel->r_offset = rel->r_offset;
14656 wrel->r_addend = 0;
14658 /* For ld -r, remove relocations in debug sections against
14659 symbols defined in discarded sections. Not done for
14660 non-debug to preserve relocs in .eh_frame which the
14661 eh_frame editing code expects to be present. */
14662 if (bfd_link_relocatable (info)
14663 && (input_section->flags & SEC_DEBUGGING))
14669 if (bfd_link_relocatable (info))
14672 if (h != NULL && &h->elf == htab->elf.hgot)
14674 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14675 sec = bfd_abs_section_ptr;
14676 unresolved_reloc = FALSE;
14679 /* TLS optimizations. Replace instruction sequences and relocs
14680 based on information we collected in tls_optimize. We edit
14681 RELOCS so that --emit-relocs will output something sensible
14682 for the final instruction stream. */
14687 tls_mask = h->tls_mask;
14688 else if (local_got_ents != NULL)
14690 struct plt_entry **local_plt = (struct plt_entry **)
14691 (local_got_ents + symtab_hdr->sh_info);
14692 unsigned char *lgot_masks = (unsigned char *)
14693 (local_plt + symtab_hdr->sh_info);
14694 tls_mask = lgot_masks[r_symndx];
14696 if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14697 && (r_type == R_PPC64_TLS
14698 || r_type == R_PPC64_TLSGD
14699 || r_type == R_PPC64_TLSLD))
14701 /* Check for toc tls entries. */
14702 unsigned char *toc_tls;
14704 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14705 &local_syms, rel, input_bfd))
14709 tls_mask = *toc_tls;
14712 /* Check that tls relocs are used with tls syms, and non-tls
14713 relocs are used with non-tls syms. */
14714 if (r_symndx != STN_UNDEF
14715 && r_type != R_PPC64_NONE
14717 || h->elf.root.type == bfd_link_hash_defined
14718 || h->elf.root.type == bfd_link_hash_defweak)
14719 && (IS_PPC64_TLS_RELOC (r_type)
14720 != (sym_type == STT_TLS
14721 || (sym_type == STT_SECTION
14722 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14724 if ((tls_mask & TLS_TLS) != 0
14725 && (r_type == R_PPC64_TLS
14726 || r_type == R_PPC64_TLSGD
14727 || r_type == R_PPC64_TLSLD))
14728 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14731 info->callbacks->einfo
14732 (!IS_PPC64_TLS_RELOC (r_type)
14733 /* xgettext:c-format */
14734 ? _("%H: %s used with TLS symbol `%pT'\n")
14735 /* xgettext:c-format */
14736 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14737 input_bfd, input_section, rel->r_offset,
14738 ppc64_elf_howto_table[r_type]->name,
14742 /* Ensure reloc mapping code below stays sane. */
14743 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14744 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14745 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
14746 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14747 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14748 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14749 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
14750 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14751 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14752 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14760 case R_PPC64_LO_DS_OPT:
14761 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14762 if ((insn & (0x3f << 26)) != 58u << 26)
14764 insn += (14u << 26) - (58u << 26);
14765 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14766 r_type = R_PPC64_TOC16_LO;
14767 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14770 case R_PPC64_TOC16:
14771 case R_PPC64_TOC16_LO:
14772 case R_PPC64_TOC16_DS:
14773 case R_PPC64_TOC16_LO_DS:
14775 /* Check for toc tls entries. */
14776 unsigned char *toc_tls;
14779 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14780 &local_syms, rel, input_bfd);
14786 tls_mask = *toc_tls;
14787 if (r_type == R_PPC64_TOC16_DS
14788 || r_type == R_PPC64_TOC16_LO_DS)
14790 if ((tls_mask & TLS_TLS) != 0
14791 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14796 /* If we found a GD reloc pair, then we might be
14797 doing a GD->IE transition. */
14800 tls_gd = TLS_TPRELGD;
14801 if ((tls_mask & TLS_TLS) != 0
14802 && (tls_mask & TLS_GD) == 0)
14805 else if (retval == 3)
14807 if ((tls_mask & TLS_TLS) != 0
14808 && (tls_mask & TLS_LD) == 0)
14816 case R_PPC64_GOT_TPREL16_HI:
14817 case R_PPC64_GOT_TPREL16_HA:
14818 if ((tls_mask & TLS_TLS) != 0
14819 && (tls_mask & TLS_TPREL) == 0)
14821 rel->r_offset -= d_offset;
14822 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14823 r_type = R_PPC64_NONE;
14824 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14828 case R_PPC64_GOT_TPREL16_DS:
14829 case R_PPC64_GOT_TPREL16_LO_DS:
14830 if ((tls_mask & TLS_TLS) != 0
14831 && (tls_mask & TLS_TPREL) == 0)
14834 insn = bfd_get_32 (input_bfd,
14835 contents + rel->r_offset - d_offset);
14837 insn |= 0x3c0d0000; /* addis 0,13,0 */
14838 bfd_put_32 (input_bfd, insn,
14839 contents + rel->r_offset - d_offset);
14840 r_type = R_PPC64_TPREL16_HA;
14841 if (toc_symndx != 0)
14843 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14844 rel->r_addend = toc_addend;
14845 /* We changed the symbol. Start over in order to
14846 get h, sym, sec etc. right. */
14850 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14855 if ((tls_mask & TLS_TLS) != 0
14856 && (tls_mask & TLS_TPREL) == 0)
14858 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14859 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14862 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14863 /* Was PPC64_TLS which sits on insn boundary, now
14864 PPC64_TPREL16_LO which is at low-order half-word. */
14865 rel->r_offset += d_offset;
14866 r_type = R_PPC64_TPREL16_LO;
14867 if (toc_symndx != 0)
14869 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14870 rel->r_addend = toc_addend;
14871 /* We changed the symbol. Start over in order to
14872 get h, sym, sec etc. right. */
14876 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14880 case R_PPC64_GOT_TLSGD16_HI:
14881 case R_PPC64_GOT_TLSGD16_HA:
14882 tls_gd = TLS_TPRELGD;
14883 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14887 case R_PPC64_GOT_TLSLD16_HI:
14888 case R_PPC64_GOT_TLSLD16_HA:
14889 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14892 if ((tls_mask & tls_gd) != 0)
14893 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14894 + R_PPC64_GOT_TPREL16_DS);
14897 rel->r_offset -= d_offset;
14898 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14899 r_type = R_PPC64_NONE;
14901 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14905 case R_PPC64_GOT_TLSGD16:
14906 case R_PPC64_GOT_TLSGD16_LO:
14907 tls_gd = TLS_TPRELGD;
14908 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14912 case R_PPC64_GOT_TLSLD16:
14913 case R_PPC64_GOT_TLSLD16_LO:
14914 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14916 unsigned int insn1, insn2;
14920 offset = (bfd_vma) -1;
14921 /* If not using the newer R_PPC64_TLSGD/LD to mark
14922 __tls_get_addr calls, we must trust that the call
14923 stays with its arg setup insns, ie. that the next
14924 reloc is the __tls_get_addr call associated with
14925 the current reloc. Edit both insns. */
14926 if (input_section->has_tls_get_addr_call
14927 && rel + 1 < relend
14928 && branch_reloc_hash_match (input_bfd, rel + 1,
14929 htab->tls_get_addr,
14930 htab->tls_get_addr_fd))
14931 offset = rel[1].r_offset;
14932 /* We read the low GOT_TLS (or TOC16) insn because we
14933 need to keep the destination reg. It may be
14934 something other than the usual r3, and moved to r3
14935 before the call by intervening code. */
14936 insn1 = bfd_get_32 (input_bfd,
14937 contents + rel->r_offset - d_offset);
14938 if ((tls_mask & tls_gd) != 0)
14941 insn1 &= (0x1f << 21) | (0x1f << 16);
14942 insn1 |= 58 << 26; /* ld */
14943 insn2 = 0x7c636a14; /* add 3,3,13 */
14944 if (offset != (bfd_vma) -1)
14945 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14946 if ((tls_mask & TLS_EXPLICIT) == 0)
14947 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14948 + R_PPC64_GOT_TPREL16_DS);
14950 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14951 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14956 insn1 &= 0x1f << 21;
14957 insn1 |= 0x3c0d0000; /* addis r,13,0 */
14958 insn2 = 0x38630000; /* addi 3,3,0 */
14961 /* Was an LD reloc. */
14963 sec = local_sections[toc_symndx];
14965 r_symndx < symtab_hdr->sh_info;
14967 if (local_sections[r_symndx] == sec)
14969 if (r_symndx >= symtab_hdr->sh_info)
14970 r_symndx = STN_UNDEF;
14971 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14972 if (r_symndx != STN_UNDEF)
14973 rel->r_addend -= (local_syms[r_symndx].st_value
14974 + sec->output_offset
14975 + sec->output_section->vma);
14977 else if (toc_symndx != 0)
14979 r_symndx = toc_symndx;
14980 rel->r_addend = toc_addend;
14982 r_type = R_PPC64_TPREL16_HA;
14983 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14984 if (offset != (bfd_vma) -1)
14986 rel[1].r_info = ELF64_R_INFO (r_symndx,
14987 R_PPC64_TPREL16_LO);
14988 rel[1].r_offset = offset + d_offset;
14989 rel[1].r_addend = rel->r_addend;
14992 bfd_put_32 (input_bfd, insn1,
14993 contents + rel->r_offset - d_offset);
14994 if (offset != (bfd_vma) -1)
14995 bfd_put_32 (input_bfd, insn2, contents + offset);
14996 if ((tls_mask & tls_gd) == 0
14997 && (tls_gd == 0 || toc_symndx != 0))
14999 /* We changed the symbol. Start over in order
15000 to get h, sym, sec etc. right. */
15006 case R_PPC64_TLSGD:
15007 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
15008 && rel + 1 < relend)
15010 unsigned int insn2;
15011 bfd_vma offset = rel->r_offset;
15013 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15015 bfd_put_32 (output_bfd, NOP, contents + offset);
15016 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15020 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15021 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15023 if ((tls_mask & TLS_TPRELGD) != 0)
15026 r_type = R_PPC64_NONE;
15027 insn2 = 0x7c636a14; /* add 3,3,13 */
15032 if (toc_symndx != 0)
15034 r_symndx = toc_symndx;
15035 rel->r_addend = toc_addend;
15037 r_type = R_PPC64_TPREL16_LO;
15038 rel->r_offset = offset + d_offset;
15039 insn2 = 0x38630000; /* addi 3,3,0 */
15041 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15042 /* Zap the reloc on the _tls_get_addr call too. */
15043 BFD_ASSERT (offset == rel[1].r_offset);
15044 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15045 bfd_put_32 (input_bfd, insn2, contents + offset);
15046 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
15051 case R_PPC64_TLSLD:
15052 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
15053 && rel + 1 < relend)
15055 unsigned int insn2;
15056 bfd_vma offset = rel->r_offset;
15058 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15060 bfd_put_32 (output_bfd, NOP, contents + offset);
15061 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15065 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15066 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15069 sec = local_sections[toc_symndx];
15071 r_symndx < symtab_hdr->sh_info;
15073 if (local_sections[r_symndx] == sec)
15075 if (r_symndx >= symtab_hdr->sh_info)
15076 r_symndx = STN_UNDEF;
15077 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
15078 if (r_symndx != STN_UNDEF)
15079 rel->r_addend -= (local_syms[r_symndx].st_value
15080 + sec->output_offset
15081 + sec->output_section->vma);
15083 r_type = R_PPC64_TPREL16_LO;
15084 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15085 rel->r_offset = offset + d_offset;
15086 /* Zap the reloc on the _tls_get_addr call too. */
15087 BFD_ASSERT (offset == rel[1].r_offset);
15088 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15089 insn2 = 0x38630000; /* addi 3,3,0 */
15090 bfd_put_32 (input_bfd, insn2, contents + offset);
15095 case R_PPC64_DTPMOD64:
15096 if (rel + 1 < relend
15097 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
15098 && rel[1].r_offset == rel->r_offset + 8)
15100 if ((tls_mask & TLS_GD) == 0)
15102 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
15103 if ((tls_mask & TLS_TPRELGD) != 0)
15104 r_type = R_PPC64_TPREL64;
15107 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15108 r_type = R_PPC64_NONE;
15110 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15115 if ((tls_mask & TLS_LD) == 0)
15117 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15118 r_type = R_PPC64_NONE;
15119 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15124 case R_PPC64_TPREL64:
15125 if ((tls_mask & TLS_TPREL) == 0)
15127 r_type = R_PPC64_NONE;
15128 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15132 case R_PPC64_ENTRY:
15133 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
15134 if (!bfd_link_pic (info)
15135 && !info->traditional_format
15136 && relocation + 0x80008000 <= 0xffffffff)
15138 unsigned int insn1, insn2;
15140 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15141 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15142 if ((insn1 & ~0xfffc) == LD_R2_0R12
15143 && insn2 == ADD_R2_R2_R12)
15145 bfd_put_32 (input_bfd,
15146 LIS_R2 + PPC_HA (relocation),
15147 contents + rel->r_offset);
15148 bfd_put_32 (input_bfd,
15149 ADDI_R2_R2 + PPC_LO (relocation),
15150 contents + rel->r_offset + 4);
15155 relocation -= (rel->r_offset
15156 + input_section->output_offset
15157 + input_section->output_section->vma);
15158 if (relocation + 0x80008000 <= 0xffffffff)
15160 unsigned int insn1, insn2;
15162 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15163 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15164 if ((insn1 & ~0xfffc) == LD_R2_0R12
15165 && insn2 == ADD_R2_R2_R12)
15167 bfd_put_32 (input_bfd,
15168 ADDIS_R2_R12 + PPC_HA (relocation),
15169 contents + rel->r_offset);
15170 bfd_put_32 (input_bfd,
15171 ADDI_R2_R2 + PPC_LO (relocation),
15172 contents + rel->r_offset + 4);
15178 case R_PPC64_REL16_HA:
15179 /* If we are generating a non-PIC executable, edit
15180 . 0: addis 2,12,.TOC.-0b@ha
15181 . addi 2,2,.TOC.-0b@l
15182 used by ELFv2 global entry points to set up r2, to
15185 if .TOC. is in range. */
15186 if (!bfd_link_pic (info)
15187 && !info->traditional_format
15189 && rel->r_addend == d_offset
15190 && h != NULL && &h->elf == htab->elf.hgot
15191 && rel + 1 < relend
15192 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
15193 && rel[1].r_offset == rel->r_offset + 4
15194 && rel[1].r_addend == rel->r_addend + 4
15195 && relocation + 0x80008000 <= 0xffffffff)
15197 unsigned int insn1, insn2;
15198 bfd_vma offset = rel->r_offset - d_offset;
15199 insn1 = bfd_get_32 (input_bfd, contents + offset);
15200 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
15201 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
15202 && (insn2 & 0xffff0000) == ADDI_R2_R2)
15204 r_type = R_PPC64_ADDR16_HA;
15205 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15206 rel->r_addend -= d_offset;
15207 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
15208 rel[1].r_addend -= d_offset + 4;
15209 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
15215 /* Handle other relocations that tweak non-addend part of insn. */
15217 max_br_offset = 1 << 25;
15218 addend = rel->r_addend;
15219 reloc_dest = DEST_NORMAL;
15225 case R_PPC64_TOCSAVE:
15226 if (relocation + addend == (rel->r_offset
15227 + input_section->output_offset
15228 + input_section->output_section->vma)
15229 && tocsave_find (htab, NO_INSERT,
15230 &local_syms, rel, input_bfd))
15232 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15234 || insn == CROR_151515 || insn == CROR_313131)
15235 bfd_put_32 (input_bfd,
15236 STD_R2_0R1 + STK_TOC (htab),
15237 contents + rel->r_offset);
15241 /* Branch taken prediction relocations. */
15242 case R_PPC64_ADDR14_BRTAKEN:
15243 case R_PPC64_REL14_BRTAKEN:
15244 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15245 /* Fall through. */
15247 /* Branch not taken prediction relocations. */
15248 case R_PPC64_ADDR14_BRNTAKEN:
15249 case R_PPC64_REL14_BRNTAKEN:
15250 insn |= bfd_get_32 (input_bfd,
15251 contents + rel->r_offset) & ~(0x01 << 21);
15252 /* Fall through. */
15254 case R_PPC64_REL14:
15255 max_br_offset = 1 << 15;
15256 /* Fall through. */
15258 case R_PPC64_REL24:
15259 case R_PPC64_REL24_NOTOC:
15260 case R_PPC64_PLTCALL:
15261 /* Calls to functions with a different TOC, such as calls to
15262 shared objects, need to alter the TOC pointer. This is
15263 done using a linkage stub. A REL24 branching to these
15264 linkage stubs needs to be followed by a nop, as the nop
15265 will be replaced with an instruction to restore the TOC
15270 && h->oh->is_func_descriptor)
15271 fdh = ppc_follow_link (h->oh);
15272 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15274 if (r_type == R_PPC64_PLTCALL
15275 && stub_entry != NULL
15276 && stub_entry->stub_type >= ppc_stub_plt_call
15277 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15280 if (stub_entry != NULL
15281 && (stub_entry->stub_type == ppc_stub_plt_call
15282 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15283 || stub_entry->stub_type == ppc_stub_plt_call_both
15284 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15285 || stub_entry->stub_type == ppc_stub_plt_branch_both
15286 || stub_entry->stub_type == ppc_stub_long_branch_r2off
15287 || stub_entry->stub_type == ppc_stub_long_branch_both))
15289 bfd_boolean can_plt_call = FALSE;
15291 if (stub_entry->stub_type == ppc_stub_plt_call
15293 && htab->params->plt_localentry0 != 0
15294 && is_elfv2_localentry0 (&h->elf))
15296 /* The function doesn't use or change r2. */
15297 can_plt_call = TRUE;
15299 else if (r_type == R_PPC64_REL24_NOTOC)
15301 /* NOTOC calls don't need to restore r2. */
15302 can_plt_call = TRUE;
15305 /* All of these stubs may modify r2, so there must be a
15306 branch and link followed by a nop. The nop is
15307 replaced by an insn to restore r2. */
15308 else if (rel->r_offset + 8 <= input_section->size)
15312 br = bfd_get_32 (input_bfd,
15313 contents + rel->r_offset);
15318 nop = bfd_get_32 (input_bfd,
15319 contents + rel->r_offset + 4);
15320 if (nop == LD_R2_0R1 + STK_TOC (htab))
15321 can_plt_call = TRUE;
15322 else if (nop == NOP
15323 || nop == CROR_151515
15324 || nop == CROR_313131)
15327 && (h == htab->tls_get_addr_fd
15328 || h == htab->tls_get_addr)
15329 && htab->params->tls_get_addr_opt)
15331 /* Special stub used, leave nop alone. */
15334 bfd_put_32 (input_bfd,
15335 LD_R2_0R1 + STK_TOC (htab),
15336 contents + rel->r_offset + 4);
15337 can_plt_call = TRUE;
15342 if (!can_plt_call && h != NULL)
15344 const char *name = h->elf.root.root.string;
15349 if (strncmp (name, "__libc_start_main", 17) == 0
15350 && (name[17] == 0 || name[17] == '@'))
15352 /* Allow crt1 branch to go via a toc adjusting
15353 stub. Other calls that never return could do
15354 the same, if we could detect such. */
15355 can_plt_call = TRUE;
15361 /* g++ as of 20130507 emits self-calls without a
15362 following nop. This is arguably wrong since we
15363 have conflicting information. On the one hand a
15364 global symbol and on the other a local call
15365 sequence, but don't error for this special case.
15366 It isn't possible to cheaply verify we have
15367 exactly such a call. Allow all calls to the same
15369 asection *code_sec = sec;
15371 if (get_opd_info (sec) != NULL)
15373 bfd_vma off = (relocation + addend
15374 - sec->output_section->vma
15375 - sec->output_offset);
15377 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15379 if (code_sec == input_section)
15380 can_plt_call = TRUE;
15385 if (stub_entry->stub_type >= ppc_stub_plt_call
15386 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15387 info->callbacks->einfo
15388 /* xgettext:c-format */
15389 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15390 "recompile with -fPIC\n"),
15391 input_bfd, input_section, rel->r_offset, sym_name);
15393 info->callbacks->einfo
15394 /* xgettext:c-format */
15395 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15396 "(-mcmodel=small toc adjust stub)\n"),
15397 input_bfd, input_section, rel->r_offset, sym_name);
15399 bfd_set_error (bfd_error_bad_value);
15404 && stub_entry->stub_type >= ppc_stub_plt_call
15405 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15406 unresolved_reloc = FALSE;
15409 if ((stub_entry == NULL
15410 || stub_entry->stub_type == ppc_stub_long_branch
15411 || stub_entry->stub_type == ppc_stub_plt_branch)
15412 && get_opd_info (sec) != NULL)
15414 /* The branch destination is the value of the opd entry. */
15415 bfd_vma off = (relocation + addend
15416 - sec->output_section->vma
15417 - sec->output_offset);
15418 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15419 if (dest != (bfd_vma) -1)
15423 reloc_dest = DEST_OPD;
15427 /* If the branch is out of reach we ought to have a long
15429 from = (rel->r_offset
15430 + input_section->output_offset
15431 + input_section->output_section->vma);
15433 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15437 if (stub_entry != NULL
15438 && (stub_entry->stub_type == ppc_stub_long_branch
15439 || stub_entry->stub_type == ppc_stub_plt_branch)
15440 && (r_type == R_PPC64_ADDR14_BRTAKEN
15441 || r_type == R_PPC64_ADDR14_BRNTAKEN
15442 || (relocation + addend - from + max_br_offset
15443 < 2 * max_br_offset)))
15444 /* Don't use the stub if this branch is in range. */
15447 if (stub_entry != NULL
15448 && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15449 || stub_entry->stub_type == ppc_stub_long_branch_both
15450 || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15451 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15452 && (r_type != R_PPC64_REL24_NOTOC
15453 || ((fdh ? fdh->elf.other : sym->st_other)
15454 & STO_PPC64_LOCAL_MASK) == 1 << STO_PPC64_LOCAL_BIT)
15455 && (relocation + addend - from + max_br_offset
15456 < 2 * max_br_offset))
15459 if (stub_entry != NULL
15460 && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15461 || stub_entry->stub_type == ppc_stub_long_branch_both
15462 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15463 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15464 && r_type == R_PPC64_REL24_NOTOC
15465 && (relocation + addend - from + max_br_offset
15466 < 2 * max_br_offset))
15469 if (stub_entry != NULL)
15471 /* Munge up the value and addend so that we call the stub
15472 rather than the procedure directly. */
15473 asection *stub_sec = stub_entry->group->stub_sec;
15475 if (stub_entry->stub_type == ppc_stub_save_res)
15476 relocation += (stub_sec->output_offset
15477 + stub_sec->output_section->vma
15478 + stub_sec->size - htab->sfpr->size
15479 - htab->sfpr->output_offset
15480 - htab->sfpr->output_section->vma);
15482 relocation = (stub_entry->stub_offset
15483 + stub_sec->output_offset
15484 + stub_sec->output_section->vma);
15486 reloc_dest = DEST_STUB;
15488 if (((stub_entry->stub_type == ppc_stub_plt_call
15489 && ALWAYS_EMIT_R2SAVE)
15490 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15491 || stub_entry->stub_type == ppc_stub_plt_call_both)
15493 && (h == htab->tls_get_addr_fd
15494 || h == htab->tls_get_addr)
15495 && htab->params->tls_get_addr_opt)
15496 && rel + 1 < relend
15497 && rel[1].r_offset == rel->r_offset + 4
15498 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15500 else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15501 || stub_entry->stub_type == ppc_stub_plt_branch_both
15502 || stub_entry->stub_type == ppc_stub_plt_call_both)
15503 && r_type == R_PPC64_REL24_NOTOC)
15511 /* Set 'a' bit. This is 0b00010 in BO field for branch
15512 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15513 for branch on CTR insns (BO == 1a00t or 1a01t). */
15514 if ((insn & (0x14 << 21)) == (0x04 << 21))
15515 insn |= 0x02 << 21;
15516 else if ((insn & (0x14 << 21)) == (0x10 << 21))
15517 insn |= 0x08 << 21;
15523 /* Invert 'y' bit if not the default. */
15524 if ((bfd_signed_vma) (relocation + addend - from) < 0)
15525 insn ^= 0x01 << 21;
15528 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15531 /* NOP out calls to undefined weak functions.
15532 We can thus call a weak function without first
15533 checking whether the function is defined. */
15535 && h->elf.root.type == bfd_link_hash_undefweak
15536 && h->elf.dynindx == -1
15537 && (r_type == R_PPC64_REL24
15538 || r_type == R_PPC64_REL24_NOTOC)
15542 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15548 /* Set `addend'. */
15550 save_unresolved_reloc = unresolved_reloc;
15554 /* xgettext:c-format */
15555 _bfd_error_handler (_("%pB: %s unsupported"),
15556 input_bfd, ppc64_elf_howto_table[r_type]->name);
15558 bfd_set_error (bfd_error_bad_value);
15564 case R_PPC64_TLSGD:
15565 case R_PPC64_TLSLD:
15566 case R_PPC64_TOCSAVE:
15567 case R_PPC64_GNU_VTINHERIT:
15568 case R_PPC64_GNU_VTENTRY:
15569 case R_PPC64_ENTRY:
15572 /* GOT16 relocations. Like an ADDR16 using the symbol's
15573 address in the GOT as relocation value instead of the
15574 symbol's value itself. Also, create a GOT entry for the
15575 symbol and put the symbol value there. */
15576 case R_PPC64_GOT_TLSGD16:
15577 case R_PPC64_GOT_TLSGD16_LO:
15578 case R_PPC64_GOT_TLSGD16_HI:
15579 case R_PPC64_GOT_TLSGD16_HA:
15580 tls_type = TLS_TLS | TLS_GD;
15583 case R_PPC64_GOT_TLSLD16:
15584 case R_PPC64_GOT_TLSLD16_LO:
15585 case R_PPC64_GOT_TLSLD16_HI:
15586 case R_PPC64_GOT_TLSLD16_HA:
15587 tls_type = TLS_TLS | TLS_LD;
15590 case R_PPC64_GOT_TPREL16_DS:
15591 case R_PPC64_GOT_TPREL16_LO_DS:
15592 case R_PPC64_GOT_TPREL16_HI:
15593 case R_PPC64_GOT_TPREL16_HA:
15594 tls_type = TLS_TLS | TLS_TPREL;
15597 case R_PPC64_GOT_DTPREL16_DS:
15598 case R_PPC64_GOT_DTPREL16_LO_DS:
15599 case R_PPC64_GOT_DTPREL16_HI:
15600 case R_PPC64_GOT_DTPREL16_HA:
15601 tls_type = TLS_TLS | TLS_DTPREL;
15604 case R_PPC64_GOT16:
15605 case R_PPC64_GOT16_LO:
15606 case R_PPC64_GOT16_HI:
15607 case R_PPC64_GOT16_HA:
15608 case R_PPC64_GOT16_DS:
15609 case R_PPC64_GOT16_LO_DS:
15612 /* Relocation is to the entry for this symbol in the global
15617 unsigned long indx = 0;
15618 struct got_entry *ent;
15620 if (tls_type == (TLS_TLS | TLS_LD)
15622 || !h->elf.def_dynamic))
15623 ent = ppc64_tlsld_got (input_bfd);
15628 if (!htab->elf.dynamic_sections_created
15629 || h->elf.dynindx == -1
15630 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15631 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15632 /* This is actually a static link, or it is a
15633 -Bsymbolic link and the symbol is defined
15634 locally, or the symbol was forced to be local
15635 because of a version file. */
15639 indx = h->elf.dynindx;
15640 unresolved_reloc = FALSE;
15642 ent = h->elf.got.glist;
15646 if (local_got_ents == NULL)
15648 ent = local_got_ents[r_symndx];
15651 for (; ent != NULL; ent = ent->next)
15652 if (ent->addend == orig_rel.r_addend
15653 && ent->owner == input_bfd
15654 && ent->tls_type == tls_type)
15660 if (ent->is_indirect)
15661 ent = ent->got.ent;
15662 offp = &ent->got.offset;
15663 got = ppc64_elf_tdata (ent->owner)->got;
15667 /* The offset must always be a multiple of 8. We use the
15668 least significant bit to record whether we have already
15669 processed this entry. */
15671 if ((off & 1) != 0)
15675 /* Generate relocs for the dynamic linker, except in
15676 the case of TLSLD where we'll use one entry per
15684 ? h->elf.type == STT_GNU_IFUNC
15685 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15688 relgot = htab->elf.irelplt;
15690 htab->local_ifunc_resolver = 1;
15691 else if (is_static_defined (&h->elf))
15692 htab->maybe_local_ifunc_resolver = 1;
15695 || (bfd_link_pic (info)
15697 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15698 || (tls_type == (TLS_TLS | TLS_LD)
15699 && !h->elf.def_dynamic))
15700 && !(tls_type == (TLS_TLS | TLS_TPREL)
15701 && bfd_link_executable (info)
15702 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15703 relgot = ppc64_elf_tdata (ent->owner)->relgot;
15704 if (relgot != NULL)
15706 outrel.r_offset = (got->output_section->vma
15707 + got->output_offset
15709 outrel.r_addend = addend;
15710 if (tls_type & (TLS_LD | TLS_GD))
15712 outrel.r_addend = 0;
15713 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15714 if (tls_type == (TLS_TLS | TLS_GD))
15716 loc = relgot->contents;
15717 loc += (relgot->reloc_count++
15718 * sizeof (Elf64_External_Rela));
15719 bfd_elf64_swap_reloca_out (output_bfd,
15721 outrel.r_offset += 8;
15722 outrel.r_addend = addend;
15724 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15727 else if (tls_type == (TLS_TLS | TLS_DTPREL))
15728 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15729 else if (tls_type == (TLS_TLS | TLS_TPREL))
15730 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15731 else if (indx != 0)
15732 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15736 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15738 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15740 /* Write the .got section contents for the sake
15742 loc = got->contents + off;
15743 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15747 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15749 outrel.r_addend += relocation;
15750 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15752 if (htab->elf.tls_sec == NULL)
15753 outrel.r_addend = 0;
15755 outrel.r_addend -= htab->elf.tls_sec->vma;
15758 loc = relgot->contents;
15759 loc += (relgot->reloc_count++
15760 * sizeof (Elf64_External_Rela));
15761 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15764 /* Init the .got section contents here if we're not
15765 emitting a reloc. */
15768 relocation += addend;
15771 if (htab->elf.tls_sec == NULL)
15775 if (tls_type & TLS_LD)
15778 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15779 if (tls_type & TLS_TPREL)
15780 relocation += DTP_OFFSET - TP_OFFSET;
15783 if (tls_type & (TLS_GD | TLS_LD))
15785 bfd_put_64 (output_bfd, relocation,
15786 got->contents + off + 8);
15790 bfd_put_64 (output_bfd, relocation,
15791 got->contents + off);
15795 if (off >= (bfd_vma) -2)
15798 relocation = got->output_section->vma + got->output_offset + off;
15799 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15803 case R_PPC64_PLT16_HA:
15804 case R_PPC64_PLT16_HI:
15805 case R_PPC64_PLT16_LO:
15806 case R_PPC64_PLT16_LO_DS:
15807 case R_PPC64_PLT32:
15808 case R_PPC64_PLT64:
15809 case R_PPC64_PLTSEQ:
15810 case R_PPC64_PLTCALL:
15811 /* Relocation is to the entry for this symbol in the
15812 procedure linkage table. */
15813 unresolved_reloc = TRUE;
15815 struct plt_entry **plt_list = NULL;
15817 plt_list = &h->elf.plt.plist;
15818 else if (local_got_ents != NULL)
15820 struct plt_entry **local_plt = (struct plt_entry **)
15821 (local_got_ents + symtab_hdr->sh_info);
15822 plt_list = local_plt + r_symndx;
15826 struct plt_entry *ent;
15828 for (ent = *plt_list; ent != NULL; ent = ent->next)
15829 if (ent->plt.offset != (bfd_vma) -1
15830 && ent->addend == orig_rel.r_addend)
15835 plt = htab->elf.splt;
15836 if (!htab->elf.dynamic_sections_created
15838 || h->elf.dynindx == -1)
15841 ? h->elf.type == STT_GNU_IFUNC
15842 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15843 plt = htab->elf.iplt;
15845 plt = htab->pltlocal;
15847 relocation = (plt->output_section->vma
15848 + plt->output_offset
15849 + ent->plt.offset);
15850 if (r_type == R_PPC64_PLT16_HA
15851 || r_type ==R_PPC64_PLT16_HI
15852 || r_type ==R_PPC64_PLT16_LO
15853 || r_type ==R_PPC64_PLT16_LO_DS)
15855 got = (elf_gp (output_bfd)
15856 + htab->sec_info[input_section->id].toc_off);
15860 unresolved_reloc = FALSE;
15868 /* Relocation value is TOC base. */
15869 relocation = TOCstart;
15870 if (r_symndx == STN_UNDEF)
15871 relocation += htab->sec_info[input_section->id].toc_off;
15872 else if (unresolved_reloc)
15874 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15875 relocation += htab->sec_info[sec->id].toc_off;
15877 unresolved_reloc = TRUE;
15880 /* TOC16 relocs. We want the offset relative to the TOC base,
15881 which is the address of the start of the TOC plus 0x8000.
15882 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15884 case R_PPC64_TOC16:
15885 case R_PPC64_TOC16_LO:
15886 case R_PPC64_TOC16_HI:
15887 case R_PPC64_TOC16_DS:
15888 case R_PPC64_TOC16_LO_DS:
15889 case R_PPC64_TOC16_HA:
15890 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15893 /* Relocate against the beginning of the section. */
15894 case R_PPC64_SECTOFF:
15895 case R_PPC64_SECTOFF_LO:
15896 case R_PPC64_SECTOFF_HI:
15897 case R_PPC64_SECTOFF_DS:
15898 case R_PPC64_SECTOFF_LO_DS:
15899 case R_PPC64_SECTOFF_HA:
15901 addend -= sec->output_section->vma;
15904 case R_PPC64_REL16:
15905 case R_PPC64_REL16_LO:
15906 case R_PPC64_REL16_HI:
15907 case R_PPC64_REL16_HA:
15908 case R_PPC64_REL16DX_HA:
15911 case R_PPC64_REL14:
15912 case R_PPC64_REL14_BRNTAKEN:
15913 case R_PPC64_REL14_BRTAKEN:
15914 case R_PPC64_REL24:
15915 case R_PPC64_REL24_NOTOC:
15918 case R_PPC64_TPREL16:
15919 case R_PPC64_TPREL16_LO:
15920 case R_PPC64_TPREL16_HI:
15921 case R_PPC64_TPREL16_HA:
15922 case R_PPC64_TPREL16_DS:
15923 case R_PPC64_TPREL16_LO_DS:
15924 case R_PPC64_TPREL16_HIGH:
15925 case R_PPC64_TPREL16_HIGHA:
15926 case R_PPC64_TPREL16_HIGHER:
15927 case R_PPC64_TPREL16_HIGHERA:
15928 case R_PPC64_TPREL16_HIGHEST:
15929 case R_PPC64_TPREL16_HIGHESTA:
15931 && h->elf.root.type == bfd_link_hash_undefweak
15932 && h->elf.dynindx == -1)
15934 /* Make this relocation against an undefined weak symbol
15935 resolve to zero. This is really just a tweak, since
15936 code using weak externs ought to check that they are
15937 defined before using them. */
15938 bfd_byte *p = contents + rel->r_offset - d_offset;
15940 insn = bfd_get_32 (input_bfd, p);
15941 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15943 bfd_put_32 (input_bfd, insn, p);
15946 if (htab->elf.tls_sec != NULL)
15947 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15948 /* The TPREL16 relocs shouldn't really be used in shared
15949 libs or with non-local symbols as that will result in
15950 DT_TEXTREL being set, but support them anyway. */
15953 case R_PPC64_DTPREL16:
15954 case R_PPC64_DTPREL16_LO:
15955 case R_PPC64_DTPREL16_HI:
15956 case R_PPC64_DTPREL16_HA:
15957 case R_PPC64_DTPREL16_DS:
15958 case R_PPC64_DTPREL16_LO_DS:
15959 case R_PPC64_DTPREL16_HIGH:
15960 case R_PPC64_DTPREL16_HIGHA:
15961 case R_PPC64_DTPREL16_HIGHER:
15962 case R_PPC64_DTPREL16_HIGHERA:
15963 case R_PPC64_DTPREL16_HIGHEST:
15964 case R_PPC64_DTPREL16_HIGHESTA:
15965 if (htab->elf.tls_sec != NULL)
15966 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15969 case R_PPC64_ADDR64_LOCAL:
15970 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15975 case R_PPC64_DTPMOD64:
15980 case R_PPC64_TPREL64:
15981 if (htab->elf.tls_sec != NULL)
15982 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15985 case R_PPC64_DTPREL64:
15986 if (htab->elf.tls_sec != NULL)
15987 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15988 /* Fall through. */
15990 /* Relocations that may need to be propagated if this is a
15992 case R_PPC64_REL30:
15993 case R_PPC64_REL32:
15994 case R_PPC64_REL64:
15995 case R_PPC64_ADDR14:
15996 case R_PPC64_ADDR14_BRNTAKEN:
15997 case R_PPC64_ADDR14_BRTAKEN:
15998 case R_PPC64_ADDR16:
15999 case R_PPC64_ADDR16_DS:
16000 case R_PPC64_ADDR16_HA:
16001 case R_PPC64_ADDR16_HI:
16002 case R_PPC64_ADDR16_HIGH:
16003 case R_PPC64_ADDR16_HIGHA:
16004 case R_PPC64_ADDR16_HIGHER:
16005 case R_PPC64_ADDR16_HIGHERA:
16006 case R_PPC64_ADDR16_HIGHEST:
16007 case R_PPC64_ADDR16_HIGHESTA:
16008 case R_PPC64_ADDR16_LO:
16009 case R_PPC64_ADDR16_LO_DS:
16010 case R_PPC64_ADDR24:
16011 case R_PPC64_ADDR32:
16012 case R_PPC64_ADDR64:
16013 case R_PPC64_UADDR16:
16014 case R_PPC64_UADDR32:
16015 case R_PPC64_UADDR64:
16017 if ((input_section->flags & SEC_ALLOC) == 0)
16020 if (NO_OPD_RELOCS && is_opd)
16023 if (bfd_link_pic (info)
16025 || h->dyn_relocs != NULL)
16026 && ((h != NULL && pc_dynrelocs (h))
16027 || must_be_dyn_reloc (info, r_type)))
16029 ? h->dyn_relocs != NULL
16030 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16032 bfd_boolean skip, relocate;
16037 /* When generating a dynamic object, these relocations
16038 are copied into the output file to be resolved at run
16044 out_off = _bfd_elf_section_offset (output_bfd, info,
16045 input_section, rel->r_offset);
16046 if (out_off == (bfd_vma) -1)
16048 else if (out_off == (bfd_vma) -2)
16049 skip = TRUE, relocate = TRUE;
16050 out_off += (input_section->output_section->vma
16051 + input_section->output_offset);
16052 outrel.r_offset = out_off;
16053 outrel.r_addend = rel->r_addend;
16055 /* Optimize unaligned reloc use. */
16056 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
16057 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
16058 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
16059 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
16060 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
16061 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
16062 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
16063 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
16064 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
16067 memset (&outrel, 0, sizeof outrel);
16068 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
16070 && r_type != R_PPC64_TOC)
16072 indx = h->elf.dynindx;
16073 BFD_ASSERT (indx != -1);
16074 outrel.r_info = ELF64_R_INFO (indx, r_type);
16078 /* This symbol is local, or marked to become local,
16079 or this is an opd section reloc which must point
16080 at a local function. */
16081 outrel.r_addend += relocation;
16082 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
16084 if (is_opd && h != NULL)
16086 /* Lie about opd entries. This case occurs
16087 when building shared libraries and we
16088 reference a function in another shared
16089 lib. The same thing happens for a weak
16090 definition in an application that's
16091 overridden by a strong definition in a
16092 shared lib. (I believe this is a generic
16093 bug in binutils handling of weak syms.)
16094 In these cases we won't use the opd
16095 entry in this lib. */
16096 unresolved_reloc = FALSE;
16099 && r_type == R_PPC64_ADDR64
16101 ? h->elf.type == STT_GNU_IFUNC
16102 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16103 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
16106 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
16108 /* We need to relocate .opd contents for ld.so.
16109 Prelink also wants simple and consistent rules
16110 for relocs. This make all RELATIVE relocs have
16111 *r_offset equal to r_addend. */
16118 ? h->elf.type == STT_GNU_IFUNC
16119 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16121 info->callbacks->einfo
16122 /* xgettext:c-format */
16123 (_("%H: %s for indirect "
16124 "function `%pT' unsupported\n"),
16125 input_bfd, input_section, rel->r_offset,
16126 ppc64_elf_howto_table[r_type]->name,
16130 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
16132 else if (sec == NULL || sec->owner == NULL)
16134 bfd_set_error (bfd_error_bad_value);
16141 osec = sec->output_section;
16142 indx = elf_section_data (osec)->dynindx;
16146 if ((osec->flags & SEC_READONLY) == 0
16147 && htab->elf.data_index_section != NULL)
16148 osec = htab->elf.data_index_section;
16150 osec = htab->elf.text_index_section;
16151 indx = elf_section_data (osec)->dynindx;
16153 BFD_ASSERT (indx != 0);
16155 /* We are turning this relocation into one
16156 against a section symbol, so subtract out
16157 the output section's address but not the
16158 offset of the input section in the output
16160 outrel.r_addend -= osec->vma;
16163 outrel.r_info = ELF64_R_INFO (indx, r_type);
16167 sreloc = elf_section_data (input_section)->sreloc;
16169 ? h->elf.type == STT_GNU_IFUNC
16170 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16172 sreloc = htab->elf.irelplt;
16174 htab->local_ifunc_resolver = 1;
16175 else if (is_static_defined (&h->elf))
16176 htab->maybe_local_ifunc_resolver = 1;
16178 if (sreloc == NULL)
16181 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16184 loc = sreloc->contents;
16185 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16186 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16188 /* If this reloc is against an external symbol, it will
16189 be computed at runtime, so there's no need to do
16190 anything now. However, for the sake of prelink ensure
16191 that the section contents are a known value. */
16194 unresolved_reloc = FALSE;
16195 /* The value chosen here is quite arbitrary as ld.so
16196 ignores section contents except for the special
16197 case of .opd where the contents might be accessed
16198 before relocation. Choose zero, as that won't
16199 cause reloc overflow. */
16202 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16203 to improve backward compatibility with older
16205 if (r_type == R_PPC64_ADDR64)
16206 addend = outrel.r_addend;
16207 /* Adjust pc_relative relocs to have zero in *r_offset. */
16208 else if (ppc64_elf_howto_table[r_type]->pc_relative)
16209 addend = outrel.r_offset;
16215 case R_PPC64_GLOB_DAT:
16216 case R_PPC64_JMP_SLOT:
16217 case R_PPC64_JMP_IREL:
16218 case R_PPC64_RELATIVE:
16219 /* We shouldn't ever see these dynamic relocs in relocatable
16221 /* Fall through. */
16223 case R_PPC64_PLTGOT16:
16224 case R_PPC64_PLTGOT16_DS:
16225 case R_PPC64_PLTGOT16_HA:
16226 case R_PPC64_PLTGOT16_HI:
16227 case R_PPC64_PLTGOT16_LO:
16228 case R_PPC64_PLTGOT16_LO_DS:
16229 case R_PPC64_PLTREL32:
16230 case R_PPC64_PLTREL64:
16231 /* These ones haven't been implemented yet. */
16233 info->callbacks->einfo
16234 /* xgettext:c-format */
16235 (_("%P: %pB: %s is not supported for `%pT'\n"),
16237 ppc64_elf_howto_table[r_type]->name, sym_name);
16239 bfd_set_error (bfd_error_invalid_operation);
16244 /* Multi-instruction sequences that access the TOC can be
16245 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16246 to nop; addi rb,r2,x; */
16252 case R_PPC64_GOT_TLSLD16_HI:
16253 case R_PPC64_GOT_TLSGD16_HI:
16254 case R_PPC64_GOT_TPREL16_HI:
16255 case R_PPC64_GOT_DTPREL16_HI:
16256 case R_PPC64_GOT16_HI:
16257 case R_PPC64_TOC16_HI:
16258 /* These relocs would only be useful if building up an
16259 offset to later add to r2, perhaps in an indexed
16260 addressing mode instruction. Don't try to optimize.
16261 Unfortunately, the possibility of someone building up an
16262 offset like this or even with the HA relocs, means that
16263 we need to check the high insn when optimizing the low
16267 case R_PPC64_PLTCALL:
16268 if (unresolved_reloc)
16270 /* No plt entry. Make this into a direct call. */
16271 bfd_byte *p = contents + rel->r_offset;
16272 insn = bfd_get_32 (input_bfd, p);
16274 bfd_put_32 (input_bfd, B_DOT | insn, p);
16275 bfd_put_32 (input_bfd, NOP, p + 4);
16276 unresolved_reloc = save_unresolved_reloc;
16277 r_type = R_PPC64_REL24;
16281 case R_PPC64_PLTSEQ:
16282 if (unresolved_reloc)
16284 unresolved_reloc = FALSE;
16289 case R_PPC64_PLT16_HA:
16290 if (unresolved_reloc)
16292 unresolved_reloc = FALSE;
16295 /* Fall through. */
16296 case R_PPC64_GOT_TLSLD16_HA:
16297 case R_PPC64_GOT_TLSGD16_HA:
16298 case R_PPC64_GOT_TPREL16_HA:
16299 case R_PPC64_GOT_DTPREL16_HA:
16300 case R_PPC64_GOT16_HA:
16301 case R_PPC64_TOC16_HA:
16302 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16303 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16307 p = contents + (rel->r_offset & ~3);
16308 bfd_put_32 (input_bfd, NOP, p);
16313 case R_PPC64_PLT16_LO:
16314 case R_PPC64_PLT16_LO_DS:
16315 if (unresolved_reloc)
16317 unresolved_reloc = FALSE;
16320 /* Fall through. */
16321 case R_PPC64_GOT_TLSLD16_LO:
16322 case R_PPC64_GOT_TLSGD16_LO:
16323 case R_PPC64_GOT_TPREL16_LO_DS:
16324 case R_PPC64_GOT_DTPREL16_LO_DS:
16325 case R_PPC64_GOT16_LO:
16326 case R_PPC64_GOT16_LO_DS:
16327 case R_PPC64_TOC16_LO:
16328 case R_PPC64_TOC16_LO_DS:
16329 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16330 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16332 bfd_byte *p = contents + (rel->r_offset & ~3);
16333 insn = bfd_get_32 (input_bfd, p);
16334 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16336 /* Transform addic to addi when we change reg. */
16337 insn &= ~((0x3f << 26) | (0x1f << 16));
16338 insn |= (14u << 26) | (2 << 16);
16342 insn &= ~(0x1f << 16);
16345 bfd_put_32 (input_bfd, insn, p);
16349 case R_PPC64_TPREL16_HA:
16350 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16352 bfd_byte *p = contents + (rel->r_offset & ~3);
16353 insn = bfd_get_32 (input_bfd, p);
16354 if ((insn & ((0x3f << 26) | 0x1f << 16))
16355 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16356 /* xgettext:c-format */
16357 info->callbacks->minfo
16358 (_("%H: warning: %s unexpected insn %#x.\n"),
16359 input_bfd, input_section, rel->r_offset,
16360 ppc64_elf_howto_table[r_type]->name, insn);
16363 bfd_put_32 (input_bfd, NOP, p);
16369 case R_PPC64_TPREL16_LO:
16370 case R_PPC64_TPREL16_LO_DS:
16371 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16373 bfd_byte *p = contents + (rel->r_offset & ~3);
16374 insn = bfd_get_32 (input_bfd, p);
16375 insn &= ~(0x1f << 16);
16377 bfd_put_32 (input_bfd, insn, p);
16382 /* Do any further special processing. */
16388 case R_PPC64_REL16_HA:
16389 case R_PPC64_REL16DX_HA:
16390 case R_PPC64_ADDR16_HA:
16391 case R_PPC64_ADDR16_HIGHA:
16392 case R_PPC64_ADDR16_HIGHERA:
16393 case R_PPC64_ADDR16_HIGHESTA:
16394 case R_PPC64_TOC16_HA:
16395 case R_PPC64_SECTOFF_HA:
16396 case R_PPC64_TPREL16_HA:
16397 case R_PPC64_TPREL16_HIGHA:
16398 case R_PPC64_TPREL16_HIGHERA:
16399 case R_PPC64_TPREL16_HIGHESTA:
16400 case R_PPC64_DTPREL16_HA:
16401 case R_PPC64_DTPREL16_HIGHA:
16402 case R_PPC64_DTPREL16_HIGHERA:
16403 case R_PPC64_DTPREL16_HIGHESTA:
16404 /* It's just possible that this symbol is a weak symbol
16405 that's not actually defined anywhere. In that case,
16406 'sec' would be NULL, and we should leave the symbol
16407 alone (it will be set to zero elsewhere in the link). */
16410 /* Fall through. */
16412 case R_PPC64_GOT16_HA:
16413 case R_PPC64_PLTGOT16_HA:
16414 case R_PPC64_PLT16_HA:
16415 case R_PPC64_GOT_TLSGD16_HA:
16416 case R_PPC64_GOT_TLSLD16_HA:
16417 case R_PPC64_GOT_TPREL16_HA:
16418 case R_PPC64_GOT_DTPREL16_HA:
16419 /* Add 0x10000 if sign bit in 0:15 is set.
16420 Bits 0:15 are not used. */
16424 case R_PPC64_ADDR16_DS:
16425 case R_PPC64_ADDR16_LO_DS:
16426 case R_PPC64_GOT16_DS:
16427 case R_PPC64_GOT16_LO_DS:
16428 case R_PPC64_PLT16_LO_DS:
16429 case R_PPC64_SECTOFF_DS:
16430 case R_PPC64_SECTOFF_LO_DS:
16431 case R_PPC64_TOC16_DS:
16432 case R_PPC64_TOC16_LO_DS:
16433 case R_PPC64_PLTGOT16_DS:
16434 case R_PPC64_PLTGOT16_LO_DS:
16435 case R_PPC64_GOT_TPREL16_DS:
16436 case R_PPC64_GOT_TPREL16_LO_DS:
16437 case R_PPC64_GOT_DTPREL16_DS:
16438 case R_PPC64_GOT_DTPREL16_LO_DS:
16439 case R_PPC64_TPREL16_DS:
16440 case R_PPC64_TPREL16_LO_DS:
16441 case R_PPC64_DTPREL16_DS:
16442 case R_PPC64_DTPREL16_LO_DS:
16443 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16445 /* If this reloc is against an lq, lxv, or stxv insn, then
16446 the value must be a multiple of 16. This is somewhat of
16447 a hack, but the "correct" way to do this by defining _DQ
16448 forms of all the _DS relocs bloats all reloc switches in
16449 this file. It doesn't make much sense to use these
16450 relocs in data, so testing the insn should be safe. */
16451 if ((insn & (0x3f << 26)) == (56u << 26)
16452 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16454 relocation += addend;
16455 addend = insn & (mask ^ 3);
16456 if ((relocation & mask) != 0)
16458 relocation ^= relocation & mask;
16459 info->callbacks->einfo
16460 /* xgettext:c-format */
16461 (_("%H: error: %s not a multiple of %u\n"),
16462 input_bfd, input_section, rel->r_offset,
16463 ppc64_elf_howto_table[r_type]->name,
16465 bfd_set_error (bfd_error_bad_value);
16472 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16473 because such sections are not SEC_ALLOC and thus ld.so will
16474 not process them. */
16475 howto = ppc64_elf_howto_table[(int) r_type];
16476 if (unresolved_reloc
16477 && !((input_section->flags & SEC_DEBUGGING) != 0
16478 && h->elf.def_dynamic)
16479 && _bfd_elf_section_offset (output_bfd, info, input_section,
16480 rel->r_offset) != (bfd_vma) -1)
16482 info->callbacks->einfo
16483 /* xgettext:c-format */
16484 (_("%H: unresolvable %s against `%pT'\n"),
16485 input_bfd, input_section, rel->r_offset,
16487 h->elf.root.root.string);
16491 /* 16-bit fields in insns mostly have signed values, but a
16492 few insns have 16-bit unsigned values. Really, we should
16493 have different reloc types. */
16494 if (howto->complain_on_overflow != complain_overflow_dont
16495 && howto->dst_mask == 0xffff
16496 && (input_section->flags & SEC_CODE) != 0)
16498 enum complain_overflow complain = complain_overflow_signed;
16500 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16501 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16502 complain = complain_overflow_bitfield;
16503 else if (howto->rightshift == 0
16504 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16505 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16506 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16507 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16508 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16509 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16510 complain = complain_overflow_unsigned;
16511 if (howto->complain_on_overflow != complain)
16513 alt_howto = *howto;
16514 alt_howto.complain_on_overflow = complain;
16515 howto = &alt_howto;
16519 if (r_type == R_PPC64_REL16DX_HA)
16521 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
16522 if (rel->r_offset + 4 > input_section->size)
16523 r = bfd_reloc_outofrange;
16526 relocation += addend;
16527 relocation -= (rel->r_offset
16528 + input_section->output_offset
16529 + input_section->output_section->vma);
16530 relocation = (bfd_signed_vma) relocation >> 16;
16531 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16533 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16534 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16536 if (relocation + 0x8000 > 0xffff)
16537 r = bfd_reloc_overflow;
16541 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
16542 rel->r_offset, relocation, addend);
16544 if (r != bfd_reloc_ok)
16546 char *more_info = NULL;
16547 const char *reloc_name = howto->name;
16549 if (reloc_dest != DEST_NORMAL)
16551 more_info = bfd_malloc (strlen (reloc_name) + 8);
16552 if (more_info != NULL)
16554 strcpy (more_info, reloc_name);
16555 strcat (more_info, (reloc_dest == DEST_OPD
16556 ? " (OPD)" : " (stub)"));
16557 reloc_name = more_info;
16561 if (r == bfd_reloc_overflow)
16563 /* On code like "if (foo) foo();" don't report overflow
16564 on a branch to zero when foo is undefined. */
16566 && (reloc_dest == DEST_STUB
16568 && (h->elf.root.type == bfd_link_hash_undefweak
16569 || h->elf.root.type == bfd_link_hash_undefined)
16570 && is_branch_reloc (r_type))))
16571 info->callbacks->reloc_overflow (info, &h->elf.root,
16572 sym_name, reloc_name,
16574 input_bfd, input_section,
16579 info->callbacks->einfo
16580 /* xgettext:c-format */
16581 (_("%H: %s against `%pT': error %d\n"),
16582 input_bfd, input_section, rel->r_offset,
16583 reloc_name, sym_name, (int) r);
16586 if (more_info != NULL)
16596 Elf_Internal_Shdr *rel_hdr;
16597 size_t deleted = rel - wrel;
16599 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16600 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16601 if (rel_hdr->sh_size == 0)
16603 /* It is too late to remove an empty reloc section. Leave
16605 ??? What is wrong with an empty section??? */
16606 rel_hdr->sh_size = rel_hdr->sh_entsize;
16609 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16610 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16611 input_section->reloc_count -= deleted;
16614 /* If we're emitting relocations, then shortly after this function
16615 returns, reloc offsets and addends for this section will be
16616 adjusted. Worse, reloc symbol indices will be for the output
16617 file rather than the input. Save a copy of the relocs for
16618 opd_entry_value. */
16619 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16622 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16623 rel = bfd_alloc (input_bfd, amt);
16624 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16625 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16628 memcpy (rel, relocs, amt);
16633 /* Adjust the value of any local symbols in opd sections. */
16636 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16637 const char *name ATTRIBUTE_UNUSED,
16638 Elf_Internal_Sym *elfsym,
16639 asection *input_sec,
16640 struct elf_link_hash_entry *h)
16642 struct _opd_sec_data *opd;
16649 opd = get_opd_info (input_sec);
16650 if (opd == NULL || opd->adjust == NULL)
16653 value = elfsym->st_value - input_sec->output_offset;
16654 if (!bfd_link_relocatable (info))
16655 value -= input_sec->output_section->vma;
16657 adjust = opd->adjust[OPD_NDX (value)];
16661 elfsym->st_value += adjust;
16665 /* Finish up dynamic symbol handling. We set the contents of various
16666 dynamic sections here. */
16669 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16670 struct bfd_link_info *info,
16671 struct elf_link_hash_entry *h,
16672 Elf_Internal_Sym *sym)
16674 struct ppc_link_hash_table *htab;
16675 struct plt_entry *ent;
16677 htab = ppc_hash_table (info);
16681 if (!htab->opd_abi && !h->def_regular)
16682 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16683 if (ent->plt.offset != (bfd_vma) -1)
16685 /* Mark the symbol as undefined, rather than as
16686 defined in glink. Leave the value if there were
16687 any relocations where pointer equality matters
16688 (this is a clue for the dynamic linker, to make
16689 function pointer comparisons work between an
16690 application and shared library), otherwise set it
16692 sym->st_shndx = SHN_UNDEF;
16693 if (!h->pointer_equality_needed)
16695 else if (!h->ref_regular_nonweak)
16697 /* This breaks function pointer comparisons, but
16698 that is better than breaking tests for a NULL
16699 function pointer. */
16707 /* This symbol needs a copy reloc. Set it up. */
16708 Elf_Internal_Rela rela;
16712 if (h->dynindx == -1
16713 || (h->root.type != bfd_link_hash_defined
16714 && h->root.type != bfd_link_hash_defweak)
16715 || htab->elf.srelbss == NULL
16716 || htab->elf.sreldynrelro == NULL)
16719 rela.r_offset = (h->root.u.def.value
16720 + h->root.u.def.section->output_section->vma
16721 + h->root.u.def.section->output_offset);
16722 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16724 if (h->root.u.def.section == htab->elf.sdynrelro)
16725 srel = htab->elf.sreldynrelro;
16727 srel = htab->elf.srelbss;
16728 loc = srel->contents;
16729 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16730 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16736 /* Used to decide how to sort relocs in an optimal manner for the
16737 dynamic linker, before writing them out. */
16739 static enum elf_reloc_type_class
16740 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16741 const asection *rel_sec,
16742 const Elf_Internal_Rela *rela)
16744 enum elf_ppc64_reloc_type r_type;
16745 struct ppc_link_hash_table *htab = ppc_hash_table (info);
16747 if (rel_sec == htab->elf.irelplt)
16748 return reloc_class_ifunc;
16750 r_type = ELF64_R_TYPE (rela->r_info);
16753 case R_PPC64_RELATIVE:
16754 return reloc_class_relative;
16755 case R_PPC64_JMP_SLOT:
16756 return reloc_class_plt;
16758 return reloc_class_copy;
16760 return reloc_class_normal;
16764 /* Finish up the dynamic sections. */
16767 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16768 struct bfd_link_info *info)
16770 struct ppc_link_hash_table *htab;
16774 htab = ppc_hash_table (info);
16778 dynobj = htab->elf.dynobj;
16779 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16781 if (htab->elf.dynamic_sections_created)
16783 Elf64_External_Dyn *dyncon, *dynconend;
16785 if (sdyn == NULL || htab->elf.sgot == NULL)
16788 dyncon = (Elf64_External_Dyn *) sdyn->contents;
16789 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16790 for (; dyncon < dynconend; dyncon++)
16792 Elf_Internal_Dyn dyn;
16795 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16802 case DT_PPC64_GLINK:
16804 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16805 /* We stupidly defined DT_PPC64_GLINK to be the start
16806 of glink rather than the first entry point, which is
16807 what ld.so needs, and now have a bigger stub to
16808 support automatic multiple TOCs. */
16809 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16813 s = bfd_get_section_by_name (output_bfd, ".opd");
16816 dyn.d_un.d_ptr = s->vma;
16820 if (htab->do_multi_toc && htab->multi_toc_needed)
16821 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16822 if (htab->has_plt_localentry0)
16823 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16826 case DT_PPC64_OPDSZ:
16827 s = bfd_get_section_by_name (output_bfd, ".opd");
16830 dyn.d_un.d_val = s->size;
16834 s = htab->elf.splt;
16835 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16839 s = htab->elf.srelplt;
16840 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16844 dyn.d_un.d_val = htab->elf.srelplt->size;
16848 if (htab->local_ifunc_resolver)
16849 info->callbacks->einfo
16850 (_("%X%P: text relocations and GNU indirect "
16851 "functions will result in a segfault at runtime\n"));
16852 else if (htab->maybe_local_ifunc_resolver)
16853 info->callbacks->einfo
16854 (_("%P: warning: text relocations and GNU indirect "
16855 "functions may result in a segfault at runtime\n"));
16859 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16863 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16864 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16866 /* Fill in the first entry in the global offset table.
16867 We use it to hold the link-time TOCbase. */
16868 bfd_put_64 (output_bfd,
16869 elf_gp (output_bfd) + TOC_BASE_OFF,
16870 htab->elf.sgot->contents);
16872 /* Set .got entry size. */
16873 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16876 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16877 && htab->elf.splt->output_section != bfd_abs_section_ptr)
16879 /* Set .plt entry size. */
16880 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16881 = PLT_ENTRY_SIZE (htab);
16884 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16885 brlt ourselves if emitrelocations. */
16886 if (htab->brlt != NULL
16887 && htab->brlt->reloc_count != 0
16888 && !_bfd_elf_link_output_relocs (output_bfd,
16890 elf_section_data (htab->brlt)->rela.hdr,
16891 elf_section_data (htab->brlt)->relocs,
16895 if (htab->glink != NULL
16896 && htab->glink->reloc_count != 0
16897 && !_bfd_elf_link_output_relocs (output_bfd,
16899 elf_section_data (htab->glink)->rela.hdr,
16900 elf_section_data (htab->glink)->relocs,
16905 if (htab->glink_eh_frame != NULL
16906 && htab->glink_eh_frame->size != 0
16907 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16908 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16909 htab->glink_eh_frame,
16910 htab->glink_eh_frame->contents))
16913 /* We need to handle writing out multiple GOT sections ourselves,
16914 since we didn't add them to DYNOBJ. We know dynobj is the first
16916 while ((dynobj = dynobj->link.next) != NULL)
16920 if (!is_ppc64_elf (dynobj))
16923 s = ppc64_elf_tdata (dynobj)->got;
16926 && s->output_section != bfd_abs_section_ptr
16927 && !bfd_set_section_contents (output_bfd, s->output_section,
16928 s->contents, s->output_offset,
16931 s = ppc64_elf_tdata (dynobj)->relgot;
16934 && s->output_section != bfd_abs_section_ptr
16935 && !bfd_set_section_contents (output_bfd, s->output_section,
16936 s->contents, s->output_offset,
16944 #include "elf64-target.h"
16946 /* FreeBSD support */
16948 #undef TARGET_LITTLE_SYM
16949 #undef TARGET_LITTLE_NAME
16951 #undef TARGET_BIG_SYM
16952 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
16953 #undef TARGET_BIG_NAME
16954 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16957 #define ELF_OSABI ELFOSABI_FREEBSD
16960 #define elf64_bed elf64_powerpc_fbsd_bed
16962 #include "elf64-target.h"