1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2016 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 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_before_check_relocs
98 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
108 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
110 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
121 /* The name of the dynamic interpreter. This is put in the .interp
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
131 /* Offsets to some stack save slots. */
133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
134 /* This one is dodgy. ELFv2 does not have a linker word, so use the
135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
139 /* TOC base pointers offset from start of TOC. */
140 #define TOC_BASE_OFF 0x8000
141 /* TOC base alignment. */
142 #define TOC_BASE_ALIGN 256
144 /* Offset of tp and dtp pointers from start of TLS block. */
145 #define TP_OFFSET 0x7000
146 #define DTP_OFFSET 0x8000
148 /* .plt call stub instructions. The normal stub is like this, but
149 sometimes the .plt entry crosses a 64k boundary and we need to
150 insert an addi to adjust r11. */
151 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
152 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
153 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
154 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
155 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
156 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
157 #define BCTR 0x4e800420 /* bctr */
159 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
160 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
161 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
163 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
164 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
165 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
166 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
167 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
168 #define BNECTR 0x4ca20420 /* bnectr+ */
169 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
171 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
172 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
173 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
175 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
176 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
177 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
179 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
180 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
181 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
182 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
183 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
185 /* glink call stub instructions. We enter with the index in R0. */
186 #define GLINK_CALL_STUB_SIZE (16*4)
190 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
191 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
193 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
194 /* ld %2,(0b-1b)(%11) */
195 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
196 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
202 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
203 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
204 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
205 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
206 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
209 #define NOP 0x60000000
211 /* Some other nops. */
212 #define CROR_151515 0x4def7b82
213 #define CROR_313131 0x4ffffb82
215 /* .glink entries for the first 32k functions are two instructions. */
216 #define LI_R0_0 0x38000000 /* li %r0,0 */
217 #define B_DOT 0x48000000 /* b . */
219 /* After that, we need two instructions to load the index, followed by
221 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
222 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
224 /* Instructions used by the save and restore reg functions. */
225 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
226 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
227 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
228 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
229 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
230 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
231 #define LI_R12_0 0x39800000 /* li %r12,0 */
232 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
233 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
234 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
235 #define BLR 0x4e800020 /* blr */
237 /* Since .opd is an array of descriptors and each entry will end up
238 with identical R_PPC64_RELATIVE relocs, there is really no need to
239 propagate .opd relocs; The dynamic linker should be taught to
240 relocate .opd without reloc entries. */
241 #ifndef NO_OPD_RELOCS
242 #define NO_OPD_RELOCS 0
246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
250 abiversion (bfd *abfd)
252 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
256 set_abiversion (bfd *abfd, int ver)
258 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
259 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
264 /* Relocation HOWTO's. */
265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
267 static reloc_howto_type ppc64_elf_howto_raw[] = {
268 /* This reloc does nothing. */
269 HOWTO (R_PPC64_NONE, /* type */
271 3, /* size (0 = byte, 1 = short, 2 = long) */
273 FALSE, /* pc_relative */
275 complain_overflow_dont, /* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_PPC64_NONE", /* name */
278 FALSE, /* partial_inplace */
281 FALSE), /* pcrel_offset */
283 /* A standard 32 bit relocation. */
284 HOWTO (R_PPC64_ADDR32, /* type */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
288 FALSE, /* pc_relative */
290 complain_overflow_bitfield, /* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_PPC64_ADDR32", /* name */
293 FALSE, /* partial_inplace */
295 0xffffffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
298 /* An absolute 26 bit branch; the lower two bits must be zero.
299 FIXME: we don't check that, we just clear them. */
300 HOWTO (R_PPC64_ADDR24, /* type */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
304 FALSE, /* pc_relative */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_PPC64_ADDR24", /* name */
309 FALSE, /* partial_inplace */
311 0x03fffffc, /* dst_mask */
312 FALSE), /* pcrel_offset */
314 /* A standard 16 bit relocation. */
315 HOWTO (R_PPC64_ADDR16, /* type */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
319 FALSE, /* pc_relative */
321 complain_overflow_bitfield, /* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_PPC64_ADDR16", /* name */
324 FALSE, /* partial_inplace */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
329 /* A 16 bit relocation without overflow. */
330 HOWTO (R_PPC64_ADDR16_LO, /* type */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
334 FALSE, /* pc_relative */
336 complain_overflow_dont,/* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_PPC64_ADDR16_LO", /* name */
339 FALSE, /* partial_inplace */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
344 /* Bits 16-31 of an address. */
345 HOWTO (R_PPC64_ADDR16_HI, /* type */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
349 FALSE, /* pc_relative */
351 complain_overflow_signed, /* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_PPC64_ADDR16_HI", /* name */
354 FALSE, /* partial_inplace */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
359 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
360 bits, treated as a signed number, is negative. */
361 HOWTO (R_PPC64_ADDR16_HA, /* type */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
365 FALSE, /* pc_relative */
367 complain_overflow_signed, /* complain_on_overflow */
368 ppc64_elf_ha_reloc, /* special_function */
369 "R_PPC64_ADDR16_HA", /* name */
370 FALSE, /* partial_inplace */
372 0xffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
375 /* An absolute 16 bit branch; the lower two bits must be zero.
376 FIXME: we don't check that, we just clear them. */
377 HOWTO (R_PPC64_ADDR14, /* type */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
381 FALSE, /* pc_relative */
383 complain_overflow_signed, /* complain_on_overflow */
384 ppc64_elf_branch_reloc, /* special_function */
385 "R_PPC64_ADDR14", /* name */
386 FALSE, /* partial_inplace */
388 0x0000fffc, /* dst_mask */
389 FALSE), /* pcrel_offset */
391 /* An absolute 16 bit branch, for which bit 10 should be set to
392 indicate that the branch is expected to be taken. The lower two
393 bits must be zero. */
394 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
398 FALSE, /* pc_relative */
400 complain_overflow_signed, /* complain_on_overflow */
401 ppc64_elf_brtaken_reloc, /* special_function */
402 "R_PPC64_ADDR14_BRTAKEN",/* name */
403 FALSE, /* partial_inplace */
405 0x0000fffc, /* dst_mask */
406 FALSE), /* pcrel_offset */
408 /* An absolute 16 bit branch, for which bit 10 should be set to
409 indicate that the branch is not expected to be taken. The lower
410 two bits must be zero. */
411 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
413 2, /* size (0 = byte, 1 = short, 2 = long) */
415 FALSE, /* pc_relative */
417 complain_overflow_signed, /* complain_on_overflow */
418 ppc64_elf_brtaken_reloc, /* special_function */
419 "R_PPC64_ADDR14_BRNTAKEN",/* name */
420 FALSE, /* partial_inplace */
422 0x0000fffc, /* dst_mask */
423 FALSE), /* pcrel_offset */
425 /* A relative 26 bit branch; the lower two bits must be zero. */
426 HOWTO (R_PPC64_REL24, /* type */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
430 TRUE, /* pc_relative */
432 complain_overflow_signed, /* complain_on_overflow */
433 ppc64_elf_branch_reloc, /* special_function */
434 "R_PPC64_REL24", /* name */
435 FALSE, /* partial_inplace */
437 0x03fffffc, /* dst_mask */
438 TRUE), /* pcrel_offset */
440 /* A relative 16 bit branch; the lower two bits must be zero. */
441 HOWTO (R_PPC64_REL14, /* type */
443 2, /* size (0 = byte, 1 = short, 2 = long) */
445 TRUE, /* pc_relative */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_branch_reloc, /* special_function */
449 "R_PPC64_REL14", /* name */
450 FALSE, /* partial_inplace */
452 0x0000fffc, /* dst_mask */
453 TRUE), /* pcrel_offset */
455 /* A relative 16 bit branch. Bit 10 should be set to indicate that
456 the branch is expected to be taken. The lower two bits must be
458 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
462 TRUE, /* pc_relative */
464 complain_overflow_signed, /* complain_on_overflow */
465 ppc64_elf_brtaken_reloc, /* special_function */
466 "R_PPC64_REL14_BRTAKEN", /* name */
467 FALSE, /* partial_inplace */
469 0x0000fffc, /* dst_mask */
470 TRUE), /* pcrel_offset */
472 /* A relative 16 bit branch. Bit 10 should be set to indicate that
473 the branch is not expected to be taken. The lower two bits must
475 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
477 2, /* size (0 = byte, 1 = short, 2 = long) */
479 TRUE, /* pc_relative */
481 complain_overflow_signed, /* complain_on_overflow */
482 ppc64_elf_brtaken_reloc, /* special_function */
483 "R_PPC64_REL14_BRNTAKEN",/* name */
484 FALSE, /* partial_inplace */
486 0x0000fffc, /* dst_mask */
487 TRUE), /* pcrel_offset */
489 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
491 HOWTO (R_PPC64_GOT16, /* type */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
495 FALSE, /* pc_relative */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_unhandled_reloc, /* special_function */
499 "R_PPC64_GOT16", /* name */
500 FALSE, /* partial_inplace */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
505 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
507 HOWTO (R_PPC64_GOT16_LO, /* type */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
511 FALSE, /* pc_relative */
513 complain_overflow_dont, /* complain_on_overflow */
514 ppc64_elf_unhandled_reloc, /* special_function */
515 "R_PPC64_GOT16_LO", /* name */
516 FALSE, /* partial_inplace */
518 0xffff, /* dst_mask */
519 FALSE), /* pcrel_offset */
521 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
523 HOWTO (R_PPC64_GOT16_HI, /* type */
525 1, /* size (0 = byte, 1 = short, 2 = long) */
527 FALSE, /* pc_relative */
529 complain_overflow_signed,/* complain_on_overflow */
530 ppc64_elf_unhandled_reloc, /* special_function */
531 "R_PPC64_GOT16_HI", /* name */
532 FALSE, /* partial_inplace */
534 0xffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
537 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
539 HOWTO (R_PPC64_GOT16_HA, /* type */
541 1, /* size (0 = byte, 1 = short, 2 = long) */
543 FALSE, /* pc_relative */
545 complain_overflow_signed,/* complain_on_overflow */
546 ppc64_elf_unhandled_reloc, /* special_function */
547 "R_PPC64_GOT16_HA", /* name */
548 FALSE, /* partial_inplace */
550 0xffff, /* dst_mask */
551 FALSE), /* pcrel_offset */
553 /* This is used only by the dynamic linker. The symbol should exist
554 both in the object being run and in some shared library. The
555 dynamic linker copies the data addressed by the symbol from the
556 shared library into the object, because the object being
557 run has to have the data at some particular address. */
558 HOWTO (R_PPC64_COPY, /* type */
560 0, /* this one is variable size */
562 FALSE, /* pc_relative */
564 complain_overflow_dont, /* complain_on_overflow */
565 ppc64_elf_unhandled_reloc, /* special_function */
566 "R_PPC64_COPY", /* name */
567 FALSE, /* partial_inplace */
570 FALSE), /* pcrel_offset */
572 /* Like R_PPC64_ADDR64, but used when setting global offset table
574 HOWTO (R_PPC64_GLOB_DAT, /* type */
576 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
578 FALSE, /* pc_relative */
580 complain_overflow_dont, /* complain_on_overflow */
581 ppc64_elf_unhandled_reloc, /* special_function */
582 "R_PPC64_GLOB_DAT", /* name */
583 FALSE, /* partial_inplace */
585 ONES (64), /* dst_mask */
586 FALSE), /* pcrel_offset */
588 /* Created by the link editor. Marks a procedure linkage table
589 entry for a symbol. */
590 HOWTO (R_PPC64_JMP_SLOT, /* type */
592 0, /* size (0 = byte, 1 = short, 2 = long) */
594 FALSE, /* pc_relative */
596 complain_overflow_dont, /* complain_on_overflow */
597 ppc64_elf_unhandled_reloc, /* special_function */
598 "R_PPC64_JMP_SLOT", /* name */
599 FALSE, /* partial_inplace */
602 FALSE), /* pcrel_offset */
604 /* Used only by the dynamic linker. When the object is run, this
605 doubleword64 is set to the load address of the object, plus the
607 HOWTO (R_PPC64_RELATIVE, /* 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 bfd_elf_generic_reloc, /* special_function */
615 "R_PPC64_RELATIVE", /* name */
616 FALSE, /* partial_inplace */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
621 /* Like R_PPC64_ADDR32, but may be unaligned. */
622 HOWTO (R_PPC64_UADDR32, /* type */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
626 FALSE, /* pc_relative */
628 complain_overflow_bitfield, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_PPC64_UADDR32", /* name */
631 FALSE, /* partial_inplace */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
636 /* Like R_PPC64_ADDR16, but may be unaligned. */
637 HOWTO (R_PPC64_UADDR16, /* type */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
641 FALSE, /* pc_relative */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_PPC64_UADDR16", /* name */
646 FALSE, /* partial_inplace */
648 0xffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
651 /* 32-bit PC relative. */
652 HOWTO (R_PPC64_REL32, /* type */
654 2, /* size (0 = byte, 1 = short, 2 = long) */
656 TRUE, /* pc_relative */
658 complain_overflow_signed, /* complain_on_overflow */
659 bfd_elf_generic_reloc, /* special_function */
660 "R_PPC64_REL32", /* name */
661 FALSE, /* partial_inplace */
663 0xffffffff, /* dst_mask */
664 TRUE), /* pcrel_offset */
666 /* 32-bit relocation to the symbol's procedure linkage table. */
667 HOWTO (R_PPC64_PLT32, /* type */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
671 FALSE, /* pc_relative */
673 complain_overflow_bitfield, /* complain_on_overflow */
674 ppc64_elf_unhandled_reloc, /* special_function */
675 "R_PPC64_PLT32", /* name */
676 FALSE, /* partial_inplace */
678 0xffffffff, /* dst_mask */
679 FALSE), /* pcrel_offset */
681 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
682 FIXME: R_PPC64_PLTREL32 not supported. */
683 HOWTO (R_PPC64_PLTREL32, /* type */
685 2, /* size (0 = byte, 1 = short, 2 = long) */
687 TRUE, /* pc_relative */
689 complain_overflow_signed, /* complain_on_overflow */
690 bfd_elf_generic_reloc, /* special_function */
691 "R_PPC64_PLTREL32", /* name */
692 FALSE, /* partial_inplace */
694 0xffffffff, /* dst_mask */
695 TRUE), /* pcrel_offset */
697 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
699 HOWTO (R_PPC64_PLT16_LO, /* type */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
703 FALSE, /* pc_relative */
705 complain_overflow_dont, /* complain_on_overflow */
706 ppc64_elf_unhandled_reloc, /* special_function */
707 "R_PPC64_PLT16_LO", /* name */
708 FALSE, /* partial_inplace */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
713 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
715 HOWTO (R_PPC64_PLT16_HI, /* type */
717 1, /* size (0 = byte, 1 = short, 2 = long) */
719 FALSE, /* pc_relative */
721 complain_overflow_signed, /* complain_on_overflow */
722 ppc64_elf_unhandled_reloc, /* special_function */
723 "R_PPC64_PLT16_HI", /* name */
724 FALSE, /* partial_inplace */
726 0xffff, /* dst_mask */
727 FALSE), /* pcrel_offset */
729 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
731 HOWTO (R_PPC64_PLT16_HA, /* type */
733 1, /* size (0 = byte, 1 = short, 2 = long) */
735 FALSE, /* pc_relative */
737 complain_overflow_signed, /* complain_on_overflow */
738 ppc64_elf_unhandled_reloc, /* special_function */
739 "R_PPC64_PLT16_HA", /* name */
740 FALSE, /* partial_inplace */
742 0xffff, /* dst_mask */
743 FALSE), /* pcrel_offset */
745 /* 16-bit section relative relocation. */
746 HOWTO (R_PPC64_SECTOFF, /* type */
748 1, /* size (0 = byte, 1 = short, 2 = long) */
750 FALSE, /* pc_relative */
752 complain_overflow_signed, /* complain_on_overflow */
753 ppc64_elf_sectoff_reloc, /* special_function */
754 "R_PPC64_SECTOFF", /* name */
755 FALSE, /* partial_inplace */
757 0xffff, /* dst_mask */
758 FALSE), /* pcrel_offset */
760 /* Like R_PPC64_SECTOFF, but no overflow warning. */
761 HOWTO (R_PPC64_SECTOFF_LO, /* type */
763 1, /* size (0 = byte, 1 = short, 2 = long) */
765 FALSE, /* pc_relative */
767 complain_overflow_dont, /* complain_on_overflow */
768 ppc64_elf_sectoff_reloc, /* special_function */
769 "R_PPC64_SECTOFF_LO", /* name */
770 FALSE, /* partial_inplace */
772 0xffff, /* dst_mask */
773 FALSE), /* pcrel_offset */
775 /* 16-bit upper half section relative relocation. */
776 HOWTO (R_PPC64_SECTOFF_HI, /* type */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
780 FALSE, /* pc_relative */
782 complain_overflow_signed, /* complain_on_overflow */
783 ppc64_elf_sectoff_reloc, /* special_function */
784 "R_PPC64_SECTOFF_HI", /* name */
785 FALSE, /* partial_inplace */
787 0xffff, /* dst_mask */
788 FALSE), /* pcrel_offset */
790 /* 16-bit upper half adjusted section relative relocation. */
791 HOWTO (R_PPC64_SECTOFF_HA, /* type */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
795 FALSE, /* pc_relative */
797 complain_overflow_signed, /* complain_on_overflow */
798 ppc64_elf_sectoff_ha_reloc, /* special_function */
799 "R_PPC64_SECTOFF_HA", /* name */
800 FALSE, /* partial_inplace */
802 0xffff, /* dst_mask */
803 FALSE), /* pcrel_offset */
805 /* Like R_PPC64_REL24 without touching the two least significant bits. */
806 HOWTO (R_PPC64_REL30, /* type */
808 2, /* size (0 = byte, 1 = short, 2 = long) */
810 TRUE, /* pc_relative */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_PPC64_REL30", /* name */
815 FALSE, /* partial_inplace */
817 0xfffffffc, /* dst_mask */
818 TRUE), /* pcrel_offset */
820 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
822 /* A standard 64-bit relocation. */
823 HOWTO (R_PPC64_ADDR64, /* type */
825 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
827 FALSE, /* pc_relative */
829 complain_overflow_dont, /* complain_on_overflow */
830 bfd_elf_generic_reloc, /* special_function */
831 "R_PPC64_ADDR64", /* name */
832 FALSE, /* partial_inplace */
834 ONES (64), /* dst_mask */
835 FALSE), /* pcrel_offset */
837 /* The bits 32-47 of an address. */
838 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
842 FALSE, /* pc_relative */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_ADDR16_HIGHER", /* name */
847 FALSE, /* partial_inplace */
849 0xffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
852 /* The bits 32-47 of an address, plus 1 if the contents of the low
853 16 bits, treated as a signed number, is negative. */
854 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
858 FALSE, /* pc_relative */
860 complain_overflow_dont, /* complain_on_overflow */
861 ppc64_elf_ha_reloc, /* special_function */
862 "R_PPC64_ADDR16_HIGHERA", /* name */
863 FALSE, /* partial_inplace */
865 0xffff, /* dst_mask */
866 FALSE), /* pcrel_offset */
868 /* The bits 48-63 of an address. */
869 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
873 FALSE, /* pc_relative */
875 complain_overflow_dont, /* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_PPC64_ADDR16_HIGHEST", /* name */
878 FALSE, /* partial_inplace */
880 0xffff, /* dst_mask */
881 FALSE), /* pcrel_offset */
883 /* The bits 48-63 of an address, plus 1 if the contents of the low
884 16 bits, treated as a signed number, is negative. */
885 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
889 FALSE, /* pc_relative */
891 complain_overflow_dont, /* complain_on_overflow */
892 ppc64_elf_ha_reloc, /* special_function */
893 "R_PPC64_ADDR16_HIGHESTA", /* name */
894 FALSE, /* partial_inplace */
896 0xffff, /* dst_mask */
897 FALSE), /* pcrel_offset */
899 /* Like ADDR64, but may be unaligned. */
900 HOWTO (R_PPC64_UADDR64, /* type */
902 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
904 FALSE, /* pc_relative */
906 complain_overflow_dont, /* complain_on_overflow */
907 bfd_elf_generic_reloc, /* special_function */
908 "R_PPC64_UADDR64", /* name */
909 FALSE, /* partial_inplace */
911 ONES (64), /* dst_mask */
912 FALSE), /* pcrel_offset */
914 /* 64-bit relative relocation. */
915 HOWTO (R_PPC64_REL64, /* type */
917 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
919 TRUE, /* pc_relative */
921 complain_overflow_dont, /* complain_on_overflow */
922 bfd_elf_generic_reloc, /* special_function */
923 "R_PPC64_REL64", /* name */
924 FALSE, /* partial_inplace */
926 ONES (64), /* dst_mask */
927 TRUE), /* pcrel_offset */
929 /* 64-bit relocation to the symbol's procedure linkage table. */
930 HOWTO (R_PPC64_PLT64, /* type */
932 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
934 FALSE, /* pc_relative */
936 complain_overflow_dont, /* complain_on_overflow */
937 ppc64_elf_unhandled_reloc, /* special_function */
938 "R_PPC64_PLT64", /* name */
939 FALSE, /* partial_inplace */
941 ONES (64), /* dst_mask */
942 FALSE), /* pcrel_offset */
944 /* 64-bit PC relative relocation to the symbol's procedure linkage
946 /* FIXME: R_PPC64_PLTREL64 not supported. */
947 HOWTO (R_PPC64_PLTREL64, /* type */
949 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
951 TRUE, /* pc_relative */
953 complain_overflow_dont, /* complain_on_overflow */
954 ppc64_elf_unhandled_reloc, /* special_function */
955 "R_PPC64_PLTREL64", /* name */
956 FALSE, /* partial_inplace */
958 ONES (64), /* dst_mask */
959 TRUE), /* pcrel_offset */
961 /* 16 bit TOC-relative relocation. */
963 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
964 HOWTO (R_PPC64_TOC16, /* type */
966 1, /* size (0 = byte, 1 = short, 2 = long) */
968 FALSE, /* pc_relative */
970 complain_overflow_signed, /* complain_on_overflow */
971 ppc64_elf_toc_reloc, /* special_function */
972 "R_PPC64_TOC16", /* name */
973 FALSE, /* partial_inplace */
975 0xffff, /* dst_mask */
976 FALSE), /* pcrel_offset */
978 /* 16 bit TOC-relative relocation without overflow. */
980 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
981 HOWTO (R_PPC64_TOC16_LO, /* type */
983 1, /* size (0 = byte, 1 = short, 2 = long) */
985 FALSE, /* pc_relative */
987 complain_overflow_dont, /* complain_on_overflow */
988 ppc64_elf_toc_reloc, /* special_function */
989 "R_PPC64_TOC16_LO", /* name */
990 FALSE, /* partial_inplace */
992 0xffff, /* dst_mask */
993 FALSE), /* pcrel_offset */
995 /* 16 bit TOC-relative relocation, high 16 bits. */
997 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
998 HOWTO (R_PPC64_TOC16_HI, /* type */
1000 1, /* size (0 = byte, 1 = short, 2 = long) */
1002 FALSE, /* pc_relative */
1004 complain_overflow_signed, /* complain_on_overflow */
1005 ppc64_elf_toc_reloc, /* special_function */
1006 "R_PPC64_TOC16_HI", /* name */
1007 FALSE, /* partial_inplace */
1009 0xffff, /* dst_mask */
1010 FALSE), /* pcrel_offset */
1012 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013 contents of the low 16 bits, treated as a signed number, is
1016 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1017 HOWTO (R_PPC64_TOC16_HA, /* type */
1018 16, /* rightshift */
1019 1, /* size (0 = byte, 1 = short, 2 = long) */
1021 FALSE, /* pc_relative */
1023 complain_overflow_signed, /* complain_on_overflow */
1024 ppc64_elf_toc_ha_reloc, /* special_function */
1025 "R_PPC64_TOC16_HA", /* name */
1026 FALSE, /* partial_inplace */
1028 0xffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1031 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1033 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1034 HOWTO (R_PPC64_TOC, /* type */
1036 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1038 FALSE, /* pc_relative */
1040 complain_overflow_dont, /* complain_on_overflow */
1041 ppc64_elf_toc64_reloc, /* special_function */
1042 "R_PPC64_TOC", /* name */
1043 FALSE, /* partial_inplace */
1045 ONES (64), /* dst_mask */
1046 FALSE), /* pcrel_offset */
1048 /* Like R_PPC64_GOT16, but also informs the link editor that the
1049 value to relocate may (!) refer to a PLT entry which the link
1050 editor (a) may replace with the symbol value. If the link editor
1051 is unable to fully resolve the symbol, it may (b) create a PLT
1052 entry and store the address to the new PLT entry in the GOT.
1053 This permits lazy resolution of function symbols at run time.
1054 The link editor may also skip all of this and just (c) emit a
1055 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1056 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16, /* type */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1061 FALSE, /* pc_relative */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16", /* name */
1066 FALSE, /* partial_inplace */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1071 /* Like R_PPC64_PLTGOT16, but without overflow. */
1072 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1073 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1077 FALSE, /* pc_relative */
1079 complain_overflow_dont, /* complain_on_overflow */
1080 ppc64_elf_unhandled_reloc, /* special_function */
1081 "R_PPC64_PLTGOT16_LO", /* name */
1082 FALSE, /* partial_inplace */
1084 0xffff, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1087 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1088 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1089 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1090 16, /* rightshift */
1091 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 FALSE, /* pc_relative */
1095 complain_overflow_signed, /* complain_on_overflow */
1096 ppc64_elf_unhandled_reloc, /* special_function */
1097 "R_PPC64_PLTGOT16_HI", /* name */
1098 FALSE, /* partial_inplace */
1100 0xffff, /* dst_mask */
1101 FALSE), /* pcrel_offset */
1103 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104 1 if the contents of the low 16 bits, treated as a signed number,
1106 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1107 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1108 16, /* rightshift */
1109 1, /* size (0 = byte, 1 = short, 2 = long) */
1111 FALSE, /* pc_relative */
1113 complain_overflow_signed, /* complain_on_overflow */
1114 ppc64_elf_unhandled_reloc, /* special_function */
1115 "R_PPC64_PLTGOT16_HA", /* name */
1116 FALSE, /* partial_inplace */
1118 0xffff, /* dst_mask */
1119 FALSE), /* pcrel_offset */
1121 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1122 HOWTO (R_PPC64_ADDR16_DS, /* type */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1126 FALSE, /* pc_relative */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 bfd_elf_generic_reloc, /* special_function */
1130 "R_PPC64_ADDR16_DS", /* name */
1131 FALSE, /* partial_inplace */
1133 0xfffc, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1136 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1137 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1139 1, /* size (0 = byte, 1 = short, 2 = long) */
1141 FALSE, /* pc_relative */
1143 complain_overflow_dont,/* complain_on_overflow */
1144 bfd_elf_generic_reloc, /* special_function */
1145 "R_PPC64_ADDR16_LO_DS",/* name */
1146 FALSE, /* partial_inplace */
1148 0xfffc, /* dst_mask */
1149 FALSE), /* pcrel_offset */
1151 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1152 HOWTO (R_PPC64_GOT16_DS, /* type */
1154 1, /* size (0 = byte, 1 = short, 2 = long) */
1156 FALSE, /* pc_relative */
1158 complain_overflow_signed, /* complain_on_overflow */
1159 ppc64_elf_unhandled_reloc, /* special_function */
1160 "R_PPC64_GOT16_DS", /* name */
1161 FALSE, /* partial_inplace */
1163 0xfffc, /* dst_mask */
1164 FALSE), /* pcrel_offset */
1166 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1167 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1169 1, /* size (0 = byte, 1 = short, 2 = long) */
1171 FALSE, /* pc_relative */
1173 complain_overflow_dont, /* complain_on_overflow */
1174 ppc64_elf_unhandled_reloc, /* special_function */
1175 "R_PPC64_GOT16_LO_DS", /* name */
1176 FALSE, /* partial_inplace */
1178 0xfffc, /* dst_mask */
1179 FALSE), /* pcrel_offset */
1181 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1182 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1184 1, /* size (0 = byte, 1 = short, 2 = long) */
1186 FALSE, /* pc_relative */
1188 complain_overflow_dont, /* complain_on_overflow */
1189 ppc64_elf_unhandled_reloc, /* special_function */
1190 "R_PPC64_PLT16_LO_DS", /* name */
1191 FALSE, /* partial_inplace */
1193 0xfffc, /* dst_mask */
1194 FALSE), /* pcrel_offset */
1196 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1197 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1199 1, /* size (0 = byte, 1 = short, 2 = long) */
1201 FALSE, /* pc_relative */
1203 complain_overflow_signed, /* complain_on_overflow */
1204 ppc64_elf_sectoff_reloc, /* special_function */
1205 "R_PPC64_SECTOFF_DS", /* name */
1206 FALSE, /* partial_inplace */
1208 0xfffc, /* dst_mask */
1209 FALSE), /* pcrel_offset */
1211 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1212 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1216 FALSE, /* pc_relative */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_sectoff_reloc, /* special_function */
1220 "R_PPC64_SECTOFF_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1226 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1227 HOWTO (R_PPC64_TOC16_DS, /* type */
1229 1, /* size (0 = byte, 1 = short, 2 = long) */
1231 FALSE, /* pc_relative */
1233 complain_overflow_signed, /* complain_on_overflow */
1234 ppc64_elf_toc_reloc, /* special_function */
1235 "R_PPC64_TOC16_DS", /* name */
1236 FALSE, /* partial_inplace */
1238 0xfffc, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1241 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1242 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1244 1, /* size (0 = byte, 1 = short, 2 = long) */
1246 FALSE, /* pc_relative */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 ppc64_elf_toc_reloc, /* special_function */
1250 "R_PPC64_TOC16_LO_DS", /* name */
1251 FALSE, /* partial_inplace */
1253 0xfffc, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1256 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1257 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1258 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1260 1, /* size (0 = byte, 1 = short, 2 = long) */
1262 FALSE, /* pc_relative */
1264 complain_overflow_signed, /* complain_on_overflow */
1265 ppc64_elf_unhandled_reloc, /* special_function */
1266 "R_PPC64_PLTGOT16_DS", /* name */
1267 FALSE, /* partial_inplace */
1269 0xfffc, /* dst_mask */
1270 FALSE), /* pcrel_offset */
1272 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1273 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1274 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1276 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 FALSE, /* pc_relative */
1280 complain_overflow_dont, /* complain_on_overflow */
1281 ppc64_elf_unhandled_reloc, /* special_function */
1282 "R_PPC64_PLTGOT16_LO_DS",/* name */
1283 FALSE, /* partial_inplace */
1285 0xfffc, /* dst_mask */
1286 FALSE), /* pcrel_offset */
1288 /* Marker relocs for TLS. */
1291 2, /* size (0 = byte, 1 = short, 2 = long) */
1293 FALSE, /* pc_relative */
1295 complain_overflow_dont, /* complain_on_overflow */
1296 bfd_elf_generic_reloc, /* special_function */
1297 "R_PPC64_TLS", /* name */
1298 FALSE, /* partial_inplace */
1301 FALSE), /* pcrel_offset */
1303 HOWTO (R_PPC64_TLSGD,
1305 2, /* size (0 = byte, 1 = short, 2 = long) */
1307 FALSE, /* pc_relative */
1309 complain_overflow_dont, /* complain_on_overflow */
1310 bfd_elf_generic_reloc, /* special_function */
1311 "R_PPC64_TLSGD", /* name */
1312 FALSE, /* partial_inplace */
1315 FALSE), /* pcrel_offset */
1317 HOWTO (R_PPC64_TLSLD,
1319 2, /* size (0 = byte, 1 = short, 2 = long) */
1321 FALSE, /* pc_relative */
1323 complain_overflow_dont, /* complain_on_overflow */
1324 bfd_elf_generic_reloc, /* special_function */
1325 "R_PPC64_TLSLD", /* name */
1326 FALSE, /* partial_inplace */
1329 FALSE), /* pcrel_offset */
1331 HOWTO (R_PPC64_TOCSAVE,
1333 2, /* size (0 = byte, 1 = short, 2 = long) */
1335 FALSE, /* pc_relative */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 bfd_elf_generic_reloc, /* special_function */
1339 "R_PPC64_TOCSAVE", /* name */
1340 FALSE, /* partial_inplace */
1343 FALSE), /* pcrel_offset */
1345 /* Computes the load module index of the load module that contains the
1346 definition of its TLS sym. */
1347 HOWTO (R_PPC64_DTPMOD64,
1349 4, /* size (0 = byte, 1 = short, 2 = long) */
1351 FALSE, /* pc_relative */
1353 complain_overflow_dont, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPMOD64", /* name */
1356 FALSE, /* partial_inplace */
1358 ONES (64), /* dst_mask */
1359 FALSE), /* pcrel_offset */
1361 /* Computes a dtv-relative displacement, the difference between the value
1362 of sym+add and the base address of the thread-local storage block that
1363 contains the definition of sym, minus 0x8000. */
1364 HOWTO (R_PPC64_DTPREL64,
1366 4, /* size (0 = byte, 1 = short, 2 = long) */
1368 FALSE, /* pc_relative */
1370 complain_overflow_dont, /* complain_on_overflow */
1371 ppc64_elf_unhandled_reloc, /* special_function */
1372 "R_PPC64_DTPREL64", /* name */
1373 FALSE, /* partial_inplace */
1375 ONES (64), /* dst_mask */
1376 FALSE), /* pcrel_offset */
1378 /* A 16 bit dtprel reloc. */
1379 HOWTO (R_PPC64_DTPREL16,
1381 1, /* size (0 = byte, 1 = short, 2 = long) */
1383 FALSE, /* pc_relative */
1385 complain_overflow_signed, /* complain_on_overflow */
1386 ppc64_elf_unhandled_reloc, /* special_function */
1387 "R_PPC64_DTPREL16", /* name */
1388 FALSE, /* partial_inplace */
1390 0xffff, /* dst_mask */
1391 FALSE), /* pcrel_offset */
1393 /* Like DTPREL16, but no overflow. */
1394 HOWTO (R_PPC64_DTPREL16_LO,
1396 1, /* size (0 = byte, 1 = short, 2 = long) */
1398 FALSE, /* pc_relative */
1400 complain_overflow_dont, /* complain_on_overflow */
1401 ppc64_elf_unhandled_reloc, /* special_function */
1402 "R_PPC64_DTPREL16_LO", /* name */
1403 FALSE, /* partial_inplace */
1405 0xffff, /* dst_mask */
1406 FALSE), /* pcrel_offset */
1408 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1409 HOWTO (R_PPC64_DTPREL16_HI,
1410 16, /* rightshift */
1411 1, /* size (0 = byte, 1 = short, 2 = long) */
1413 FALSE, /* pc_relative */
1415 complain_overflow_signed, /* complain_on_overflow */
1416 ppc64_elf_unhandled_reloc, /* special_function */
1417 "R_PPC64_DTPREL16_HI", /* name */
1418 FALSE, /* partial_inplace */
1420 0xffff, /* dst_mask */
1421 FALSE), /* pcrel_offset */
1423 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1424 HOWTO (R_PPC64_DTPREL16_HA,
1425 16, /* rightshift */
1426 1, /* size (0 = byte, 1 = short, 2 = long) */
1428 FALSE, /* pc_relative */
1430 complain_overflow_signed, /* complain_on_overflow */
1431 ppc64_elf_unhandled_reloc, /* special_function */
1432 "R_PPC64_DTPREL16_HA", /* name */
1433 FALSE, /* partial_inplace */
1435 0xffff, /* dst_mask */
1436 FALSE), /* pcrel_offset */
1438 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1439 HOWTO (R_PPC64_DTPREL16_HIGHER,
1440 32, /* rightshift */
1441 1, /* size (0 = byte, 1 = short, 2 = long) */
1443 FALSE, /* pc_relative */
1445 complain_overflow_dont, /* complain_on_overflow */
1446 ppc64_elf_unhandled_reloc, /* special_function */
1447 "R_PPC64_DTPREL16_HIGHER", /* name */
1448 FALSE, /* partial_inplace */
1450 0xffff, /* dst_mask */
1451 FALSE), /* pcrel_offset */
1453 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1454 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455 32, /* rightshift */
1456 1, /* size (0 = byte, 1 = short, 2 = long) */
1458 FALSE, /* pc_relative */
1460 complain_overflow_dont, /* complain_on_overflow */
1461 ppc64_elf_unhandled_reloc, /* special_function */
1462 "R_PPC64_DTPREL16_HIGHERA", /* name */
1463 FALSE, /* partial_inplace */
1465 0xffff, /* dst_mask */
1466 FALSE), /* pcrel_offset */
1468 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1469 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470 48, /* rightshift */
1471 1, /* size (0 = byte, 1 = short, 2 = long) */
1473 FALSE, /* pc_relative */
1475 complain_overflow_dont, /* complain_on_overflow */
1476 ppc64_elf_unhandled_reloc, /* special_function */
1477 "R_PPC64_DTPREL16_HIGHEST", /* name */
1478 FALSE, /* partial_inplace */
1480 0xffff, /* dst_mask */
1481 FALSE), /* pcrel_offset */
1483 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1484 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485 48, /* rightshift */
1486 1, /* size (0 = byte, 1 = short, 2 = long) */
1488 FALSE, /* pc_relative */
1490 complain_overflow_dont, /* complain_on_overflow */
1491 ppc64_elf_unhandled_reloc, /* special_function */
1492 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493 FALSE, /* partial_inplace */
1495 0xffff, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1498 /* Like DTPREL16, but for insns with a DS field. */
1499 HOWTO (R_PPC64_DTPREL16_DS,
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1503 FALSE, /* pc_relative */
1505 complain_overflow_signed, /* complain_on_overflow */
1506 ppc64_elf_unhandled_reloc, /* special_function */
1507 "R_PPC64_DTPREL16_DS", /* name */
1508 FALSE, /* partial_inplace */
1510 0xfffc, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1513 /* Like DTPREL16_DS, but no overflow. */
1514 HOWTO (R_PPC64_DTPREL16_LO_DS,
1516 1, /* size (0 = byte, 1 = short, 2 = long) */
1518 FALSE, /* pc_relative */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 ppc64_elf_unhandled_reloc, /* special_function */
1522 "R_PPC64_DTPREL16_LO_DS", /* name */
1523 FALSE, /* partial_inplace */
1525 0xfffc, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1528 /* Computes a tp-relative displacement, the difference between the value of
1529 sym+add and the value of the thread pointer (r13). */
1530 HOWTO (R_PPC64_TPREL64,
1532 4, /* size (0 = byte, 1 = short, 2 = long) */
1534 FALSE, /* pc_relative */
1536 complain_overflow_dont, /* complain_on_overflow */
1537 ppc64_elf_unhandled_reloc, /* special_function */
1538 "R_PPC64_TPREL64", /* name */
1539 FALSE, /* partial_inplace */
1541 ONES (64), /* dst_mask */
1542 FALSE), /* pcrel_offset */
1544 /* A 16 bit tprel reloc. */
1545 HOWTO (R_PPC64_TPREL16,
1547 1, /* size (0 = byte, 1 = short, 2 = long) */
1549 FALSE, /* pc_relative */
1551 complain_overflow_signed, /* complain_on_overflow */
1552 ppc64_elf_unhandled_reloc, /* special_function */
1553 "R_PPC64_TPREL16", /* name */
1554 FALSE, /* partial_inplace */
1556 0xffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1559 /* Like TPREL16, but no overflow. */
1560 HOWTO (R_PPC64_TPREL16_LO,
1562 1, /* size (0 = byte, 1 = short, 2 = long) */
1564 FALSE, /* pc_relative */
1566 complain_overflow_dont, /* complain_on_overflow */
1567 ppc64_elf_unhandled_reloc, /* special_function */
1568 "R_PPC64_TPREL16_LO", /* name */
1569 FALSE, /* partial_inplace */
1571 0xffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1574 /* Like TPREL16_LO, but next higher group of 16 bits. */
1575 HOWTO (R_PPC64_TPREL16_HI,
1576 16, /* rightshift */
1577 1, /* size (0 = byte, 1 = short, 2 = long) */
1579 FALSE, /* pc_relative */
1581 complain_overflow_signed, /* complain_on_overflow */
1582 ppc64_elf_unhandled_reloc, /* special_function */
1583 "R_PPC64_TPREL16_HI", /* name */
1584 FALSE, /* partial_inplace */
1586 0xffff, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1589 /* Like TPREL16_HI, but adjust for low 16 bits. */
1590 HOWTO (R_PPC64_TPREL16_HA,
1591 16, /* rightshift */
1592 1, /* size (0 = byte, 1 = short, 2 = long) */
1594 FALSE, /* pc_relative */
1596 complain_overflow_signed, /* complain_on_overflow */
1597 ppc64_elf_unhandled_reloc, /* special_function */
1598 "R_PPC64_TPREL16_HA", /* name */
1599 FALSE, /* partial_inplace */
1601 0xffff, /* dst_mask */
1602 FALSE), /* pcrel_offset */
1604 /* Like TPREL16_HI, but next higher group of 16 bits. */
1605 HOWTO (R_PPC64_TPREL16_HIGHER,
1606 32, /* rightshift */
1607 1, /* size (0 = byte, 1 = short, 2 = long) */
1609 FALSE, /* pc_relative */
1611 complain_overflow_dont, /* complain_on_overflow */
1612 ppc64_elf_unhandled_reloc, /* special_function */
1613 "R_PPC64_TPREL16_HIGHER", /* name */
1614 FALSE, /* partial_inplace */
1616 0xffff, /* dst_mask */
1617 FALSE), /* pcrel_offset */
1619 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1620 HOWTO (R_PPC64_TPREL16_HIGHERA,
1621 32, /* rightshift */
1622 1, /* size (0 = byte, 1 = short, 2 = long) */
1624 FALSE, /* pc_relative */
1626 complain_overflow_dont, /* complain_on_overflow */
1627 ppc64_elf_unhandled_reloc, /* special_function */
1628 "R_PPC64_TPREL16_HIGHERA", /* name */
1629 FALSE, /* partial_inplace */
1631 0xffff, /* dst_mask */
1632 FALSE), /* pcrel_offset */
1634 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1635 HOWTO (R_PPC64_TPREL16_HIGHEST,
1636 48, /* rightshift */
1637 1, /* size (0 = byte, 1 = short, 2 = long) */
1639 FALSE, /* pc_relative */
1641 complain_overflow_dont, /* complain_on_overflow */
1642 ppc64_elf_unhandled_reloc, /* special_function */
1643 "R_PPC64_TPREL16_HIGHEST", /* name */
1644 FALSE, /* partial_inplace */
1646 0xffff, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1649 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1650 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651 48, /* rightshift */
1652 1, /* size (0 = byte, 1 = short, 2 = long) */
1654 FALSE, /* pc_relative */
1656 complain_overflow_dont, /* complain_on_overflow */
1657 ppc64_elf_unhandled_reloc, /* special_function */
1658 "R_PPC64_TPREL16_HIGHESTA", /* name */
1659 FALSE, /* partial_inplace */
1661 0xffff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1664 /* Like TPREL16, but for insns with a DS field. */
1665 HOWTO (R_PPC64_TPREL16_DS,
1667 1, /* size (0 = byte, 1 = short, 2 = long) */
1669 FALSE, /* pc_relative */
1671 complain_overflow_signed, /* complain_on_overflow */
1672 ppc64_elf_unhandled_reloc, /* special_function */
1673 "R_PPC64_TPREL16_DS", /* name */
1674 FALSE, /* partial_inplace */
1676 0xfffc, /* dst_mask */
1677 FALSE), /* pcrel_offset */
1679 /* Like TPREL16_DS, but no overflow. */
1680 HOWTO (R_PPC64_TPREL16_LO_DS,
1682 1, /* size (0 = byte, 1 = short, 2 = long) */
1684 FALSE, /* pc_relative */
1686 complain_overflow_dont, /* complain_on_overflow */
1687 ppc64_elf_unhandled_reloc, /* special_function */
1688 "R_PPC64_TPREL16_LO_DS", /* name */
1689 FALSE, /* partial_inplace */
1691 0xfffc, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1694 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696 to the first entry relative to the TOC base (r2). */
1697 HOWTO (R_PPC64_GOT_TLSGD16,
1699 1, /* size (0 = byte, 1 = short, 2 = long) */
1701 FALSE, /* pc_relative */
1703 complain_overflow_signed, /* complain_on_overflow */
1704 ppc64_elf_unhandled_reloc, /* special_function */
1705 "R_PPC64_GOT_TLSGD16", /* name */
1706 FALSE, /* partial_inplace */
1708 0xffff, /* dst_mask */
1709 FALSE), /* pcrel_offset */
1711 /* Like GOT_TLSGD16, but no overflow. */
1712 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1716 FALSE, /* pc_relative */
1718 complain_overflow_dont, /* complain_on_overflow */
1719 ppc64_elf_unhandled_reloc, /* special_function */
1720 "R_PPC64_GOT_TLSGD16_LO", /* name */
1721 FALSE, /* partial_inplace */
1723 0xffff, /* dst_mask */
1724 FALSE), /* pcrel_offset */
1726 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1727 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728 16, /* rightshift */
1729 1, /* size (0 = byte, 1 = short, 2 = long) */
1731 FALSE, /* pc_relative */
1733 complain_overflow_signed, /* complain_on_overflow */
1734 ppc64_elf_unhandled_reloc, /* special_function */
1735 "R_PPC64_GOT_TLSGD16_HI", /* name */
1736 FALSE, /* partial_inplace */
1738 0xffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1741 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1742 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743 16, /* rightshift */
1744 1, /* size (0 = byte, 1 = short, 2 = long) */
1746 FALSE, /* pc_relative */
1748 complain_overflow_signed, /* complain_on_overflow */
1749 ppc64_elf_unhandled_reloc, /* special_function */
1750 "R_PPC64_GOT_TLSGD16_HA", /* name */
1751 FALSE, /* partial_inplace */
1753 0xffff, /* dst_mask */
1754 FALSE), /* pcrel_offset */
1756 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757 with values (sym+add)@dtpmod and zero, and computes the offset to the
1758 first entry relative to the TOC base (r2). */
1759 HOWTO (R_PPC64_GOT_TLSLD16,
1761 1, /* size (0 = byte, 1 = short, 2 = long) */
1763 FALSE, /* pc_relative */
1765 complain_overflow_signed, /* complain_on_overflow */
1766 ppc64_elf_unhandled_reloc, /* special_function */
1767 "R_PPC64_GOT_TLSLD16", /* name */
1768 FALSE, /* partial_inplace */
1770 0xffff, /* dst_mask */
1771 FALSE), /* pcrel_offset */
1773 /* Like GOT_TLSLD16, but no overflow. */
1774 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1776 1, /* size (0 = byte, 1 = short, 2 = long) */
1778 FALSE, /* pc_relative */
1780 complain_overflow_dont, /* complain_on_overflow */
1781 ppc64_elf_unhandled_reloc, /* special_function */
1782 "R_PPC64_GOT_TLSLD16_LO", /* name */
1783 FALSE, /* partial_inplace */
1785 0xffff, /* dst_mask */
1786 FALSE), /* pcrel_offset */
1788 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1789 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790 16, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1793 FALSE, /* pc_relative */
1795 complain_overflow_signed, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_TLSLD16_HI", /* name */
1798 FALSE, /* partial_inplace */
1800 0xffff, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1803 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1804 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805 16, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1808 FALSE, /* pc_relative */
1810 complain_overflow_signed, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_TLSLD16_HA", /* name */
1813 FALSE, /* partial_inplace */
1815 0xffff, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1818 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819 the offset to the entry relative to the TOC base (r2). */
1820 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1822 1, /* size (0 = byte, 1 = short, 2 = long) */
1824 FALSE, /* pc_relative */
1826 complain_overflow_signed, /* complain_on_overflow */
1827 ppc64_elf_unhandled_reloc, /* special_function */
1828 "R_PPC64_GOT_DTPREL16_DS", /* name */
1829 FALSE, /* partial_inplace */
1831 0xfffc, /* dst_mask */
1832 FALSE), /* pcrel_offset */
1834 /* Like GOT_DTPREL16_DS, but no overflow. */
1835 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1837 1, /* size (0 = byte, 1 = short, 2 = long) */
1839 FALSE, /* pc_relative */
1841 complain_overflow_dont, /* complain_on_overflow */
1842 ppc64_elf_unhandled_reloc, /* special_function */
1843 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844 FALSE, /* partial_inplace */
1846 0xfffc, /* dst_mask */
1847 FALSE), /* pcrel_offset */
1849 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1850 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851 16, /* rightshift */
1852 1, /* size (0 = byte, 1 = short, 2 = long) */
1854 FALSE, /* pc_relative */
1856 complain_overflow_signed, /* complain_on_overflow */
1857 ppc64_elf_unhandled_reloc, /* special_function */
1858 "R_PPC64_GOT_DTPREL16_HI", /* name */
1859 FALSE, /* partial_inplace */
1861 0xffff, /* dst_mask */
1862 FALSE), /* pcrel_offset */
1864 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1865 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866 16, /* rightshift */
1867 1, /* size (0 = byte, 1 = short, 2 = long) */
1869 FALSE, /* pc_relative */
1871 complain_overflow_signed, /* complain_on_overflow */
1872 ppc64_elf_unhandled_reloc, /* special_function */
1873 "R_PPC64_GOT_DTPREL16_HA", /* name */
1874 FALSE, /* partial_inplace */
1876 0xffff, /* dst_mask */
1877 FALSE), /* pcrel_offset */
1879 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880 offset to the entry relative to the TOC base (r2). */
1881 HOWTO (R_PPC64_GOT_TPREL16_DS,
1883 1, /* size (0 = byte, 1 = short, 2 = long) */
1885 FALSE, /* pc_relative */
1887 complain_overflow_signed, /* complain_on_overflow */
1888 ppc64_elf_unhandled_reloc, /* special_function */
1889 "R_PPC64_GOT_TPREL16_DS", /* name */
1890 FALSE, /* partial_inplace */
1892 0xfffc, /* dst_mask */
1893 FALSE), /* pcrel_offset */
1895 /* Like GOT_TPREL16_DS, but no overflow. */
1896 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1898 1, /* size (0 = byte, 1 = short, 2 = long) */
1900 FALSE, /* pc_relative */
1902 complain_overflow_dont, /* complain_on_overflow */
1903 ppc64_elf_unhandled_reloc, /* special_function */
1904 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905 FALSE, /* partial_inplace */
1907 0xfffc, /* dst_mask */
1908 FALSE), /* pcrel_offset */
1910 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1911 HOWTO (R_PPC64_GOT_TPREL16_HI,
1912 16, /* rightshift */
1913 1, /* size (0 = byte, 1 = short, 2 = long) */
1915 FALSE, /* pc_relative */
1917 complain_overflow_signed, /* complain_on_overflow */
1918 ppc64_elf_unhandled_reloc, /* special_function */
1919 "R_PPC64_GOT_TPREL16_HI", /* name */
1920 FALSE, /* partial_inplace */
1922 0xffff, /* dst_mask */
1923 FALSE), /* pcrel_offset */
1925 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1926 HOWTO (R_PPC64_GOT_TPREL16_HA,
1927 16, /* rightshift */
1928 1, /* size (0 = byte, 1 = short, 2 = long) */
1930 FALSE, /* pc_relative */
1932 complain_overflow_signed, /* complain_on_overflow */
1933 ppc64_elf_unhandled_reloc, /* special_function */
1934 "R_PPC64_GOT_TPREL16_HA", /* name */
1935 FALSE, /* partial_inplace */
1937 0xffff, /* dst_mask */
1938 FALSE), /* pcrel_offset */
1940 HOWTO (R_PPC64_JMP_IREL, /* type */
1942 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1944 FALSE, /* pc_relative */
1946 complain_overflow_dont, /* complain_on_overflow */
1947 ppc64_elf_unhandled_reloc, /* special_function */
1948 "R_PPC64_JMP_IREL", /* name */
1949 FALSE, /* partial_inplace */
1952 FALSE), /* pcrel_offset */
1954 HOWTO (R_PPC64_IRELATIVE, /* type */
1956 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1958 FALSE, /* pc_relative */
1960 complain_overflow_dont, /* complain_on_overflow */
1961 bfd_elf_generic_reloc, /* special_function */
1962 "R_PPC64_IRELATIVE", /* name */
1963 FALSE, /* partial_inplace */
1965 ONES (64), /* dst_mask */
1966 FALSE), /* pcrel_offset */
1968 /* A 16 bit relative relocation. */
1969 HOWTO (R_PPC64_REL16, /* type */
1971 1, /* size (0 = byte, 1 = short, 2 = long) */
1973 TRUE, /* pc_relative */
1975 complain_overflow_signed, /* complain_on_overflow */
1976 bfd_elf_generic_reloc, /* special_function */
1977 "R_PPC64_REL16", /* name */
1978 FALSE, /* partial_inplace */
1980 0xffff, /* dst_mask */
1981 TRUE), /* pcrel_offset */
1983 /* A 16 bit relative relocation without overflow. */
1984 HOWTO (R_PPC64_REL16_LO, /* type */
1986 1, /* size (0 = byte, 1 = short, 2 = long) */
1988 TRUE, /* pc_relative */
1990 complain_overflow_dont,/* complain_on_overflow */
1991 bfd_elf_generic_reloc, /* special_function */
1992 "R_PPC64_REL16_LO", /* name */
1993 FALSE, /* partial_inplace */
1995 0xffff, /* dst_mask */
1996 TRUE), /* pcrel_offset */
1998 /* The high order 16 bits of a relative address. */
1999 HOWTO (R_PPC64_REL16_HI, /* type */
2000 16, /* rightshift */
2001 1, /* size (0 = byte, 1 = short, 2 = long) */
2003 TRUE, /* pc_relative */
2005 complain_overflow_signed, /* complain_on_overflow */
2006 bfd_elf_generic_reloc, /* special_function */
2007 "R_PPC64_REL16_HI", /* name */
2008 FALSE, /* partial_inplace */
2010 0xffff, /* dst_mask */
2011 TRUE), /* pcrel_offset */
2013 /* The high order 16 bits of a relative address, plus 1 if the contents of
2014 the low 16 bits, treated as a signed number, is negative. */
2015 HOWTO (R_PPC64_REL16_HA, /* type */
2016 16, /* rightshift */
2017 1, /* size (0 = byte, 1 = short, 2 = long) */
2019 TRUE, /* pc_relative */
2021 complain_overflow_signed, /* complain_on_overflow */
2022 ppc64_elf_ha_reloc, /* special_function */
2023 "R_PPC64_REL16_HA", /* name */
2024 FALSE, /* partial_inplace */
2026 0xffff, /* dst_mask */
2027 TRUE), /* pcrel_offset */
2029 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2030 HOWTO (R_PPC64_REL16DX_HA, /* type */
2031 16, /* rightshift */
2032 2, /* size (0 = byte, 1 = short, 2 = long) */
2034 TRUE, /* pc_relative */
2036 complain_overflow_signed, /* complain_on_overflow */
2037 ppc64_elf_ha_reloc, /* special_function */
2038 "R_PPC64_REL16DX_HA", /* name */
2039 FALSE, /* partial_inplace */
2041 0x1fffc1, /* dst_mask */
2042 TRUE), /* pcrel_offset */
2044 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2045 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2046 16, /* rightshift */
2047 1, /* size (0 = byte, 1 = short, 2 = long) */
2049 FALSE, /* pc_relative */
2051 complain_overflow_dont, /* complain_on_overflow */
2052 bfd_elf_generic_reloc, /* special_function */
2053 "R_PPC64_ADDR16_HIGH", /* name */
2054 FALSE, /* partial_inplace */
2056 0xffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2059 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2060 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2061 16, /* rightshift */
2062 1, /* size (0 = byte, 1 = short, 2 = long) */
2064 FALSE, /* pc_relative */
2066 complain_overflow_dont, /* complain_on_overflow */
2067 ppc64_elf_ha_reloc, /* special_function */
2068 "R_PPC64_ADDR16_HIGHA", /* name */
2069 FALSE, /* partial_inplace */
2071 0xffff, /* dst_mask */
2072 FALSE), /* pcrel_offset */
2074 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2075 HOWTO (R_PPC64_DTPREL16_HIGH,
2076 16, /* rightshift */
2077 1, /* size (0 = byte, 1 = short, 2 = long) */
2079 FALSE, /* pc_relative */
2081 complain_overflow_dont, /* complain_on_overflow */
2082 ppc64_elf_unhandled_reloc, /* special_function */
2083 "R_PPC64_DTPREL16_HIGH", /* name */
2084 FALSE, /* partial_inplace */
2086 0xffff, /* dst_mask */
2087 FALSE), /* pcrel_offset */
2089 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2090 HOWTO (R_PPC64_DTPREL16_HIGHA,
2091 16, /* rightshift */
2092 1, /* size (0 = byte, 1 = short, 2 = long) */
2094 FALSE, /* pc_relative */
2096 complain_overflow_dont, /* complain_on_overflow */
2097 ppc64_elf_unhandled_reloc, /* special_function */
2098 "R_PPC64_DTPREL16_HIGHA", /* name */
2099 FALSE, /* partial_inplace */
2101 0xffff, /* dst_mask */
2102 FALSE), /* pcrel_offset */
2104 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2105 HOWTO (R_PPC64_TPREL16_HIGH,
2106 16, /* rightshift */
2107 1, /* size (0 = byte, 1 = short, 2 = long) */
2109 FALSE, /* pc_relative */
2111 complain_overflow_dont, /* complain_on_overflow */
2112 ppc64_elf_unhandled_reloc, /* special_function */
2113 "R_PPC64_TPREL16_HIGH", /* name */
2114 FALSE, /* partial_inplace */
2116 0xffff, /* dst_mask */
2117 FALSE), /* pcrel_offset */
2119 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2120 HOWTO (R_PPC64_TPREL16_HIGHA,
2121 16, /* rightshift */
2122 1, /* size (0 = byte, 1 = short, 2 = long) */
2124 FALSE, /* pc_relative */
2126 complain_overflow_dont, /* complain_on_overflow */
2127 ppc64_elf_unhandled_reloc, /* special_function */
2128 "R_PPC64_TPREL16_HIGHA", /* name */
2129 FALSE, /* partial_inplace */
2131 0xffff, /* dst_mask */
2132 FALSE), /* pcrel_offset */
2134 /* Marker reloc on ELFv2 large-model function entry. */
2135 HOWTO (R_PPC64_ENTRY,
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2139 FALSE, /* pc_relative */
2141 complain_overflow_dont, /* complain_on_overflow */
2142 bfd_elf_generic_reloc, /* special_function */
2143 "R_PPC64_ENTRY", /* name */
2144 FALSE, /* partial_inplace */
2147 FALSE), /* pcrel_offset */
2149 /* Like ADDR64, but use local entry point of function. */
2150 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2152 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2154 FALSE, /* pc_relative */
2156 complain_overflow_dont, /* complain_on_overflow */
2157 bfd_elf_generic_reloc, /* special_function */
2158 "R_PPC64_ADDR64_LOCAL", /* name */
2159 FALSE, /* partial_inplace */
2161 ONES (64), /* dst_mask */
2162 FALSE), /* pcrel_offset */
2164 /* GNU extension to record C++ vtable hierarchy. */
2165 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2167 0, /* size (0 = byte, 1 = short, 2 = long) */
2169 FALSE, /* pc_relative */
2171 complain_overflow_dont, /* complain_on_overflow */
2172 NULL, /* special_function */
2173 "R_PPC64_GNU_VTINHERIT", /* name */
2174 FALSE, /* partial_inplace */
2177 FALSE), /* pcrel_offset */
2179 /* GNU extension to record C++ vtable member usage. */
2180 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2182 0, /* size (0 = byte, 1 = short, 2 = long) */
2184 FALSE, /* pc_relative */
2186 complain_overflow_dont, /* complain_on_overflow */
2187 NULL, /* special_function */
2188 "R_PPC64_GNU_VTENTRY", /* name */
2189 FALSE, /* partial_inplace */
2192 FALSE), /* pcrel_offset */
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2200 ppc_howto_init (void)
2202 unsigned int i, type;
2204 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2206 type = ppc64_elf_howto_raw[i].type;
2207 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214 bfd_reloc_code_real_type code)
2216 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219 /* Initialize howto table if needed. */
2227 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2229 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2231 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2233 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2235 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2237 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2239 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2241 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2243 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2245 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2247 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2249 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2251 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2253 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2255 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2257 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2259 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2261 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2263 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2265 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2267 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2269 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2271 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2273 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2275 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2277 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2279 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2281 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2283 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2285 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2287 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2289 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2291 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2293 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2295 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2297 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2299 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2301 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2303 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2305 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2307 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2309 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2311 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2313 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2315 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2317 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2319 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2321 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2323 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2325 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2327 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2329 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2331 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2333 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2335 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2337 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2339 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2341 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2343 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2345 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2347 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2349 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2351 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2353 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2355 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2357 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2359 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2361 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2363 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2365 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2367 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2369 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2371 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2373 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2375 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2379 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2381 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2383 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2385 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2387 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2389 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2391 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2393 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2395 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2397 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2399 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2401 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2403 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2405 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2407 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2409 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2411 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2413 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2415 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2417 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2419 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2421 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2423 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2425 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2427 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2429 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2431 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2433 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2435 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2437 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2439 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2441 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2443 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2445 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2447 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2449 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2451 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2453 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2455 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2457 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2461 return ppc64_elf_howto_table[r];
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2470 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471 if (ppc64_elf_howto_raw[i].name != NULL
2472 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473 return &ppc64_elf_howto_raw[i];
2478 /* Set the howto pointer for a PowerPC ELF reloc. */
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482 Elf_Internal_Rela *dst)
2486 /* Initialize howto table if needed. */
2487 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2490 type = ELF64_R_TYPE (dst->r_info);
2491 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2493 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2495 type = R_PPC64_NONE;
2497 cache_ptr->howto = ppc64_elf_howto_table[type];
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504 void *data, asection *input_section,
2505 bfd *output_bfd, char **error_message)
2507 enum elf_ppc64_reloc_type r_type;
2509 bfd_size_type octets;
2512 /* If this is a relocatable link (output_bfd test tells us), just
2513 call the generic function. Any adjustment will be done at final
2515 if (output_bfd != NULL)
2516 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517 input_section, output_bfd, error_message);
2519 /* Adjust the addend for sign extension of the low 16 bits.
2520 We won't actually be using the low 16 bits, so trashing them
2522 reloc_entry->addend += 0x8000;
2523 r_type = reloc_entry->howto->type;
2524 if (r_type != R_PPC64_REL16DX_HA)
2525 return bfd_reloc_continue;
2528 if (!bfd_is_com_section (symbol->section))
2529 value = symbol->value;
2530 value += (reloc_entry->addend
2531 + symbol->section->output_offset
2532 + symbol->section->output_section->vma);
2533 value -= (reloc_entry->address
2534 + input_section->output_offset
2535 + input_section->output_section->vma);
2536 value = (bfd_signed_vma) value >> 16;
2538 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2541 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543 if (value + 0x8000 > 0xffff)
2544 return bfd_reloc_overflow;
2545 return bfd_reloc_ok;
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550 void *data, asection *input_section,
2551 bfd *output_bfd, char **error_message)
2553 if (output_bfd != NULL)
2554 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555 input_section, output_bfd, error_message);
2557 if (strcmp (symbol->section->name, ".opd") == 0
2558 && (symbol->section->owner->flags & DYNAMIC) == 0)
2560 bfd_vma dest = opd_entry_value (symbol->section,
2561 symbol->value + reloc_entry->addend,
2563 if (dest != (bfd_vma) -1)
2564 reloc_entry->addend = dest - (symbol->value
2565 + symbol->section->output_section->vma
2566 + symbol->section->output_offset);
2570 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2572 if (symbol->section->owner != abfd
2573 && symbol->section->owner != NULL
2574 && abiversion (symbol->section->owner) >= 2)
2578 for (i = 0; i < symbol->section->owner->symcount; ++i)
2580 asymbol *symdef = symbol->section->owner->outsymbols[i];
2582 if (strcmp (symdef->name, symbol->name) == 0)
2584 elfsym = (elf_symbol_type *) symdef;
2590 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2592 return bfd_reloc_continue;
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597 void *data, asection *input_section,
2598 bfd *output_bfd, char **error_message)
2601 enum elf_ppc64_reloc_type r_type;
2602 bfd_size_type octets;
2603 /* Assume 'at' branch hints. */
2604 bfd_boolean is_isa_v2 = TRUE;
2606 /* If this is a relocatable link (output_bfd test tells us), just
2607 call the generic function. Any adjustment will be done at final
2609 if (output_bfd != NULL)
2610 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611 input_section, output_bfd, error_message);
2613 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615 insn &= ~(0x01 << 21);
2616 r_type = reloc_entry->howto->type;
2617 if (r_type == R_PPC64_ADDR14_BRTAKEN
2618 || r_type == R_PPC64_REL14_BRTAKEN)
2619 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2623 /* Set 'a' bit. This is 0b00010 in BO field for branch
2624 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625 for branch on CTR insns (BO == 1a00t or 1a01t). */
2626 if ((insn & (0x14 << 21)) == (0x04 << 21))
2628 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2638 if (!bfd_is_com_section (symbol->section))
2639 target = symbol->value;
2640 target += symbol->section->output_section->vma;
2641 target += symbol->section->output_offset;
2642 target += reloc_entry->addend;
2644 from = (reloc_entry->address
2645 + input_section->output_offset
2646 + input_section->output_section->vma);
2648 /* Invert 'y' bit if not the default. */
2649 if ((bfd_signed_vma) (target - from) < 0)
2652 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2654 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655 input_section, output_bfd, error_message);
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660 void *data, asection *input_section,
2661 bfd *output_bfd, char **error_message)
2663 /* If this is a relocatable link (output_bfd test tells us), just
2664 call the generic function. Any adjustment will be done at final
2666 if (output_bfd != NULL)
2667 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668 input_section, output_bfd, error_message);
2670 /* Subtract the symbol section base address. */
2671 reloc_entry->addend -= symbol->section->output_section->vma;
2672 return bfd_reloc_continue;
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677 void *data, asection *input_section,
2678 bfd *output_bfd, char **error_message)
2680 /* If this is a relocatable link (output_bfd test tells us), just
2681 call the generic function. Any adjustment will be done at final
2683 if (output_bfd != NULL)
2684 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685 input_section, output_bfd, error_message);
2687 /* Subtract the symbol section base address. */
2688 reloc_entry->addend -= symbol->section->output_section->vma;
2690 /* Adjust the addend for sign extension of the low 16 bits. */
2691 reloc_entry->addend += 0x8000;
2692 return bfd_reloc_continue;
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697 void *data, asection *input_section,
2698 bfd *output_bfd, char **error_message)
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2709 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2711 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2713 /* Subtract the TOC base address. */
2714 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715 return bfd_reloc_continue;
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720 void *data, asection *input_section,
2721 bfd *output_bfd, char **error_message)
2725 /* If this is a relocatable link (output_bfd test tells us), just
2726 call the generic function. Any adjustment will be done at final
2728 if (output_bfd != NULL)
2729 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730 input_section, output_bfd, error_message);
2732 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2734 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2736 /* Subtract the TOC base address. */
2737 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2739 /* Adjust the addend for sign extension of the low 16 bits. */
2740 reloc_entry->addend += 0x8000;
2741 return bfd_reloc_continue;
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746 void *data, asection *input_section,
2747 bfd *output_bfd, char **error_message)
2750 bfd_size_type octets;
2752 /* If this is a relocatable link (output_bfd test tells us), just
2753 call the generic function. Any adjustment will be done at final
2755 if (output_bfd != NULL)
2756 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757 input_section, output_bfd, error_message);
2759 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2761 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2763 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765 return bfd_reloc_ok;
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770 void *data, asection *input_section,
2771 bfd *output_bfd, char **error_message)
2773 /* If this is a relocatable link (output_bfd test tells us), just
2774 call the generic function. Any adjustment will be done at final
2776 if (output_bfd != NULL)
2777 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778 input_section, output_bfd, error_message);
2780 if (error_message != NULL)
2782 static char buf[60];
2783 sprintf (buf, "generic linker can't handle %s",
2784 reloc_entry->howto->name);
2785 *error_message = buf;
2787 return bfd_reloc_dangerous;
2790 /* Track GOT entries needed for a given symbol. We might need more
2791 than one got entry per symbol. */
2794 struct got_entry *next;
2796 /* The symbol addend that we'll be placing in the GOT. */
2799 /* Unlike other ELF targets, we use separate GOT entries for the same
2800 symbol referenced from different input files. This is to support
2801 automatic multiple TOC/GOT sections, where the TOC base can vary
2802 from one input file to another. After partitioning into TOC groups
2803 we merge entries within the group.
2805 Point to the BFD owning this GOT entry. */
2808 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809 TLS_TPREL or TLS_DTPREL for tls entries. */
2810 unsigned char tls_type;
2812 /* Non-zero if got.ent points to real entry. */
2813 unsigned char is_indirect;
2815 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2818 bfd_signed_vma refcount;
2820 struct got_entry *ent;
2824 /* The same for PLT. */
2827 struct plt_entry *next;
2833 bfd_signed_vma refcount;
2838 struct ppc64_elf_obj_tdata
2840 struct elf_obj_tdata elf;
2842 /* Shortcuts to dynamic linker sections. */
2846 /* Used during garbage collection. We attach global symbols defined
2847 on removed .opd entries to this section so that the sym is removed. */
2848 asection *deleted_section;
2850 /* TLS local dynamic got entry handling. Support for multiple GOT
2851 sections means we potentially need one of these for each input bfd. */
2852 struct got_entry tlsld_got;
2855 /* A copy of relocs before they are modified for --emit-relocs. */
2856 Elf_Internal_Rela *relocs;
2858 /* Section contents. */
2862 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863 the reloc to be in the range -32768 to 32767. */
2864 unsigned int has_small_toc_reloc : 1;
2866 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867 instruction not one we handle. */
2868 unsigned int unexpected_toc_insn : 1;
2871 #define ppc64_elf_tdata(bfd) \
2872 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2874 #define ppc64_tlsld_got(bfd) \
2875 (&ppc64_elf_tdata (bfd)->tlsld_got)
2877 #define is_ppc64_elf(bfd) \
2878 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879 && elf_object_id (bfd) == PPC64_ELF_DATA)
2881 /* Override the generic function because we store some extras. */
2884 ppc64_elf_mkobject (bfd *abfd)
2886 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891 default is 32 bit. */
2894 ppc64_elf_object_p (bfd *abfd)
2896 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2898 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2900 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2902 /* Relies on arch after 32 bit default being 64 bit default. */
2903 abfd->arch_info = abfd->arch_info->next;
2904 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2910 /* Support for core dump NOTE sections. */
2913 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2915 size_t offset, size;
2917 if (note->descsz != 504)
2921 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2924 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2930 /* Make a ".reg/999" section. */
2931 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2932 size, note->descpos + offset);
2936 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2938 if (note->descsz != 136)
2941 elf_tdata (abfd)->core->pid
2942 = bfd_get_32 (abfd, note->descdata + 24);
2943 elf_tdata (abfd)->core->program
2944 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2945 elf_tdata (abfd)->core->command
2946 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2952 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2965 va_start (ap, note_type);
2966 memset (data, 0, sizeof (data));
2967 strncpy (data + 40, va_arg (ap, const char *), 16);
2968 strncpy (data + 56, va_arg (ap, const char *), 80);
2970 return elfcore_write_note (abfd, buf, bufsiz,
2971 "CORE", note_type, data, sizeof (data));
2982 va_start (ap, note_type);
2983 memset (data, 0, 112);
2984 pid = va_arg (ap, long);
2985 bfd_put_32 (abfd, pid, data + 32);
2986 cursig = va_arg (ap, int);
2987 bfd_put_16 (abfd, cursig, data + 12);
2988 greg = va_arg (ap, const void *);
2989 memcpy (data + 112, greg, 384);
2990 memset (data + 496, 0, 8);
2992 return elfcore_write_note (abfd, buf, bufsiz,
2993 "CORE", note_type, data, sizeof (data));
2998 /* Add extra PPC sections. */
3000 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3002 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3003 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3004 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3007 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3008 { NULL, 0, 0, 0, 0 }
3011 enum _ppc64_sec_type {
3017 struct _ppc64_elf_section_data
3019 struct bfd_elf_section_data elf;
3023 /* An array with one entry for each opd function descriptor,
3024 and some spares since opd entries may be either 16 or 24 bytes. */
3025 #define OPD_NDX(OFF) ((OFF) >> 4)
3026 struct _opd_sec_data
3028 /* Points to the function code section for local opd entries. */
3029 asection **func_sec;
3031 /* After editing .opd, adjust references to opd local syms. */
3035 /* An array for toc sections, indexed by offset/8. */
3036 struct _toc_sec_data
3038 /* Specifies the relocation symbol index used at a given toc offset. */
3041 /* And the relocation addend. */
3046 enum _ppc64_sec_type sec_type:2;
3048 /* Flag set when small branches are detected. Used to
3049 select suitable defaults for the stub group size. */
3050 unsigned int has_14bit_branch:1;
3053 #define ppc64_elf_section_data(sec) \
3054 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3057 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3059 if (!sec->used_by_bfd)
3061 struct _ppc64_elf_section_data *sdata;
3062 bfd_size_type amt = sizeof (*sdata);
3064 sdata = bfd_zalloc (abfd, amt);
3067 sec->used_by_bfd = sdata;
3070 return _bfd_elf_new_section_hook (abfd, sec);
3073 static struct _opd_sec_data *
3074 get_opd_info (asection * sec)
3077 && ppc64_elf_section_data (sec) != NULL
3078 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3079 return &ppc64_elf_section_data (sec)->u.opd;
3083 /* Parameters for the qsort hook. */
3084 static bfd_boolean synthetic_relocatable;
3086 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3089 compare_symbols (const void *ap, const void *bp)
3091 const asymbol *a = * (const asymbol **) ap;
3092 const asymbol *b = * (const asymbol **) bp;
3094 /* Section symbols first. */
3095 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3097 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3100 /* then .opd symbols. */
3101 if (strcmp (a->section->name, ".opd") == 0
3102 && strcmp (b->section->name, ".opd") != 0)
3104 if (strcmp (a->section->name, ".opd") != 0
3105 && strcmp (b->section->name, ".opd") == 0)
3108 /* then other code symbols. */
3109 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3110 == (SEC_CODE | SEC_ALLOC)
3111 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3112 != (SEC_CODE | SEC_ALLOC))
3115 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3116 != (SEC_CODE | SEC_ALLOC)
3117 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3118 == (SEC_CODE | SEC_ALLOC))
3121 if (synthetic_relocatable)
3123 if (a->section->id < b->section->id)
3126 if (a->section->id > b->section->id)
3130 if (a->value + a->section->vma < b->value + b->section->vma)
3133 if (a->value + a->section->vma > b->value + b->section->vma)
3136 /* For syms with the same value, prefer strong dynamic global function
3137 syms over other syms. */
3138 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3141 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3144 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3147 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3150 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3153 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3156 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3159 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3165 /* Search SYMS for a symbol of the given VALUE. */
3168 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3172 if (id == (unsigned) -1)
3176 mid = (lo + hi) >> 1;
3177 if (syms[mid]->value + syms[mid]->section->vma < value)
3179 else if (syms[mid]->value + syms[mid]->section->vma > value)
3189 mid = (lo + hi) >> 1;
3190 if (syms[mid]->section->id < id)
3192 else if (syms[mid]->section->id > id)
3194 else if (syms[mid]->value < value)
3196 else if (syms[mid]->value > value)
3206 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3208 bfd_vma vma = *(bfd_vma *) ptr;
3209 return ((section->flags & SEC_ALLOC) != 0
3210 && section->vma <= vma
3211 && vma < section->vma + section->size);
3214 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3215 entry syms. Also generate @plt symbols for the glink branch table.
3216 Returns count of synthetic symbols in RET or -1 on error. */
3219 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3220 long static_count, asymbol **static_syms,
3221 long dyn_count, asymbol **dyn_syms,
3228 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3229 asection *opd = NULL;
3230 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3232 int abi = abiversion (abfd);
3238 opd = bfd_get_section_by_name (abfd, ".opd");
3239 if (opd == NULL && abi == 1)
3243 symcount = static_count;
3245 symcount += dyn_count;
3249 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3253 if (!relocatable && static_count != 0 && dyn_count != 0)
3255 /* Use both symbol tables. */
3256 memcpy (syms, static_syms, static_count * sizeof (*syms));
3257 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3259 else if (!relocatable && static_count == 0)
3260 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3262 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3264 synthetic_relocatable = relocatable;
3265 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3267 if (!relocatable && symcount > 1)
3270 /* Trim duplicate syms, since we may have merged the normal and
3271 dynamic symbols. Actually, we only care about syms that have
3272 different values, so trim any with the same value. */
3273 for (i = 1, j = 1; i < symcount; ++i)
3274 if (syms[i - 1]->value + syms[i - 1]->section->vma
3275 != syms[i]->value + syms[i]->section->vma)
3276 syms[j++] = syms[i];
3281 if (strcmp (syms[i]->section->name, ".opd") == 0)
3285 for (; i < symcount; ++i)
3286 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3287 != (SEC_CODE | SEC_ALLOC))
3288 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3292 for (; i < symcount; ++i)
3293 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3297 for (; i < symcount; ++i)
3298 if (strcmp (syms[i]->section->name, ".opd") != 0)
3302 for (; i < symcount; ++i)
3303 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3304 != (SEC_CODE | SEC_ALLOC))
3312 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3317 if (opdsymend == secsymend)
3320 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3321 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3325 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3332 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3336 while (r < opd->relocation + relcount
3337 && r->address < syms[i]->value + opd->vma)
3340 if (r == opd->relocation + relcount)
3343 if (r->address != syms[i]->value + opd->vma)
3346 if (r->howto->type != R_PPC64_ADDR64)
3349 sym = *r->sym_ptr_ptr;
3350 if (!sym_exists_at (syms, opdsymend, symcount,
3351 sym->section->id, sym->value + r->addend))
3354 size += sizeof (asymbol);
3355 size += strlen (syms[i]->name) + 2;
3361 s = *ret = bfd_malloc (size);
3368 names = (char *) (s + count);
3370 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3374 while (r < opd->relocation + relcount
3375 && r->address < syms[i]->value + opd->vma)
3378 if (r == opd->relocation + relcount)
3381 if (r->address != syms[i]->value + opd->vma)
3384 if (r->howto->type != R_PPC64_ADDR64)
3387 sym = *r->sym_ptr_ptr;
3388 if (!sym_exists_at (syms, opdsymend, symcount,
3389 sym->section->id, sym->value + r->addend))
3394 s->flags |= BSF_SYNTHETIC;
3395 s->section = sym->section;
3396 s->value = sym->value + r->addend;
3399 len = strlen (syms[i]->name);
3400 memcpy (names, syms[i]->name, len + 1);
3402 /* Have udata.p point back to the original symbol this
3403 synthetic symbol was derived from. */
3404 s->udata.p = syms[i];
3411 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3412 bfd_byte *contents = NULL;
3415 bfd_vma glink_vma = 0, resolv_vma = 0;
3416 asection *dynamic, *glink = NULL, *relplt = NULL;
3419 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3421 free_contents_and_exit_err:
3423 free_contents_and_exit:
3430 for (i = secsymend; i < opdsymend; ++i)
3434 /* Ignore bogus symbols. */
3435 if (syms[i]->value > opd->size - 8)
3438 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3439 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3442 size += sizeof (asymbol);
3443 size += strlen (syms[i]->name) + 2;
3447 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3449 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3451 bfd_byte *dynbuf, *extdyn, *extdynend;
3453 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3455 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3456 goto free_contents_and_exit_err;
3458 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3459 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3462 extdynend = extdyn + dynamic->size;
3463 for (; extdyn < extdynend; extdyn += extdynsize)
3465 Elf_Internal_Dyn dyn;
3466 (*swap_dyn_in) (abfd, extdyn, &dyn);
3468 if (dyn.d_tag == DT_NULL)
3471 if (dyn.d_tag == DT_PPC64_GLINK)
3473 /* The first glink stub starts at offset 32; see
3474 comment in ppc64_elf_finish_dynamic_sections. */
3475 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3476 /* The .glink section usually does not survive the final
3477 link; search for the section (usually .text) where the
3478 glink stubs now reside. */
3479 glink = bfd_sections_find_if (abfd, section_covers_vma,
3490 /* Determine __glink trampoline by reading the relative branch
3491 from the first glink stub. */
3493 unsigned int off = 0;
3495 while (bfd_get_section_contents (abfd, glink, buf,
3496 glink_vma + off - glink->vma, 4))
3498 unsigned int insn = bfd_get_32 (abfd, buf);
3500 if ((insn & ~0x3fffffc) == 0)
3502 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3511 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3513 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3516 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3517 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3518 goto free_contents_and_exit_err;
3520 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3521 size += plt_count * sizeof (asymbol);
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3526 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3528 size += sizeof ("+0x") - 1 + 16;
3534 goto free_contents_and_exit;
3535 s = *ret = bfd_malloc (size);
3537 goto free_contents_and_exit_err;
3539 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3541 for (i = secsymend; i < opdsymend; ++i)
3545 if (syms[i]->value > opd->size - 8)
3548 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3549 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3553 asection *sec = abfd->sections;
3560 long mid = (lo + hi) >> 1;
3561 if (syms[mid]->section->vma < ent)
3563 else if (syms[mid]->section->vma > ent)
3567 sec = syms[mid]->section;
3572 if (lo >= hi && lo > codesecsym)
3573 sec = syms[lo - 1]->section;
3575 for (; sec != NULL; sec = sec->next)
3579 /* SEC_LOAD may not be set if SEC is from a separate debug
3581 if ((sec->flags & SEC_ALLOC) == 0)
3583 if ((sec->flags & SEC_CODE) != 0)
3586 s->flags |= BSF_SYNTHETIC;
3587 s->value = ent - s->section->vma;
3590 len = strlen (syms[i]->name);
3591 memcpy (names, syms[i]->name, len + 1);
3593 /* Have udata.p point back to the original symbol this
3594 synthetic symbol was derived from. */
3595 s->udata.p = syms[i];
3601 if (glink != NULL && relplt != NULL)
3605 /* Add a symbol for the main glink trampoline. */
3606 memset (s, 0, sizeof *s);
3608 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3610 s->value = resolv_vma - glink->vma;
3612 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3613 names += sizeof ("__glink_PLTresolve");
3618 /* FIXME: It would be very much nicer to put sym@plt on the
3619 stub rather than on the glink branch table entry. The
3620 objdump disassembler would then use a sensible symbol
3621 name on plt calls. The difficulty in doing so is
3622 a) finding the stubs, and,
3623 b) matching stubs against plt entries, and,
3624 c) there can be multiple stubs for a given plt entry.
3626 Solving (a) could be done by code scanning, but older
3627 ppc64 binaries used different stubs to current code.
3628 (b) is the tricky one since you need to known the toc
3629 pointer for at least one function that uses a pic stub to
3630 be able to calculate the plt address referenced.
3631 (c) means gdb would need to set multiple breakpoints (or
3632 find the glink branch itself) when setting breakpoints
3633 for pending shared library loads. */
3634 p = relplt->relocation;
3635 for (i = 0; i < plt_count; i++, p++)
3639 *s = **p->sym_ptr_ptr;
3640 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3641 we are defining a symbol, ensure one of them is set. */
3642 if ((s->flags & BSF_LOCAL) == 0)
3643 s->flags |= BSF_GLOBAL;
3644 s->flags |= BSF_SYNTHETIC;
3646 s->value = glink_vma - glink->vma;
3649 len = strlen ((*p->sym_ptr_ptr)->name);
3650 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3654 memcpy (names, "+0x", sizeof ("+0x") - 1);
3655 names += sizeof ("+0x") - 1;
3656 bfd_sprintf_vma (abfd, names, p->addend);
3657 names += strlen (names);
3659 memcpy (names, "@plt", sizeof ("@plt"));
3660 names += sizeof ("@plt");
3680 /* The following functions are specific to the ELF linker, while
3681 functions above are used generally. Those named ppc64_elf_* are
3682 called by the main ELF linker code. They appear in this file more
3683 or less in the order in which they are called. eg.
3684 ppc64_elf_check_relocs is called early in the link process,
3685 ppc64_elf_finish_dynamic_sections is one of the last functions
3688 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3689 functions have both a function code symbol and a function descriptor
3690 symbol. A call to foo in a relocatable object file looks like:
3697 The function definition in another object file might be:
3701 . .quad .TOC.@tocbase
3707 When the linker resolves the call during a static link, the branch
3708 unsurprisingly just goes to .foo and the .opd information is unused.
3709 If the function definition is in a shared library, things are a little
3710 different: The call goes via a plt call stub, the opd information gets
3711 copied to the plt, and the linker patches the nop.
3719 . std 2,40(1) # in practice, the call stub
3720 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3721 . addi 11,11,Lfoo@toc@l # this is the general idea
3729 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3731 The "reloc ()" notation is supposed to indicate that the linker emits
3732 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3735 What are the difficulties here? Well, firstly, the relocations
3736 examined by the linker in check_relocs are against the function code
3737 sym .foo, while the dynamic relocation in the plt is emitted against
3738 the function descriptor symbol, foo. Somewhere along the line, we need
3739 to carefully copy dynamic link information from one symbol to the other.
3740 Secondly, the generic part of the elf linker will make .foo a dynamic
3741 symbol as is normal for most other backends. We need foo dynamic
3742 instead, at least for an application final link. However, when
3743 creating a shared library containing foo, we need to have both symbols
3744 dynamic so that references to .foo are satisfied during the early
3745 stages of linking. Otherwise the linker might decide to pull in a
3746 definition from some other object, eg. a static library.
3748 Update: As of August 2004, we support a new convention. Function
3749 calls may use the function descriptor symbol, ie. "bl foo". This
3750 behaves exactly as "bl .foo". */
3752 /* Of those relocs that might be copied as dynamic relocs, this function
3753 selects those that must be copied when linking a shared library,
3754 even when the symbol is local. */
3757 must_be_dyn_reloc (struct bfd_link_info *info,
3758 enum elf_ppc64_reloc_type r_type)
3770 case R_PPC64_TPREL16:
3771 case R_PPC64_TPREL16_LO:
3772 case R_PPC64_TPREL16_HI:
3773 case R_PPC64_TPREL16_HA:
3774 case R_PPC64_TPREL16_DS:
3775 case R_PPC64_TPREL16_LO_DS:
3776 case R_PPC64_TPREL16_HIGH:
3777 case R_PPC64_TPREL16_HIGHA:
3778 case R_PPC64_TPREL16_HIGHER:
3779 case R_PPC64_TPREL16_HIGHERA:
3780 case R_PPC64_TPREL16_HIGHEST:
3781 case R_PPC64_TPREL16_HIGHESTA:
3782 case R_PPC64_TPREL64:
3783 return !bfd_link_executable (info);
3787 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3788 copying dynamic variables from a shared lib into an app's dynbss
3789 section, and instead use a dynamic relocation to point into the
3790 shared lib. With code that gcc generates, it's vital that this be
3791 enabled; In the PowerPC64 ABI, the address of a function is actually
3792 the address of a function descriptor, which resides in the .opd
3793 section. gcc uses the descriptor directly rather than going via the
3794 GOT as some other ABI's do, which means that initialized function
3795 pointers must reference the descriptor. Thus, a function pointer
3796 initialized to the address of a function in a shared library will
3797 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3798 redefines the function descriptor symbol to point to the copy. This
3799 presents a problem as a plt entry for that function is also
3800 initialized from the function descriptor symbol and the copy reloc
3801 may not be initialized first. */
3802 #define ELIMINATE_COPY_RELOCS 1
3804 /* Section name for stubs is the associated section name plus this
3806 #define STUB_SUFFIX ".stub"
3809 ppc_stub_long_branch:
3810 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3811 destination, but a 24 bit branch in a stub section will reach.
3814 ppc_stub_plt_branch:
3815 Similar to the above, but a 24 bit branch in the stub section won't
3816 reach its destination.
3817 . addis %r11,%r2,xxx@toc@ha
3818 . ld %r12,xxx@toc@l(%r11)
3823 Used to call a function in a shared library. If it so happens that
3824 the plt entry referenced crosses a 64k boundary, then an extra
3825 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3827 . addis %r11,%r2,xxx@toc@ha
3828 . ld %r12,xxx+0@toc@l(%r11)
3830 . ld %r2,xxx+8@toc@l(%r11)
3831 . ld %r11,xxx+16@toc@l(%r11)
3834 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3835 code to adjust the value and save r2 to support multiple toc sections.
3836 A ppc_stub_long_branch with an r2 offset looks like:
3838 . addis %r2,%r2,off@ha
3839 . addi %r2,%r2,off@l
3842 A ppc_stub_plt_branch with an r2 offset looks like:
3844 . addis %r11,%r2,xxx@toc@ha
3845 . ld %r12,xxx@toc@l(%r11)
3846 . addis %r2,%r2,off@ha
3847 . addi %r2,%r2,off@l
3851 In cases where the "addis" instruction would add zero, the "addis" is
3852 omitted and following instructions modified slightly in some cases.
3855 enum ppc_stub_type {
3857 ppc_stub_long_branch,
3858 ppc_stub_long_branch_r2off,
3859 ppc_stub_plt_branch,
3860 ppc_stub_plt_branch_r2off,
3862 ppc_stub_plt_call_r2save,
3863 ppc_stub_global_entry,
3867 /* Information on stub grouping. */
3870 /* The stub section. */
3872 /* This is the section to which stubs in the group will be attached. */
3875 struct map_stub *next;
3876 /* Whether to emit a copy of register save/restore functions in this
3881 struct ppc_stub_hash_entry {
3883 /* Base hash table entry structure. */
3884 struct bfd_hash_entry root;
3886 enum ppc_stub_type stub_type;
3888 /* Group information. */
3889 struct map_stub *group;
3891 /* Offset within stub_sec of the beginning of this stub. */
3892 bfd_vma stub_offset;
3894 /* Given the symbol's value and its section we can determine its final
3895 value when building the stubs (so the stub knows where to jump. */
3896 bfd_vma target_value;
3897 asection *target_section;
3899 /* The symbol table entry, if any, that this was derived from. */
3900 struct ppc_link_hash_entry *h;
3901 struct plt_entry *plt_ent;
3903 /* Symbol st_other. */
3904 unsigned char other;
3907 struct ppc_branch_hash_entry {
3909 /* Base hash table entry structure. */
3910 struct bfd_hash_entry root;
3912 /* Offset within branch lookup table. */
3913 unsigned int offset;
3915 /* Generation marker. */
3919 /* Used to track dynamic relocations for local symbols. */
3920 struct ppc_dyn_relocs
3922 struct ppc_dyn_relocs *next;
3924 /* The input section of the reloc. */
3927 /* Total number of relocs copied for the input section. */
3928 unsigned int count : 31;
3930 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3931 unsigned int ifunc : 1;
3934 struct ppc_link_hash_entry
3936 struct elf_link_hash_entry elf;
3939 /* A pointer to the most recently used stub hash entry against this
3941 struct ppc_stub_hash_entry *stub_cache;
3943 /* A pointer to the next symbol starting with a '.' */
3944 struct ppc_link_hash_entry *next_dot_sym;
3947 /* Track dynamic relocs copied for this symbol. */
3948 struct elf_dyn_relocs *dyn_relocs;
3950 /* Link between function code and descriptor symbols. */
3951 struct ppc_link_hash_entry *oh;
3953 /* Flag function code and descriptor symbols. */
3954 unsigned int is_func:1;
3955 unsigned int is_func_descriptor:1;
3956 unsigned int fake:1;
3958 /* Whether global opd/toc sym has been adjusted or not.
3959 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3960 should be set for all globals defined in any opd/toc section. */
3961 unsigned int adjust_done:1;
3963 /* Set if we twiddled this symbol to weak at some stage. */
3964 unsigned int was_undefined:1;
3966 /* Set if this is an out-of-line register save/restore function,
3967 with non-standard calling convention. */
3968 unsigned int save_res:1;
3970 /* Contexts in which symbol is used in the GOT (or TOC).
3971 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3972 corresponding relocs are encountered during check_relocs.
3973 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3974 indicate the corresponding GOT entry type is not needed.
3975 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3976 a TPREL one. We use a separate flag rather than setting TPREL
3977 just for convenience in distinguishing the two cases. */
3978 #define TLS_GD 1 /* GD reloc. */
3979 #define TLS_LD 2 /* LD reloc. */
3980 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3981 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3982 #define TLS_TLS 16 /* Any TLS reloc. */
3983 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3984 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3985 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3986 unsigned char tls_mask;
3989 /* ppc64 ELF linker hash table. */
3991 struct ppc_link_hash_table
3993 struct elf_link_hash_table elf;
3995 /* The stub hash table. */
3996 struct bfd_hash_table stub_hash_table;
3998 /* Another hash table for plt_branch stubs. */
3999 struct bfd_hash_table branch_hash_table;
4001 /* Hash table for function prologue tocsave. */
4002 htab_t tocsave_htab;
4004 /* Various options and other info passed from the linker. */
4005 struct ppc64_elf_params *params;
4007 /* The size of sec_info below. */
4008 unsigned int sec_info_arr_size;
4010 /* Per-section array of extra section info. Done this way rather
4011 than as part of ppc64_elf_section_data so we have the info for
4012 non-ppc64 sections. */
4015 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4020 /* The section group that this section belongs to. */
4021 struct map_stub *group;
4022 /* A temp section list pointer. */
4027 /* Linked list of groups. */
4028 struct map_stub *group;
4030 /* Temp used when calculating TOC pointers. */
4033 asection *toc_first_sec;
4035 /* Used when adding symbols. */
4036 struct ppc_link_hash_entry *dot_syms;
4038 /* Shortcuts to get to dynamic linker sections. */
4045 asection *glink_eh_frame;
4047 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4048 struct ppc_link_hash_entry *tls_get_addr;
4049 struct ppc_link_hash_entry *tls_get_addr_fd;
4051 /* The size of reliplt used by got entry relocs. */
4052 bfd_size_type got_reli_size;
4055 unsigned long stub_count[ppc_stub_global_entry];
4057 /* Number of stubs against global syms. */
4058 unsigned long stub_globals;
4060 /* Set if we're linking code with function descriptors. */
4061 unsigned int opd_abi:1;
4063 /* Support for multiple toc sections. */
4064 unsigned int do_multi_toc:1;
4065 unsigned int multi_toc_needed:1;
4066 unsigned int second_toc_pass:1;
4067 unsigned int do_toc_opt:1;
4070 unsigned int stub_error:1;
4072 /* Temp used by ppc64_elf_before_check_relocs. */
4073 unsigned int twiddled_syms:1;
4075 /* Incremented every time we size stubs. */
4076 unsigned int stub_iteration;
4078 /* Small local sym cache. */
4079 struct sym_cache sym_cache;
4082 /* Rename some of the generic section flags to better document how they
4085 /* Nonzero if this section has TLS related relocations. */
4086 #define has_tls_reloc sec_flg0
4088 /* Nonzero if this section has a call to __tls_get_addr. */
4089 #define has_tls_get_addr_call sec_flg1
4091 /* Nonzero if this section has any toc or got relocs. */
4092 #define has_toc_reloc sec_flg2
4094 /* Nonzero if this section has a call to another section that uses
4096 #define makes_toc_func_call sec_flg3
4098 /* Recursion protection when determining above flag. */
4099 #define call_check_in_progress sec_flg4
4100 #define call_check_done sec_flg5
4102 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4104 #define ppc_hash_table(p) \
4105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4106 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4108 #define ppc_stub_hash_lookup(table, string, create, copy) \
4109 ((struct ppc_stub_hash_entry *) \
4110 bfd_hash_lookup ((table), (string), (create), (copy)))
4112 #define ppc_branch_hash_lookup(table, string, create, copy) \
4113 ((struct ppc_branch_hash_entry *) \
4114 bfd_hash_lookup ((table), (string), (create), (copy)))
4116 /* Create an entry in the stub hash table. */
4118 static struct bfd_hash_entry *
4119 stub_hash_newfunc (struct bfd_hash_entry *entry,
4120 struct bfd_hash_table *table,
4123 /* Allocate the structure if it has not already been allocated by a
4127 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4132 /* Call the allocation method of the superclass. */
4133 entry = bfd_hash_newfunc (entry, table, string);
4136 struct ppc_stub_hash_entry *eh;
4138 /* Initialize the local fields. */
4139 eh = (struct ppc_stub_hash_entry *) entry;
4140 eh->stub_type = ppc_stub_none;
4142 eh->stub_offset = 0;
4143 eh->target_value = 0;
4144 eh->target_section = NULL;
4153 /* Create an entry in the branch hash table. */
4155 static struct bfd_hash_entry *
4156 branch_hash_newfunc (struct bfd_hash_entry *entry,
4157 struct bfd_hash_table *table,
4160 /* Allocate the structure if it has not already been allocated by a
4164 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4169 /* Call the allocation method of the superclass. */
4170 entry = bfd_hash_newfunc (entry, table, string);
4173 struct ppc_branch_hash_entry *eh;
4175 /* Initialize the local fields. */
4176 eh = (struct ppc_branch_hash_entry *) entry;
4184 /* Create an entry in a ppc64 ELF linker hash table. */
4186 static struct bfd_hash_entry *
4187 link_hash_newfunc (struct bfd_hash_entry *entry,
4188 struct bfd_hash_table *table,
4191 /* Allocate the structure if it has not already been allocated by a
4195 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4200 /* Call the allocation method of the superclass. */
4201 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4204 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4206 memset (&eh->u.stub_cache, 0,
4207 (sizeof (struct ppc_link_hash_entry)
4208 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4210 /* When making function calls, old ABI code references function entry
4211 points (dot symbols), while new ABI code references the function
4212 descriptor symbol. We need to make any combination of reference and
4213 definition work together, without breaking archive linking.
4215 For a defined function "foo" and an undefined call to "bar":
4216 An old object defines "foo" and ".foo", references ".bar" (possibly
4218 A new object defines "foo" and references "bar".
4220 A new object thus has no problem with its undefined symbols being
4221 satisfied by definitions in an old object. On the other hand, the
4222 old object won't have ".bar" satisfied by a new object.
4224 Keep a list of newly added dot-symbols. */
4226 if (string[0] == '.')
4228 struct ppc_link_hash_table *htab;
4230 htab = (struct ppc_link_hash_table *) table;
4231 eh->u.next_dot_sym = htab->dot_syms;
4232 htab->dot_syms = eh;
4239 struct tocsave_entry {
4245 tocsave_htab_hash (const void *p)
4247 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4248 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4252 tocsave_htab_eq (const void *p1, const void *p2)
4254 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4255 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4256 return e1->sec == e2->sec && e1->offset == e2->offset;
4259 /* Destroy a ppc64 ELF linker hash table. */
4262 ppc64_elf_link_hash_table_free (bfd *obfd)
4264 struct ppc_link_hash_table *htab;
4266 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4267 if (htab->tocsave_htab)
4268 htab_delete (htab->tocsave_htab);
4269 bfd_hash_table_free (&htab->branch_hash_table);
4270 bfd_hash_table_free (&htab->stub_hash_table);
4271 _bfd_elf_link_hash_table_free (obfd);
4274 /* Create a ppc64 ELF linker hash table. */
4276 static struct bfd_link_hash_table *
4277 ppc64_elf_link_hash_table_create (bfd *abfd)
4279 struct ppc_link_hash_table *htab;
4280 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4282 htab = bfd_zmalloc (amt);
4286 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4287 sizeof (struct ppc_link_hash_entry),
4294 /* Init the stub hash table too. */
4295 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4296 sizeof (struct ppc_stub_hash_entry)))
4298 _bfd_elf_link_hash_table_free (abfd);
4302 /* And the branch hash table. */
4303 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4304 sizeof (struct ppc_branch_hash_entry)))
4306 bfd_hash_table_free (&htab->stub_hash_table);
4307 _bfd_elf_link_hash_table_free (abfd);
4311 htab->tocsave_htab = htab_try_create (1024,
4315 if (htab->tocsave_htab == NULL)
4317 ppc64_elf_link_hash_table_free (abfd);
4320 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4322 /* Initializing two fields of the union is just cosmetic. We really
4323 only care about glist, but when compiled on a 32-bit host the
4324 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4325 debugger inspection of these fields look nicer. */
4326 htab->elf.init_got_refcount.refcount = 0;
4327 htab->elf.init_got_refcount.glist = NULL;
4328 htab->elf.init_plt_refcount.refcount = 0;
4329 htab->elf.init_plt_refcount.glist = NULL;
4330 htab->elf.init_got_offset.offset = 0;
4331 htab->elf.init_got_offset.glist = NULL;
4332 htab->elf.init_plt_offset.offset = 0;
4333 htab->elf.init_plt_offset.glist = NULL;
4335 return &htab->elf.root;
4338 /* Create sections for linker generated code. */
4341 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4343 struct ppc_link_hash_table *htab;
4346 htab = ppc_hash_table (info);
4348 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4349 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4350 if (htab->params->save_restore_funcs)
4352 /* Create .sfpr for code to save and restore fp regs. */
4353 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4355 if (htab->sfpr == NULL
4356 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4360 if (bfd_link_relocatable (info))
4363 /* Create .glink for lazy dynamic linking support. */
4364 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4366 if (htab->glink == NULL
4367 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4370 if (!info->no_ld_generated_unwind_info)
4372 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4373 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4374 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4377 if (htab->glink_eh_frame == NULL
4378 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4382 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4383 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4384 if (htab->elf.iplt == NULL
4385 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4388 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4389 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4391 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4392 if (htab->elf.irelplt == NULL
4393 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4396 /* Create branch lookup table for plt_branch stubs. */
4397 flags = (SEC_ALLOC | SEC_LOAD
4398 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4399 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4401 if (htab->brlt == NULL
4402 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4405 if (!bfd_link_pic (info))
4408 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4409 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4410 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4413 if (htab->relbrlt == NULL
4414 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4420 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4423 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4424 struct ppc64_elf_params *params)
4426 struct ppc_link_hash_table *htab;
4428 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4430 /* Always hook our dynamic sections into the first bfd, which is the
4431 linker created stub bfd. This ensures that the GOT header is at
4432 the start of the output TOC section. */
4433 htab = ppc_hash_table (info);
4434 htab->elf.dynobj = params->stub_bfd;
4435 htab->params = params;
4437 return create_linkage_sections (htab->elf.dynobj, info);
4440 /* Build a name for an entry in the stub hash table. */
4443 ppc_stub_name (const asection *input_section,
4444 const asection *sym_sec,
4445 const struct ppc_link_hash_entry *h,
4446 const Elf_Internal_Rela *rel)
4451 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4452 offsets from a sym as a branch target? In fact, we could
4453 probably assume the addend is always zero. */
4454 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4458 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4459 stub_name = bfd_malloc (len);
4460 if (stub_name == NULL)
4463 len = sprintf (stub_name, "%08x.%s+%x",
4464 input_section->id & 0xffffffff,
4465 h->elf.root.root.string,
4466 (int) rel->r_addend & 0xffffffff);
4470 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4471 stub_name = bfd_malloc (len);
4472 if (stub_name == NULL)
4475 len = sprintf (stub_name, "%08x.%x:%x+%x",
4476 input_section->id & 0xffffffff,
4477 sym_sec->id & 0xffffffff,
4478 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4479 (int) rel->r_addend & 0xffffffff);
4481 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4482 stub_name[len - 2] = 0;
4486 /* Look up an entry in the stub hash. Stub entries are cached because
4487 creating the stub name takes a bit of time. */
4489 static struct ppc_stub_hash_entry *
4490 ppc_get_stub_entry (const asection *input_section,
4491 const asection *sym_sec,
4492 struct ppc_link_hash_entry *h,
4493 const Elf_Internal_Rela *rel,
4494 struct ppc_link_hash_table *htab)
4496 struct ppc_stub_hash_entry *stub_entry;
4497 struct map_stub *group;
4499 /* If this input section is part of a group of sections sharing one
4500 stub section, then use the id of the first section in the group.
4501 Stub names need to include a section id, as there may well be
4502 more than one stub used to reach say, printf, and we need to
4503 distinguish between them. */
4504 group = htab->sec_info[input_section->id].u.group;
4506 if (h != NULL && h->u.stub_cache != NULL
4507 && h->u.stub_cache->h == h
4508 && h->u.stub_cache->group == group)
4510 stub_entry = h->u.stub_cache;
4516 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4517 if (stub_name == NULL)
4520 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4521 stub_name, FALSE, FALSE);
4523 h->u.stub_cache = stub_entry;
4531 /* Add a new stub entry to the stub hash. Not all fields of the new
4532 stub entry are initialised. */
4534 static struct ppc_stub_hash_entry *
4535 ppc_add_stub (const char *stub_name,
4537 struct bfd_link_info *info)
4539 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4540 struct map_stub *group;
4543 struct ppc_stub_hash_entry *stub_entry;
4545 group = htab->sec_info[section->id].u.group;
4546 link_sec = group->link_sec;
4547 stub_sec = group->stub_sec;
4548 if (stub_sec == NULL)
4554 namelen = strlen (link_sec->name);
4555 len = namelen + sizeof (STUB_SUFFIX);
4556 s_name = bfd_alloc (htab->params->stub_bfd, len);
4560 memcpy (s_name, link_sec->name, namelen);
4561 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4562 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4563 if (stub_sec == NULL)
4565 group->stub_sec = stub_sec;
4568 /* Enter this entry into the linker stub hash table. */
4569 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4571 if (stub_entry == NULL)
4573 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4574 section->owner, stub_name);
4578 stub_entry->group = group;
4579 stub_entry->stub_offset = 0;
4583 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4584 not already done. */
4587 create_got_section (bfd *abfd, struct bfd_link_info *info)
4589 asection *got, *relgot;
4591 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4593 if (!is_ppc64_elf (abfd))
4599 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4602 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4603 | SEC_LINKER_CREATED);
4605 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4607 || !bfd_set_section_alignment (abfd, got, 3))
4610 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4611 flags | SEC_READONLY);
4613 || ! bfd_set_section_alignment (abfd, relgot, 3))
4616 ppc64_elf_tdata (abfd)->got = got;
4617 ppc64_elf_tdata (abfd)->relgot = relgot;
4621 /* Create the dynamic sections, and set up shortcuts. */
4624 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4626 struct ppc_link_hash_table *htab;
4628 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4631 htab = ppc_hash_table (info);
4635 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4636 if (!bfd_link_pic (info))
4637 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4639 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4640 || (!bfd_link_pic (info) && !htab->relbss))
4646 /* Follow indirect and warning symbol links. */
4648 static inline struct bfd_link_hash_entry *
4649 follow_link (struct bfd_link_hash_entry *h)
4651 while (h->type == bfd_link_hash_indirect
4652 || h->type == bfd_link_hash_warning)
4657 static inline struct elf_link_hash_entry *
4658 elf_follow_link (struct elf_link_hash_entry *h)
4660 return (struct elf_link_hash_entry *) follow_link (&h->root);
4663 static inline struct ppc_link_hash_entry *
4664 ppc_follow_link (struct ppc_link_hash_entry *h)
4666 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4669 /* Merge PLT info on FROM with that on TO. */
4672 move_plt_plist (struct ppc_link_hash_entry *from,
4673 struct ppc_link_hash_entry *to)
4675 if (from->elf.plt.plist != NULL)
4677 if (to->elf.plt.plist != NULL)
4679 struct plt_entry **entp;
4680 struct plt_entry *ent;
4682 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4684 struct plt_entry *dent;
4686 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4687 if (dent->addend == ent->addend)
4689 dent->plt.refcount += ent->plt.refcount;
4696 *entp = to->elf.plt.plist;
4699 to->elf.plt.plist = from->elf.plt.plist;
4700 from->elf.plt.plist = NULL;
4704 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4707 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4708 struct elf_link_hash_entry *dir,
4709 struct elf_link_hash_entry *ind)
4711 struct ppc_link_hash_entry *edir, *eind;
4713 edir = (struct ppc_link_hash_entry *) dir;
4714 eind = (struct ppc_link_hash_entry *) ind;
4716 edir->is_func |= eind->is_func;
4717 edir->is_func_descriptor |= eind->is_func_descriptor;
4718 edir->tls_mask |= eind->tls_mask;
4719 if (eind->oh != NULL)
4720 edir->oh = ppc_follow_link (eind->oh);
4722 /* If called to transfer flags for a weakdef during processing
4723 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4724 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4725 if (!(ELIMINATE_COPY_RELOCS
4726 && eind->elf.root.type != bfd_link_hash_indirect
4727 && edir->elf.dynamic_adjusted))
4728 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4730 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4731 edir->elf.ref_regular |= eind->elf.ref_regular;
4732 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4733 edir->elf.needs_plt |= eind->elf.needs_plt;
4734 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4736 /* Copy over any dynamic relocs we may have on the indirect sym. */
4737 if (eind->dyn_relocs != NULL)
4739 if (edir->dyn_relocs != NULL)
4741 struct elf_dyn_relocs **pp;
4742 struct elf_dyn_relocs *p;
4744 /* Add reloc counts against the indirect sym to the direct sym
4745 list. Merge any entries against the same section. */
4746 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4748 struct elf_dyn_relocs *q;
4750 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4751 if (q->sec == p->sec)
4753 q->pc_count += p->pc_count;
4754 q->count += p->count;
4761 *pp = edir->dyn_relocs;
4764 edir->dyn_relocs = eind->dyn_relocs;
4765 eind->dyn_relocs = NULL;
4768 /* If we were called to copy over info for a weak sym, that's all.
4769 You might think dyn_relocs need not be copied over; After all,
4770 both syms will be dynamic or both non-dynamic so we're just
4771 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4772 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4773 dyn_relocs in read-only sections, and it does so on what is the
4775 if (eind->elf.root.type != bfd_link_hash_indirect)
4778 /* Copy over got entries that we may have already seen to the
4779 symbol which just became indirect. */
4780 if (eind->elf.got.glist != NULL)
4782 if (edir->elf.got.glist != NULL)
4784 struct got_entry **entp;
4785 struct got_entry *ent;
4787 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4789 struct got_entry *dent;
4791 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4792 if (dent->addend == ent->addend
4793 && dent->owner == ent->owner
4794 && dent->tls_type == ent->tls_type)
4796 dent->got.refcount += ent->got.refcount;
4803 *entp = edir->elf.got.glist;
4806 edir->elf.got.glist = eind->elf.got.glist;
4807 eind->elf.got.glist = NULL;
4810 /* And plt entries. */
4811 move_plt_plist (eind, edir);
4813 if (eind->elf.dynindx != -1)
4815 if (edir->elf.dynindx != -1)
4816 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4817 edir->elf.dynstr_index);
4818 edir->elf.dynindx = eind->elf.dynindx;
4819 edir->elf.dynstr_index = eind->elf.dynstr_index;
4820 eind->elf.dynindx = -1;
4821 eind->elf.dynstr_index = 0;
4825 /* Find the function descriptor hash entry from the given function code
4826 hash entry FH. Link the entries via their OH fields. */
4828 static struct ppc_link_hash_entry *
4829 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4831 struct ppc_link_hash_entry *fdh = fh->oh;
4835 const char *fd_name = fh->elf.root.root.string + 1;
4837 fdh = (struct ppc_link_hash_entry *)
4838 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4842 fdh->is_func_descriptor = 1;
4848 return ppc_follow_link (fdh);
4851 /* Make a fake function descriptor sym for the code sym FH. */
4853 static struct ppc_link_hash_entry *
4854 make_fdh (struct bfd_link_info *info,
4855 struct ppc_link_hash_entry *fh)
4859 struct bfd_link_hash_entry *bh;
4860 struct ppc_link_hash_entry *fdh;
4862 abfd = fh->elf.root.u.undef.abfd;
4863 newsym = bfd_make_empty_symbol (abfd);
4864 newsym->name = fh->elf.root.root.string + 1;
4865 newsym->section = bfd_und_section_ptr;
4867 newsym->flags = BSF_WEAK;
4870 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4871 newsym->flags, newsym->section,
4872 newsym->value, NULL, FALSE, FALSE,
4876 fdh = (struct ppc_link_hash_entry *) bh;
4877 fdh->elf.non_elf = 0;
4879 fdh->is_func_descriptor = 1;
4886 /* Fix function descriptor symbols defined in .opd sections to be
4890 ppc64_elf_add_symbol_hook (bfd *ibfd,
4891 struct bfd_link_info *info,
4892 Elf_Internal_Sym *isym,
4894 flagword *flags ATTRIBUTE_UNUSED,
4898 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4899 && (ibfd->flags & DYNAMIC) == 0
4900 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4901 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4904 && strcmp ((*sec)->name, ".opd") == 0)
4908 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4909 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4910 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4912 /* If the symbol is a function defined in .opd, and the function
4913 code is in a discarded group, let it appear to be undefined. */
4914 if (!bfd_link_relocatable (info)
4915 && (*sec)->reloc_count != 0
4916 && opd_entry_value (*sec, *value, &code_sec, NULL,
4917 FALSE) != (bfd_vma) -1
4918 && discarded_section (code_sec))
4920 *sec = bfd_und_section_ptr;
4921 isym->st_shndx = SHN_UNDEF;
4924 else if (*sec != NULL
4925 && strcmp ((*sec)->name, ".toc") == 0
4926 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4928 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4930 htab->params->object_in_toc = 1;
4933 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4935 if (abiversion (ibfd) == 0)
4936 set_abiversion (ibfd, 2);
4937 else if (abiversion (ibfd) == 1)
4939 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4940 " for ABI version 1\n"), name);
4941 bfd_set_error (bfd_error_bad_value);
4949 /* Merge non-visibility st_other attributes: local entry point. */
4952 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4953 const Elf_Internal_Sym *isym,
4954 bfd_boolean definition,
4955 bfd_boolean dynamic)
4957 if (definition && !dynamic)
4958 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4959 | ELF_ST_VISIBILITY (h->other));
4962 /* This function makes an old ABI object reference to ".bar" cause the
4963 inclusion of a new ABI object archive that defines "bar".
4964 NAME is a symbol defined in an archive. Return a symbol in the hash
4965 table that might be satisfied by the archive symbols. */
4967 static struct elf_link_hash_entry *
4968 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4969 struct bfd_link_info *info,
4972 struct elf_link_hash_entry *h;
4976 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4978 /* Don't return this sym if it is a fake function descriptor
4979 created by add_symbol_adjust. */
4980 && !(h->root.type == bfd_link_hash_undefweak
4981 && ((struct ppc_link_hash_entry *) h)->fake))
4987 len = strlen (name);
4988 dot_name = bfd_alloc (abfd, len + 2);
4989 if (dot_name == NULL)
4990 return (struct elf_link_hash_entry *) 0 - 1;
4992 memcpy (dot_name + 1, name, len + 1);
4993 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4994 bfd_release (abfd, dot_name);
4998 /* This function satisfies all old ABI object references to ".bar" if a
4999 new ABI object defines "bar". Well, at least, undefined dot symbols
5000 are made weak. This stops later archive searches from including an
5001 object if we already have a function descriptor definition. It also
5002 prevents the linker complaining about undefined symbols.
5003 We also check and correct mismatched symbol visibility here. The
5004 most restrictive visibility of the function descriptor and the
5005 function entry symbol is used. */
5008 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5010 struct ppc_link_hash_table *htab;
5011 struct ppc_link_hash_entry *fdh;
5013 if (eh->elf.root.type == bfd_link_hash_indirect)
5016 if (eh->elf.root.type == bfd_link_hash_warning)
5017 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5019 if (eh->elf.root.root.string[0] != '.')
5022 htab = ppc_hash_table (info);
5026 fdh = lookup_fdh (eh, htab);
5029 if (!bfd_link_relocatable (info)
5030 && (eh->elf.root.type == bfd_link_hash_undefined
5031 || eh->elf.root.type == bfd_link_hash_undefweak)
5032 && eh->elf.ref_regular)
5034 /* Make an undefweak function descriptor sym, which is enough to
5035 pull in an --as-needed shared lib, but won't cause link
5036 errors. Archives are handled elsewhere. */
5037 fdh = make_fdh (info, eh);
5040 fdh->elf.ref_regular = 1;
5045 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5046 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5047 if (entry_vis < descr_vis)
5048 fdh->elf.other += entry_vis - descr_vis;
5049 else if (entry_vis > descr_vis)
5050 eh->elf.other += descr_vis - entry_vis;
5052 if ((fdh->elf.root.type == bfd_link_hash_defined
5053 || fdh->elf.root.type == bfd_link_hash_defweak)
5054 && eh->elf.root.type == bfd_link_hash_undefined)
5056 eh->elf.root.type = bfd_link_hash_undefweak;
5057 eh->was_undefined = 1;
5058 htab->twiddled_syms = 1;
5065 /* Set up opd section info and abiversion for IBFD, and process list
5066 of dot-symbols we made in link_hash_newfunc. */
5069 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5071 struct ppc_link_hash_table *htab;
5072 struct ppc_link_hash_entry **p, *eh;
5073 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5075 if (opd != NULL && opd->size != 0)
5077 if (abiversion (ibfd) == 0)
5078 set_abiversion (ibfd, 1);
5079 else if (abiversion (ibfd) == 2)
5081 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5083 ibfd, abiversion (ibfd));
5084 bfd_set_error (bfd_error_bad_value);
5088 if ((ibfd->flags & DYNAMIC) == 0
5089 && (opd->flags & SEC_RELOC) != 0
5090 && opd->reloc_count != 0
5091 && !bfd_is_abs_section (opd->output_section))
5093 /* Garbage collection needs some extra help with .opd sections.
5094 We don't want to necessarily keep everything referenced by
5095 relocs in .opd, as that would keep all functions. Instead,
5096 if we reference an .opd symbol (a function descriptor), we
5097 want to keep the function code symbol's section. This is
5098 easy for global symbols, but for local syms we need to keep
5099 information about the associated function section. */
5101 asection **opd_sym_map;
5103 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5104 opd_sym_map = bfd_zalloc (ibfd, amt);
5105 if (opd_sym_map == NULL)
5107 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5108 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5109 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5113 if (!is_ppc64_elf (info->output_bfd))
5115 htab = ppc_hash_table (info);
5119 /* For input files without an explicit abiversion in e_flags
5120 we should have flagged any with symbol st_other bits set
5121 as ELFv1 and above flagged those with .opd as ELFv2.
5122 Set the output abiversion if not yet set, and for any input
5123 still ambiguous, take its abiversion from the output.
5124 Differences in ABI are reported later. */
5125 if (abiversion (info->output_bfd) == 0)
5126 set_abiversion (info->output_bfd, abiversion (ibfd));
5127 else if (abiversion (ibfd) == 0)
5128 set_abiversion (ibfd, abiversion (info->output_bfd));
5130 p = &htab->dot_syms;
5131 while ((eh = *p) != NULL)
5134 if (&eh->elf == htab->elf.hgot)
5136 else if (htab->elf.hgot == NULL
5137 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5138 htab->elf.hgot = &eh->elf;
5139 else if (!add_symbol_adjust (eh, info))
5141 p = &eh->u.next_dot_sym;
5144 /* Clear the list for non-ppc64 input files. */
5145 p = &htab->dot_syms;
5146 while ((eh = *p) != NULL)
5149 p = &eh->u.next_dot_sym;
5152 /* We need to fix the undefs list for any syms we have twiddled to
5154 if (htab->twiddled_syms)
5156 bfd_link_repair_undef_list (&htab->elf.root);
5157 htab->twiddled_syms = 0;
5162 /* Undo hash table changes when an --as-needed input file is determined
5163 not to be needed. */
5166 ppc64_elf_notice_as_needed (bfd *ibfd,
5167 struct bfd_link_info *info,
5168 enum notice_asneeded_action act)
5170 if (act == notice_not_needed)
5172 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5177 htab->dot_syms = NULL;
5179 return _bfd_elf_notice_as_needed (ibfd, info, act);
5182 /* If --just-symbols against a final linked binary, then assume we need
5183 toc adjusting stubs when calling functions defined there. */
5186 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5188 if ((sec->flags & SEC_CODE) != 0
5189 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5190 && is_ppc64_elf (sec->owner))
5192 if (abiversion (sec->owner) >= 2
5193 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5194 sec->has_toc_reloc = 1;
5196 _bfd_elf_link_just_syms (sec, info);
5199 static struct plt_entry **
5200 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5201 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5203 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5204 struct plt_entry **local_plt;
5205 unsigned char *local_got_tls_masks;
5207 if (local_got_ents == NULL)
5209 bfd_size_type size = symtab_hdr->sh_info;
5211 size *= (sizeof (*local_got_ents)
5212 + sizeof (*local_plt)
5213 + sizeof (*local_got_tls_masks));
5214 local_got_ents = bfd_zalloc (abfd, size);
5215 if (local_got_ents == NULL)
5217 elf_local_got_ents (abfd) = local_got_ents;
5220 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5222 struct got_entry *ent;
5224 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5225 if (ent->addend == r_addend
5226 && ent->owner == abfd
5227 && ent->tls_type == tls_type)
5231 bfd_size_type amt = sizeof (*ent);
5232 ent = bfd_alloc (abfd, amt);
5235 ent->next = local_got_ents[r_symndx];
5236 ent->addend = r_addend;
5238 ent->tls_type = tls_type;
5239 ent->is_indirect = FALSE;
5240 ent->got.refcount = 0;
5241 local_got_ents[r_symndx] = ent;
5243 ent->got.refcount += 1;
5246 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5247 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5248 local_got_tls_masks[r_symndx] |= tls_type;
5250 return local_plt + r_symndx;
5254 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5256 struct plt_entry *ent;
5258 for (ent = *plist; ent != NULL; ent = ent->next)
5259 if (ent->addend == addend)
5263 bfd_size_type amt = sizeof (*ent);
5264 ent = bfd_alloc (abfd, amt);
5268 ent->addend = addend;
5269 ent->plt.refcount = 0;
5272 ent->plt.refcount += 1;
5277 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5279 return (r_type == R_PPC64_REL24
5280 || r_type == R_PPC64_REL14
5281 || r_type == R_PPC64_REL14_BRTAKEN
5282 || r_type == R_PPC64_REL14_BRNTAKEN
5283 || r_type == R_PPC64_ADDR24
5284 || r_type == R_PPC64_ADDR14
5285 || r_type == R_PPC64_ADDR14_BRTAKEN
5286 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5289 /* Look through the relocs for a section during the first phase, and
5290 calculate needed space in the global offset table, procedure
5291 linkage table, and dynamic reloc sections. */
5294 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5295 asection *sec, const Elf_Internal_Rela *relocs)
5297 struct ppc_link_hash_table *htab;
5298 Elf_Internal_Shdr *symtab_hdr;
5299 struct elf_link_hash_entry **sym_hashes;
5300 const Elf_Internal_Rela *rel;
5301 const Elf_Internal_Rela *rel_end;
5303 asection **opd_sym_map;
5304 struct elf_link_hash_entry *tga, *dottga;
5306 if (bfd_link_relocatable (info))
5309 /* Don't do anything special with non-loaded, non-alloced sections.
5310 In particular, any relocs in such sections should not affect GOT
5311 and PLT reference counting (ie. we don't allow them to create GOT
5312 or PLT entries), there's no possibility or desire to optimize TLS
5313 relocs, and there's not much point in propagating relocs to shared
5314 libs that the dynamic linker won't relocate. */
5315 if ((sec->flags & SEC_ALLOC) == 0)
5318 BFD_ASSERT (is_ppc64_elf (abfd));
5320 htab = ppc_hash_table (info);
5324 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5325 FALSE, FALSE, TRUE);
5326 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5327 FALSE, FALSE, TRUE);
5328 symtab_hdr = &elf_symtab_hdr (abfd);
5329 sym_hashes = elf_sym_hashes (abfd);
5332 if (ppc64_elf_section_data (sec) != NULL
5333 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5334 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5336 rel_end = relocs + sec->reloc_count;
5337 for (rel = relocs; rel < rel_end; rel++)
5339 unsigned long r_symndx;
5340 struct elf_link_hash_entry *h;
5341 enum elf_ppc64_reloc_type r_type;
5343 struct _ppc64_elf_section_data *ppc64_sec;
5344 struct plt_entry **ifunc, **plt_list;
5346 r_symndx = ELF64_R_SYM (rel->r_info);
5347 if (r_symndx < symtab_hdr->sh_info)
5351 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5352 h = elf_follow_link (h);
5354 /* PR15323, ref flags aren't set for references in the same
5356 h->root.non_ir_ref = 1;
5358 if (h == htab->elf.hgot)
5359 sec->has_toc_reloc = 1;
5366 if (h->type == STT_GNU_IFUNC)
5369 ifunc = &h->plt.plist;
5374 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5379 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5381 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5382 rel->r_addend, PLT_IFUNC);
5388 r_type = ELF64_R_TYPE (rel->r_info);
5393 /* These special tls relocs tie a call to __tls_get_addr with
5394 its parameter symbol. */
5397 case R_PPC64_GOT_TLSLD16:
5398 case R_PPC64_GOT_TLSLD16_LO:
5399 case R_PPC64_GOT_TLSLD16_HI:
5400 case R_PPC64_GOT_TLSLD16_HA:
5401 tls_type = TLS_TLS | TLS_LD;
5404 case R_PPC64_GOT_TLSGD16:
5405 case R_PPC64_GOT_TLSGD16_LO:
5406 case R_PPC64_GOT_TLSGD16_HI:
5407 case R_PPC64_GOT_TLSGD16_HA:
5408 tls_type = TLS_TLS | TLS_GD;
5411 case R_PPC64_GOT_TPREL16_DS:
5412 case R_PPC64_GOT_TPREL16_LO_DS:
5413 case R_PPC64_GOT_TPREL16_HI:
5414 case R_PPC64_GOT_TPREL16_HA:
5415 if (bfd_link_pic (info))
5416 info->flags |= DF_STATIC_TLS;
5417 tls_type = TLS_TLS | TLS_TPREL;
5420 case R_PPC64_GOT_DTPREL16_DS:
5421 case R_PPC64_GOT_DTPREL16_LO_DS:
5422 case R_PPC64_GOT_DTPREL16_HI:
5423 case R_PPC64_GOT_DTPREL16_HA:
5424 tls_type = TLS_TLS | TLS_DTPREL;
5426 sec->has_tls_reloc = 1;
5430 case R_PPC64_GOT16_DS:
5431 case R_PPC64_GOT16_HA:
5432 case R_PPC64_GOT16_HI:
5433 case R_PPC64_GOT16_LO:
5434 case R_PPC64_GOT16_LO_DS:
5435 /* This symbol requires a global offset table entry. */
5436 sec->has_toc_reloc = 1;
5437 if (r_type == R_PPC64_GOT_TLSLD16
5438 || r_type == R_PPC64_GOT_TLSGD16
5439 || r_type == R_PPC64_GOT_TPREL16_DS
5440 || r_type == R_PPC64_GOT_DTPREL16_DS
5441 || r_type == R_PPC64_GOT16
5442 || r_type == R_PPC64_GOT16_DS)
5444 htab->do_multi_toc = 1;
5445 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5448 if (ppc64_elf_tdata (abfd)->got == NULL
5449 && !create_got_section (abfd, info))
5454 struct ppc_link_hash_entry *eh;
5455 struct got_entry *ent;
5457 eh = (struct ppc_link_hash_entry *) h;
5458 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5459 if (ent->addend == rel->r_addend
5460 && ent->owner == abfd
5461 && ent->tls_type == tls_type)
5465 bfd_size_type amt = sizeof (*ent);
5466 ent = bfd_alloc (abfd, amt);
5469 ent->next = eh->elf.got.glist;
5470 ent->addend = rel->r_addend;
5472 ent->tls_type = tls_type;
5473 ent->is_indirect = FALSE;
5474 ent->got.refcount = 0;
5475 eh->elf.got.glist = ent;
5477 ent->got.refcount += 1;
5478 eh->tls_mask |= tls_type;
5481 /* This is a global offset table entry for a local symbol. */
5482 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5483 rel->r_addend, tls_type))
5486 /* We may also need a plt entry if the symbol turns out to be
5488 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5490 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5495 case R_PPC64_PLT16_HA:
5496 case R_PPC64_PLT16_HI:
5497 case R_PPC64_PLT16_LO:
5500 /* This symbol requires a procedure linkage table entry. */
5505 if (h->root.root.string[0] == '.'
5506 && h->root.root.string[1] != '\0')
5507 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5508 plt_list = &h->plt.plist;
5510 if (plt_list == NULL)
5512 /* It does not make sense to have a procedure linkage
5513 table entry for a non-ifunc local symbol. */
5514 info->callbacks->einfo
5515 (_("%P: %H: %s reloc against local symbol\n"),
5516 abfd, sec, rel->r_offset,
5517 ppc64_elf_howto_table[r_type]->name);
5518 bfd_set_error (bfd_error_bad_value);
5521 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5525 /* The following relocations don't need to propagate the
5526 relocation if linking a shared object since they are
5527 section relative. */
5528 case R_PPC64_SECTOFF:
5529 case R_PPC64_SECTOFF_LO:
5530 case R_PPC64_SECTOFF_HI:
5531 case R_PPC64_SECTOFF_HA:
5532 case R_PPC64_SECTOFF_DS:
5533 case R_PPC64_SECTOFF_LO_DS:
5534 case R_PPC64_DTPREL16:
5535 case R_PPC64_DTPREL16_LO:
5536 case R_PPC64_DTPREL16_HI:
5537 case R_PPC64_DTPREL16_HA:
5538 case R_PPC64_DTPREL16_DS:
5539 case R_PPC64_DTPREL16_LO_DS:
5540 case R_PPC64_DTPREL16_HIGH:
5541 case R_PPC64_DTPREL16_HIGHA:
5542 case R_PPC64_DTPREL16_HIGHER:
5543 case R_PPC64_DTPREL16_HIGHERA:
5544 case R_PPC64_DTPREL16_HIGHEST:
5545 case R_PPC64_DTPREL16_HIGHESTA:
5550 case R_PPC64_REL16_LO:
5551 case R_PPC64_REL16_HI:
5552 case R_PPC64_REL16_HA:
5553 case R_PPC64_REL16DX_HA:
5556 /* Not supported as a dynamic relocation. */
5557 case R_PPC64_ADDR64_LOCAL:
5558 if (bfd_link_pic (info))
5560 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5562 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5563 "in shared libraries and PIEs.\n"),
5564 abfd, sec, rel->r_offset,
5565 ppc64_elf_howto_table[r_type]->name);
5566 bfd_set_error (bfd_error_bad_value);
5572 case R_PPC64_TOC16_DS:
5573 htab->do_multi_toc = 1;
5574 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5575 case R_PPC64_TOC16_LO:
5576 case R_PPC64_TOC16_HI:
5577 case R_PPC64_TOC16_HA:
5578 case R_PPC64_TOC16_LO_DS:
5579 sec->has_toc_reloc = 1;
5586 /* This relocation describes the C++ object vtable hierarchy.
5587 Reconstruct it for later use during GC. */
5588 case R_PPC64_GNU_VTINHERIT:
5589 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5593 /* This relocation describes which C++ vtable entries are actually
5594 used. Record for later use during GC. */
5595 case R_PPC64_GNU_VTENTRY:
5596 BFD_ASSERT (h != NULL);
5598 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5603 case R_PPC64_REL14_BRTAKEN:
5604 case R_PPC64_REL14_BRNTAKEN:
5606 asection *dest = NULL;
5608 /* Heuristic: If jumping outside our section, chances are
5609 we are going to need a stub. */
5612 /* If the sym is weak it may be overridden later, so
5613 don't assume we know where a weak sym lives. */
5614 if (h->root.type == bfd_link_hash_defined)
5615 dest = h->root.u.def.section;
5619 Elf_Internal_Sym *isym;
5621 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5626 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5630 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5639 if (h->root.root.string[0] == '.'
5640 && h->root.root.string[1] != '\0')
5641 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5643 if (h == tga || h == dottga)
5645 sec->has_tls_reloc = 1;
5647 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5648 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5649 /* We have a new-style __tls_get_addr call with
5653 /* Mark this section as having an old-style call. */
5654 sec->has_tls_get_addr_call = 1;
5656 plt_list = &h->plt.plist;
5659 /* We may need a .plt entry if the function this reloc
5660 refers to is in a shared lib. */
5662 && !update_plt_info (abfd, plt_list, rel->r_addend))
5666 case R_PPC64_ADDR14:
5667 case R_PPC64_ADDR14_BRNTAKEN:
5668 case R_PPC64_ADDR14_BRTAKEN:
5669 case R_PPC64_ADDR24:
5672 case R_PPC64_TPREL64:
5673 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5674 if (bfd_link_pic (info))
5675 info->flags |= DF_STATIC_TLS;
5678 case R_PPC64_DTPMOD64:
5679 if (rel + 1 < rel_end
5680 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5681 && rel[1].r_offset == rel->r_offset + 8)
5682 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5684 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5687 case R_PPC64_DTPREL64:
5688 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5690 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5691 && rel[-1].r_offset == rel->r_offset - 8)
5692 /* This is the second reloc of a dtpmod, dtprel pair.
5693 Don't mark with TLS_DTPREL. */
5697 sec->has_tls_reloc = 1;
5700 struct ppc_link_hash_entry *eh;
5701 eh = (struct ppc_link_hash_entry *) h;
5702 eh->tls_mask |= tls_type;
5705 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5706 rel->r_addend, tls_type))
5709 ppc64_sec = ppc64_elf_section_data (sec);
5710 if (ppc64_sec->sec_type != sec_toc)
5714 /* One extra to simplify get_tls_mask. */
5715 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5716 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5717 if (ppc64_sec->u.toc.symndx == NULL)
5719 amt = sec->size * sizeof (bfd_vma) / 8;
5720 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5721 if (ppc64_sec->u.toc.add == NULL)
5723 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5724 ppc64_sec->sec_type = sec_toc;
5726 BFD_ASSERT (rel->r_offset % 8 == 0);
5727 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5728 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5730 /* Mark the second slot of a GD or LD entry.
5731 -1 to indicate GD and -2 to indicate LD. */
5732 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5733 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5734 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5735 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5738 case R_PPC64_TPREL16:
5739 case R_PPC64_TPREL16_LO:
5740 case R_PPC64_TPREL16_HI:
5741 case R_PPC64_TPREL16_HA:
5742 case R_PPC64_TPREL16_DS:
5743 case R_PPC64_TPREL16_LO_DS:
5744 case R_PPC64_TPREL16_HIGH:
5745 case R_PPC64_TPREL16_HIGHA:
5746 case R_PPC64_TPREL16_HIGHER:
5747 case R_PPC64_TPREL16_HIGHERA:
5748 case R_PPC64_TPREL16_HIGHEST:
5749 case R_PPC64_TPREL16_HIGHESTA:
5750 if (bfd_link_pic (info))
5752 info->flags |= DF_STATIC_TLS;
5757 case R_PPC64_ADDR64:
5758 if (opd_sym_map != NULL
5759 && rel + 1 < rel_end
5760 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5764 if (h->root.root.string[0] == '.'
5765 && h->root.root.string[1] != 0
5766 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5769 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5774 Elf_Internal_Sym *isym;
5776 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5781 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5782 if (s != NULL && s != sec)
5783 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5788 case R_PPC64_ADDR16:
5789 case R_PPC64_ADDR16_DS:
5790 case R_PPC64_ADDR16_HA:
5791 case R_PPC64_ADDR16_HI:
5792 case R_PPC64_ADDR16_HIGH:
5793 case R_PPC64_ADDR16_HIGHA:
5794 case R_PPC64_ADDR16_HIGHER:
5795 case R_PPC64_ADDR16_HIGHERA:
5796 case R_PPC64_ADDR16_HIGHEST:
5797 case R_PPC64_ADDR16_HIGHESTA:
5798 case R_PPC64_ADDR16_LO:
5799 case R_PPC64_ADDR16_LO_DS:
5800 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5801 && rel->r_addend == 0)
5803 /* We may need a .plt entry if this reloc refers to a
5804 function in a shared lib. */
5805 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5807 h->pointer_equality_needed = 1;
5814 case R_PPC64_ADDR32:
5815 case R_PPC64_UADDR16:
5816 case R_PPC64_UADDR32:
5817 case R_PPC64_UADDR64:
5819 if (h != NULL && !bfd_link_pic (info))
5820 /* We may need a copy reloc. */
5823 /* Don't propagate .opd relocs. */
5824 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5827 /* If we are creating a shared library, and this is a reloc
5828 against a global symbol, or a non PC relative reloc
5829 against a local symbol, then we need to copy the reloc
5830 into the shared library. However, if we are linking with
5831 -Bsymbolic, we do not need to copy a reloc against a
5832 global symbol which is defined in an object we are
5833 including in the link (i.e., DEF_REGULAR is set). At
5834 this point we have not seen all the input files, so it is
5835 possible that DEF_REGULAR is not set now but will be set
5836 later (it is never cleared). In case of a weak definition,
5837 DEF_REGULAR may be cleared later by a strong definition in
5838 a shared library. We account for that possibility below by
5839 storing information in the dyn_relocs field of the hash
5840 table entry. A similar situation occurs when creating
5841 shared libraries and symbol visibility changes render the
5844 If on the other hand, we are creating an executable, we
5845 may need to keep relocations for symbols satisfied by a
5846 dynamic library if we manage to avoid copy relocs for the
5849 if ((bfd_link_pic (info)
5850 && (must_be_dyn_reloc (info, r_type)
5852 && (!SYMBOLIC_BIND (info, h)
5853 || h->root.type == bfd_link_hash_defweak
5854 || !h->def_regular))))
5855 || (ELIMINATE_COPY_RELOCS
5856 && !bfd_link_pic (info)
5858 && (h->root.type == bfd_link_hash_defweak
5859 || !h->def_regular))
5860 || (!bfd_link_pic (info)
5863 /* We must copy these reloc types into the output file.
5864 Create a reloc section in dynobj and make room for
5868 sreloc = _bfd_elf_make_dynamic_reloc_section
5869 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5875 /* If this is a global symbol, we count the number of
5876 relocations we need for this symbol. */
5879 struct elf_dyn_relocs *p;
5880 struct elf_dyn_relocs **head;
5882 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5884 if (p == NULL || p->sec != sec)
5886 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5896 if (!must_be_dyn_reloc (info, r_type))
5901 /* Track dynamic relocs needed for local syms too.
5902 We really need local syms available to do this
5904 struct ppc_dyn_relocs *p;
5905 struct ppc_dyn_relocs **head;
5906 bfd_boolean is_ifunc;
5909 Elf_Internal_Sym *isym;
5911 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5916 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5920 vpp = &elf_section_data (s)->local_dynrel;
5921 head = (struct ppc_dyn_relocs **) vpp;
5922 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5924 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5926 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5928 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5934 p->ifunc = is_ifunc;
5950 /* Merge backend specific data from an object file to the output
5951 object file when linking. */
5954 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5956 unsigned long iflags, oflags;
5958 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5961 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5964 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5967 iflags = elf_elfheader (ibfd)->e_flags;
5968 oflags = elf_elfheader (obfd)->e_flags;
5970 if (iflags & ~EF_PPC64_ABI)
5972 (*_bfd_error_handler)
5973 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5974 bfd_set_error (bfd_error_bad_value);
5977 else if (iflags != oflags && iflags != 0)
5979 (*_bfd_error_handler)
5980 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5981 ibfd, iflags, oflags);
5982 bfd_set_error (bfd_error_bad_value);
5986 /* Merge Tag_compatibility attributes and any common GNU ones. */
5987 _bfd_elf_merge_object_attributes (ibfd, obfd);
5993 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5995 /* Print normal ELF private data. */
5996 _bfd_elf_print_private_bfd_data (abfd, ptr);
5998 if (elf_elfheader (abfd)->e_flags != 0)
6002 /* xgettext:c-format */
6003 fprintf (file, _("private flags = 0x%lx:"),
6004 elf_elfheader (abfd)->e_flags);
6006 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6007 fprintf (file, _(" [abiv%ld]"),
6008 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6015 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6016 of the code entry point, and its section, which must be in the same
6017 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6020 opd_entry_value (asection *opd_sec,
6022 asection **code_sec,
6024 bfd_boolean in_code_sec)
6026 bfd *opd_bfd = opd_sec->owner;
6027 Elf_Internal_Rela *relocs;
6028 Elf_Internal_Rela *lo, *hi, *look;
6031 /* No relocs implies we are linking a --just-symbols object, or looking
6032 at a final linked executable with addr2line or somesuch. */
6033 if (opd_sec->reloc_count == 0)
6035 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6037 if (contents == NULL)
6039 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6040 return (bfd_vma) -1;
6041 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6044 /* PR 17512: file: 64b9dfbb. */
6045 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6046 return (bfd_vma) -1;
6048 val = bfd_get_64 (opd_bfd, contents + offset);
6049 if (code_sec != NULL)
6051 asection *sec, *likely = NULL;
6057 && val < sec->vma + sec->size)
6063 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6065 && (sec->flags & SEC_LOAD) != 0
6066 && (sec->flags & SEC_ALLOC) != 0)
6071 if (code_off != NULL)
6072 *code_off = val - likely->vma;
6078 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6080 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6082 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6083 /* PR 17512: file: df8e1fd6. */
6085 return (bfd_vma) -1;
6087 /* Go find the opd reloc at the sym address. */
6089 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6093 look = lo + (hi - lo) / 2;
6094 if (look->r_offset < offset)
6096 else if (look->r_offset > offset)
6100 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6102 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6103 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6105 unsigned long symndx = ELF64_R_SYM (look->r_info);
6106 asection *sec = NULL;
6108 if (symndx >= symtab_hdr->sh_info
6109 && elf_sym_hashes (opd_bfd) != NULL)
6111 struct elf_link_hash_entry **sym_hashes;
6112 struct elf_link_hash_entry *rh;
6114 sym_hashes = elf_sym_hashes (opd_bfd);
6115 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6118 rh = elf_follow_link (rh);
6119 if (rh->root.type != bfd_link_hash_defined
6120 && rh->root.type != bfd_link_hash_defweak)
6122 if (rh->root.u.def.section->owner == opd_bfd)
6124 val = rh->root.u.def.value;
6125 sec = rh->root.u.def.section;
6132 Elf_Internal_Sym *sym;
6134 if (symndx < symtab_hdr->sh_info)
6136 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6139 size_t symcnt = symtab_hdr->sh_info;
6140 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6145 symtab_hdr->contents = (bfd_byte *) sym;
6151 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6157 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6160 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6161 val = sym->st_value;
6164 val += look->r_addend;
6165 if (code_off != NULL)
6167 if (code_sec != NULL)
6169 if (in_code_sec && *code_sec != sec)
6174 if (sec->output_section != NULL)
6175 val += sec->output_section->vma + sec->output_offset;
6184 /* If the ELF symbol SYM might be a function in SEC, return the
6185 function size and set *CODE_OFF to the function's entry point,
6186 otherwise return zero. */
6188 static bfd_size_type
6189 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6194 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6195 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6199 if (!(sym->flags & BSF_SYNTHETIC))
6200 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6202 if (strcmp (sym->section->name, ".opd") == 0)
6204 struct _opd_sec_data *opd = get_opd_info (sym->section);
6205 bfd_vma symval = sym->value;
6208 && opd->adjust != NULL
6209 && elf_section_data (sym->section)->relocs != NULL)
6211 /* opd_entry_value will use cached relocs that have been
6212 adjusted, but with raw symbols. That means both local
6213 and global symbols need adjusting. */
6214 long adjust = opd->adjust[OPD_NDX (symval)];
6220 if (opd_entry_value (sym->section, symval,
6221 &sec, code_off, TRUE) == (bfd_vma) -1)
6223 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6224 symbol. This size has nothing to do with the code size of the
6225 function, which is what we're supposed to return, but the
6226 code size isn't available without looking up the dot-sym.
6227 However, doing that would be a waste of time particularly
6228 since elf_find_function will look at the dot-sym anyway.
6229 Now, elf_find_function will keep the largest size of any
6230 function sym found at the code address of interest, so return
6231 1 here to avoid it incorrectly caching a larger function size
6232 for a small function. This does mean we return the wrong
6233 size for a new-ABI function of size 24, but all that does is
6234 disable caching for such functions. */
6240 if (sym->section != sec)
6242 *code_off = sym->value;
6249 /* Return true if symbol is defined in a regular object file. */
6252 is_static_defined (struct elf_link_hash_entry *h)
6254 return ((h->root.type == bfd_link_hash_defined
6255 || h->root.type == bfd_link_hash_defweak)
6256 && h->root.u.def.section != NULL
6257 && h->root.u.def.section->output_section != NULL);
6260 /* If FDH is a function descriptor symbol, return the associated code
6261 entry symbol if it is defined. Return NULL otherwise. */
6263 static struct ppc_link_hash_entry *
6264 defined_code_entry (struct ppc_link_hash_entry *fdh)
6266 if (fdh->is_func_descriptor)
6268 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6269 if (fh->elf.root.type == bfd_link_hash_defined
6270 || fh->elf.root.type == bfd_link_hash_defweak)
6276 /* If FH is a function code entry symbol, return the associated
6277 function descriptor symbol if it is defined. Return NULL otherwise. */
6279 static struct ppc_link_hash_entry *
6280 defined_func_desc (struct ppc_link_hash_entry *fh)
6283 && fh->oh->is_func_descriptor)
6285 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6286 if (fdh->elf.root.type == bfd_link_hash_defined
6287 || fdh->elf.root.type == bfd_link_hash_defweak)
6293 /* Mark all our entry sym sections, both opd and code section. */
6296 ppc64_elf_gc_keep (struct bfd_link_info *info)
6298 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6299 struct bfd_sym_chain *sym;
6304 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6306 struct ppc_link_hash_entry *eh, *fh;
6309 eh = (struct ppc_link_hash_entry *)
6310 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6313 if (eh->elf.root.type != bfd_link_hash_defined
6314 && eh->elf.root.type != bfd_link_hash_defweak)
6317 fh = defined_code_entry (eh);
6320 sec = fh->elf.root.u.def.section;
6321 sec->flags |= SEC_KEEP;
6323 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6324 && opd_entry_value (eh->elf.root.u.def.section,
6325 eh->elf.root.u.def.value,
6326 &sec, NULL, FALSE) != (bfd_vma) -1)
6327 sec->flags |= SEC_KEEP;
6329 sec = eh->elf.root.u.def.section;
6330 sec->flags |= SEC_KEEP;
6334 /* Mark sections containing dynamically referenced symbols. When
6335 building shared libraries, we must assume that any visible symbol is
6339 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6341 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6342 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6343 struct ppc_link_hash_entry *fdh;
6344 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6346 /* Dynamic linking info is on the func descriptor sym. */
6347 fdh = defined_func_desc (eh);
6351 if ((eh->elf.root.type == bfd_link_hash_defined
6352 || eh->elf.root.type == bfd_link_hash_defweak)
6353 && (eh->elf.ref_dynamic
6354 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6355 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6356 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6357 && (!bfd_link_executable (info)
6358 || info->export_dynamic
6361 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6362 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6363 || !bfd_hide_sym_by_version (info->version_info,
6364 eh->elf.root.root.string)))))
6367 struct ppc_link_hash_entry *fh;
6369 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6371 /* Function descriptor syms cause the associated
6372 function code sym section to be marked. */
6373 fh = defined_code_entry (eh);
6376 code_sec = fh->elf.root.u.def.section;
6377 code_sec->flags |= SEC_KEEP;
6379 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6380 && opd_entry_value (eh->elf.root.u.def.section,
6381 eh->elf.root.u.def.value,
6382 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6383 code_sec->flags |= SEC_KEEP;
6389 /* Return the section that should be marked against GC for a given
6393 ppc64_elf_gc_mark_hook (asection *sec,
6394 struct bfd_link_info *info,
6395 Elf_Internal_Rela *rel,
6396 struct elf_link_hash_entry *h,
6397 Elf_Internal_Sym *sym)
6401 /* Syms return NULL if we're marking .opd, so we avoid marking all
6402 function sections, as all functions are referenced in .opd. */
6404 if (get_opd_info (sec) != NULL)
6409 enum elf_ppc64_reloc_type r_type;
6410 struct ppc_link_hash_entry *eh, *fh, *fdh;
6412 r_type = ELF64_R_TYPE (rel->r_info);
6415 case R_PPC64_GNU_VTINHERIT:
6416 case R_PPC64_GNU_VTENTRY:
6420 switch (h->root.type)
6422 case bfd_link_hash_defined:
6423 case bfd_link_hash_defweak:
6424 eh = (struct ppc_link_hash_entry *) h;
6425 fdh = defined_func_desc (eh);
6429 /* Function descriptor syms cause the associated
6430 function code sym section to be marked. */
6431 fh = defined_code_entry (eh);
6434 /* They also mark their opd section. */
6435 eh->elf.root.u.def.section->gc_mark = 1;
6437 rsec = fh->elf.root.u.def.section;
6439 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6440 && opd_entry_value (eh->elf.root.u.def.section,
6441 eh->elf.root.u.def.value,
6442 &rsec, NULL, FALSE) != (bfd_vma) -1)
6443 eh->elf.root.u.def.section->gc_mark = 1;
6445 rsec = h->root.u.def.section;
6448 case bfd_link_hash_common:
6449 rsec = h->root.u.c.p->section;
6453 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6459 struct _opd_sec_data *opd;
6461 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6462 opd = get_opd_info (rsec);
6463 if (opd != NULL && opd->func_sec != NULL)
6467 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6474 /* Update the .got, .plt. and dynamic reloc reference counts for the
6475 section being removed. */
6478 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6479 asection *sec, const Elf_Internal_Rela *relocs)
6481 struct ppc_link_hash_table *htab;
6482 Elf_Internal_Shdr *symtab_hdr;
6483 struct elf_link_hash_entry **sym_hashes;
6484 struct got_entry **local_got_ents;
6485 const Elf_Internal_Rela *rel, *relend;
6487 if (bfd_link_relocatable (info))
6490 if ((sec->flags & SEC_ALLOC) == 0)
6493 elf_section_data (sec)->local_dynrel = NULL;
6495 htab = ppc_hash_table (info);
6499 symtab_hdr = &elf_symtab_hdr (abfd);
6500 sym_hashes = elf_sym_hashes (abfd);
6501 local_got_ents = elf_local_got_ents (abfd);
6503 relend = relocs + sec->reloc_count;
6504 for (rel = relocs; rel < relend; rel++)
6506 unsigned long r_symndx;
6507 enum elf_ppc64_reloc_type r_type;
6508 struct elf_link_hash_entry *h = NULL;
6509 struct plt_entry **plt_list;
6510 unsigned char tls_type = 0;
6512 r_symndx = ELF64_R_SYM (rel->r_info);
6513 r_type = ELF64_R_TYPE (rel->r_info);
6514 if (r_symndx >= symtab_hdr->sh_info)
6516 struct ppc_link_hash_entry *eh;
6517 struct elf_dyn_relocs **pp;
6518 struct elf_dyn_relocs *p;
6520 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6521 h = elf_follow_link (h);
6522 eh = (struct ppc_link_hash_entry *) h;
6524 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6527 /* Everything must go for SEC. */
6535 case R_PPC64_GOT_TLSLD16:
6536 case R_PPC64_GOT_TLSLD16_LO:
6537 case R_PPC64_GOT_TLSLD16_HI:
6538 case R_PPC64_GOT_TLSLD16_HA:
6539 tls_type = TLS_TLS | TLS_LD;
6542 case R_PPC64_GOT_TLSGD16:
6543 case R_PPC64_GOT_TLSGD16_LO:
6544 case R_PPC64_GOT_TLSGD16_HI:
6545 case R_PPC64_GOT_TLSGD16_HA:
6546 tls_type = TLS_TLS | TLS_GD;
6549 case R_PPC64_GOT_TPREL16_DS:
6550 case R_PPC64_GOT_TPREL16_LO_DS:
6551 case R_PPC64_GOT_TPREL16_HI:
6552 case R_PPC64_GOT_TPREL16_HA:
6553 tls_type = TLS_TLS | TLS_TPREL;
6556 case R_PPC64_GOT_DTPREL16_DS:
6557 case R_PPC64_GOT_DTPREL16_LO_DS:
6558 case R_PPC64_GOT_DTPREL16_HI:
6559 case R_PPC64_GOT_DTPREL16_HA:
6560 tls_type = TLS_TLS | TLS_DTPREL;
6564 case R_PPC64_GOT16_DS:
6565 case R_PPC64_GOT16_HA:
6566 case R_PPC64_GOT16_HI:
6567 case R_PPC64_GOT16_LO:
6568 case R_PPC64_GOT16_LO_DS:
6571 struct got_entry *ent;
6576 ent = local_got_ents[r_symndx];
6578 for (; ent != NULL; ent = ent->next)
6579 if (ent->addend == rel->r_addend
6580 && ent->owner == abfd
6581 && ent->tls_type == tls_type)
6585 if (ent->got.refcount > 0)
6586 ent->got.refcount -= 1;
6590 case R_PPC64_PLT16_HA:
6591 case R_PPC64_PLT16_HI:
6592 case R_PPC64_PLT16_LO:
6596 case R_PPC64_REL14_BRNTAKEN:
6597 case R_PPC64_REL14_BRTAKEN:
6601 plt_list = &h->plt.plist;
6602 else if (local_got_ents != NULL)
6604 struct plt_entry **local_plt = (struct plt_entry **)
6605 (local_got_ents + symtab_hdr->sh_info);
6606 unsigned char *local_got_tls_masks = (unsigned char *)
6607 (local_plt + symtab_hdr->sh_info);
6608 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6609 plt_list = local_plt + r_symndx;
6613 struct plt_entry *ent;
6615 for (ent = *plt_list; ent != NULL; ent = ent->next)
6616 if (ent->addend == rel->r_addend)
6618 if (ent != NULL && ent->plt.refcount > 0)
6619 ent->plt.refcount -= 1;
6630 /* The maximum size of .sfpr. */
6631 #define SFPR_MAX (218*4)
6633 struct sfpr_def_parms
6635 const char name[12];
6636 unsigned char lo, hi;
6637 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6638 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6641 /* Auto-generate _save*, _rest* functions in .sfpr.
6642 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6646 sfpr_define (struct bfd_link_info *info,
6647 const struct sfpr_def_parms *parm,
6650 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6652 size_t len = strlen (parm->name);
6653 bfd_boolean writing = FALSE;
6659 memcpy (sym, parm->name, len);
6662 for (i = parm->lo; i <= parm->hi; i++)
6664 struct ppc_link_hash_entry *h;
6666 sym[len + 0] = i / 10 + '0';
6667 sym[len + 1] = i % 10 + '0';
6668 h = (struct ppc_link_hash_entry *)
6669 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6670 if (stub_sec != NULL)
6673 && h->elf.root.type == bfd_link_hash_defined
6674 && h->elf.root.u.def.section == htab->sfpr)
6676 struct elf_link_hash_entry *s;
6678 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6679 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6682 if (s->root.type == bfd_link_hash_new
6683 || (s->root.type = bfd_link_hash_defined
6684 && s->root.u.def.section == stub_sec))
6686 s->root.type = bfd_link_hash_defined;
6687 s->root.u.def.section = stub_sec;
6688 s->root.u.def.value = (stub_sec->size
6689 + h->elf.root.u.def.value);
6692 s->ref_regular_nonweak = 1;
6693 s->forced_local = 1;
6695 s->root.linker_def = 1;
6703 if (!h->elf.def_regular)
6705 h->elf.root.type = bfd_link_hash_defined;
6706 h->elf.root.u.def.section = htab->sfpr;
6707 h->elf.root.u.def.value = htab->sfpr->size;
6708 h->elf.type = STT_FUNC;
6709 h->elf.def_regular = 1;
6711 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6713 if (htab->sfpr->contents == NULL)
6715 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6716 if (htab->sfpr->contents == NULL)
6723 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6725 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6727 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6728 htab->sfpr->size = p - htab->sfpr->contents;
6736 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6738 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6743 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6745 p = savegpr0 (abfd, p, r);
6746 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6748 bfd_put_32 (abfd, BLR, p);
6753 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6755 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6760 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6762 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6764 p = restgpr0 (abfd, p, r);
6765 bfd_put_32 (abfd, MTLR_R0, p);
6769 p = restgpr0 (abfd, p, 30);
6770 p = restgpr0 (abfd, p, 31);
6772 bfd_put_32 (abfd, BLR, p);
6777 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6779 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6784 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6786 p = savegpr1 (abfd, p, r);
6787 bfd_put_32 (abfd, BLR, p);
6792 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6794 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6799 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6801 p = restgpr1 (abfd, p, r);
6802 bfd_put_32 (abfd, BLR, p);
6807 savefpr (bfd *abfd, bfd_byte *p, int r)
6809 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6814 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6816 p = savefpr (abfd, p, r);
6817 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6819 bfd_put_32 (abfd, BLR, p);
6824 restfpr (bfd *abfd, bfd_byte *p, int r)
6826 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6831 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6833 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6835 p = restfpr (abfd, p, r);
6836 bfd_put_32 (abfd, MTLR_R0, p);
6840 p = restfpr (abfd, p, 30);
6841 p = restfpr (abfd, p, 31);
6843 bfd_put_32 (abfd, BLR, p);
6848 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6850 p = savefpr (abfd, p, r);
6851 bfd_put_32 (abfd, BLR, p);
6856 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6858 p = restfpr (abfd, p, r);
6859 bfd_put_32 (abfd, BLR, p);
6864 savevr (bfd *abfd, bfd_byte *p, int r)
6866 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6868 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6873 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6875 p = savevr (abfd, p, r);
6876 bfd_put_32 (abfd, BLR, p);
6881 restvr (bfd *abfd, bfd_byte *p, int r)
6883 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6885 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6890 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6892 p = restvr (abfd, p, r);
6893 bfd_put_32 (abfd, BLR, p);
6897 /* Called via elf_link_hash_traverse to transfer dynamic linking
6898 information on function code symbol entries to their corresponding
6899 function descriptor symbol entries. */
6902 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6904 struct bfd_link_info *info;
6905 struct ppc_link_hash_table *htab;
6906 struct plt_entry *ent;
6907 struct ppc_link_hash_entry *fh;
6908 struct ppc_link_hash_entry *fdh;
6909 bfd_boolean force_local;
6911 fh = (struct ppc_link_hash_entry *) h;
6912 if (fh->elf.root.type == bfd_link_hash_indirect)
6916 htab = ppc_hash_table (info);
6920 /* Resolve undefined references to dot-symbols as the value
6921 in the function descriptor, if we have one in a regular object.
6922 This is to satisfy cases like ".quad .foo". Calls to functions
6923 in dynamic objects are handled elsewhere. */
6924 if (fh->elf.root.type == bfd_link_hash_undefweak
6925 && fh->was_undefined
6926 && (fdh = defined_func_desc (fh)) != NULL
6927 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6928 && opd_entry_value (fdh->elf.root.u.def.section,
6929 fdh->elf.root.u.def.value,
6930 &fh->elf.root.u.def.section,
6931 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6933 fh->elf.root.type = fdh->elf.root.type;
6934 fh->elf.forced_local = 1;
6935 fh->elf.def_regular = fdh->elf.def_regular;
6936 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6939 /* If this is a function code symbol, transfer dynamic linking
6940 information to the function descriptor symbol. */
6944 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6945 if (ent->plt.refcount > 0)
6948 || fh->elf.root.root.string[0] != '.'
6949 || fh->elf.root.root.string[1] == '\0')
6952 /* Find the corresponding function descriptor symbol. Create it
6953 as undefined if necessary. */
6955 fdh = lookup_fdh (fh, htab);
6957 && !bfd_link_executable (info)
6958 && (fh->elf.root.type == bfd_link_hash_undefined
6959 || fh->elf.root.type == bfd_link_hash_undefweak))
6961 fdh = make_fdh (info, fh);
6966 /* Fake function descriptors are made undefweak. If the function
6967 code symbol is strong undefined, make the fake sym the same.
6968 If the function code symbol is defined, then force the fake
6969 descriptor local; We can't support overriding of symbols in a
6970 shared library on a fake descriptor. */
6974 && fdh->elf.root.type == bfd_link_hash_undefweak)
6976 if (fh->elf.root.type == bfd_link_hash_undefined)
6978 fdh->elf.root.type = bfd_link_hash_undefined;
6979 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6981 else if (fh->elf.root.type == bfd_link_hash_defined
6982 || fh->elf.root.type == bfd_link_hash_defweak)
6984 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6989 && !fdh->elf.forced_local
6990 && (!bfd_link_executable (info)
6991 || fdh->elf.def_dynamic
6992 || fdh->elf.ref_dynamic
6993 || (fdh->elf.root.type == bfd_link_hash_undefweak
6994 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6996 if (fdh->elf.dynindx == -1)
6997 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6999 fdh->elf.ref_regular |= fh->elf.ref_regular;
7000 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7001 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7002 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7003 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7005 move_plt_plist (fh, fdh);
7006 fdh->elf.needs_plt = 1;
7008 fdh->is_func_descriptor = 1;
7013 /* Now that the info is on the function descriptor, clear the
7014 function code sym info. Any function code syms for which we
7015 don't have a definition in a regular file, we force local.
7016 This prevents a shared library from exporting syms that have
7017 been imported from another library. Function code syms that
7018 are really in the library we must leave global to prevent the
7019 linker dragging in a definition from a static library. */
7020 force_local = (!fh->elf.def_regular
7022 || !fdh->elf.def_regular
7023 || fdh->elf.forced_local);
7024 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7029 static const struct sfpr_def_parms save_res_funcs[] =
7031 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7032 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7033 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7034 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7035 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7036 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7037 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7038 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7039 { "._savef", 14, 31, savefpr, savefpr1_tail },
7040 { "._restf", 14, 31, restfpr, restfpr1_tail },
7041 { "_savevr_", 20, 31, savevr, savevr_tail },
7042 { "_restvr_", 20, 31, restvr, restvr_tail }
7045 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7046 this hook to a) provide some gcc support functions, and b) transfer
7047 dynamic linking information gathered so far on function code symbol
7048 entries, to their corresponding function descriptor symbol entries. */
7051 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7052 struct bfd_link_info *info)
7054 struct ppc_link_hash_table *htab;
7056 htab = ppc_hash_table (info);
7060 /* Provide any missing _save* and _rest* functions. */
7061 if (htab->sfpr != NULL)
7065 htab->sfpr->size = 0;
7066 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7067 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7069 if (htab->sfpr->size == 0)
7070 htab->sfpr->flags |= SEC_EXCLUDE;
7073 if (bfd_link_relocatable (info))
7076 if (htab->elf.hgot != NULL)
7078 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7079 /* Make .TOC. defined so as to prevent it being made dynamic.
7080 The wrong value here is fixed later in ppc64_elf_set_toc. */
7081 if (!htab->elf.hgot->def_regular
7082 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7084 htab->elf.hgot->root.type = bfd_link_hash_defined;
7085 htab->elf.hgot->root.u.def.value = 0;
7086 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7087 htab->elf.hgot->def_regular = 1;
7088 htab->elf.hgot->root.linker_def = 1;
7090 htab->elf.hgot->type = STT_OBJECT;
7091 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7095 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7100 /* Return true if we have dynamic relocs that apply to read-only sections. */
7103 readonly_dynrelocs (struct elf_link_hash_entry *h)
7105 struct ppc_link_hash_entry *eh;
7106 struct elf_dyn_relocs *p;
7108 eh = (struct ppc_link_hash_entry *) h;
7109 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7111 asection *s = p->sec->output_section;
7113 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7119 /* Adjust a symbol defined by a dynamic object and referenced by a
7120 regular object. The current definition is in some section of the
7121 dynamic object, but we're not including those sections. We have to
7122 change the definition to something the rest of the link can
7126 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7127 struct elf_link_hash_entry *h)
7129 struct ppc_link_hash_table *htab;
7132 htab = ppc_hash_table (info);
7136 /* Deal with function syms. */
7137 if (h->type == STT_FUNC
7138 || h->type == STT_GNU_IFUNC
7141 /* Clear procedure linkage table information for any symbol that
7142 won't need a .plt entry. */
7143 struct plt_entry *ent;
7144 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7145 if (ent->plt.refcount > 0)
7148 || (h->type != STT_GNU_IFUNC
7149 && (SYMBOL_CALLS_LOCAL (info, h)
7150 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7151 && h->root.type == bfd_link_hash_undefweak)))
7152 || ((struct ppc_link_hash_entry *) h)->save_res)
7154 h->plt.plist = NULL;
7156 h->pointer_equality_needed = 0;
7158 else if (abiversion (info->output_bfd) == 2)
7160 /* Taking a function's address in a read/write section
7161 doesn't require us to define the function symbol in the
7162 executable on a global entry stub. A dynamic reloc can
7164 if (h->pointer_equality_needed
7165 && h->type != STT_GNU_IFUNC
7166 && !readonly_dynrelocs (h))
7168 h->pointer_equality_needed = 0;
7172 /* After adjust_dynamic_symbol, non_got_ref set in the
7173 non-shared case means that we have allocated space in
7174 .dynbss for the symbol and thus dyn_relocs for this
7175 symbol should be discarded.
7176 If we get here we know we are making a PLT entry for this
7177 symbol, and in an executable we'd normally resolve
7178 relocations against this symbol to the PLT entry. Allow
7179 dynamic relocs if the reference is weak, and the dynamic
7180 relocs will not cause text relocation. */
7181 else if (!h->ref_regular_nonweak
7183 && h->type != STT_GNU_IFUNC
7184 && !readonly_dynrelocs (h))
7187 /* If making a plt entry, then we don't need copy relocs. */
7192 h->plt.plist = NULL;
7194 /* If this is a weak symbol, and there is a real definition, the
7195 processor independent code will have arranged for us to see the
7196 real definition first, and we can just use the same value. */
7197 if (h->u.weakdef != NULL)
7199 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7200 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7201 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7202 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7203 if (ELIMINATE_COPY_RELOCS)
7204 h->non_got_ref = h->u.weakdef->non_got_ref;
7208 /* If we are creating a shared library, we must presume that the
7209 only references to the symbol are via the global offset table.
7210 For such cases we need not do anything here; the relocations will
7211 be handled correctly by relocate_section. */
7212 if (bfd_link_pic (info))
7215 /* If there are no references to this symbol that do not use the
7216 GOT, we don't need to generate a copy reloc. */
7217 if (!h->non_got_ref)
7220 /* Don't generate a copy reloc for symbols defined in the executable. */
7221 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7224 /* If -z nocopyreloc was given, don't generate them either. */
7225 if (info->nocopyreloc)
7231 /* If we didn't find any dynamic relocs in read-only sections, then
7232 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7233 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7239 /* Protected variables do not work with .dynbss. The copy in
7240 .dynbss won't be used by the shared library with the protected
7241 definition for the variable. Text relocations are preferable
7242 to an incorrect program. */
7243 if (h->protected_def)
7249 if (h->plt.plist != NULL)
7251 /* We should never get here, but unfortunately there are versions
7252 of gcc out there that improperly (for this ABI) put initialized
7253 function pointers, vtable refs and suchlike in read-only
7254 sections. Allow them to proceed, but warn that this might
7255 break at runtime. */
7256 info->callbacks->einfo
7257 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7258 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7259 h->root.root.string);
7262 /* This is a reference to a symbol defined by a dynamic object which
7263 is not a function. */
7265 /* We must allocate the symbol in our .dynbss section, which will
7266 become part of the .bss section of the executable. There will be
7267 an entry for this symbol in the .dynsym section. The dynamic
7268 object will contain position independent code, so all references
7269 from the dynamic object to this symbol will go through the global
7270 offset table. The dynamic linker will use the .dynsym entry to
7271 determine the address it must put in the global offset table, so
7272 both the dynamic object and the regular object will refer to the
7273 same memory location for the variable. */
7275 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7276 to copy the initial value out of the dynamic object and into the
7277 runtime process image. We need to remember the offset into the
7278 .rela.bss section we are going to use. */
7279 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7281 htab->relbss->size += sizeof (Elf64_External_Rela);
7287 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7290 /* If given a function descriptor symbol, hide both the function code
7291 sym and the descriptor. */
7293 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7294 struct elf_link_hash_entry *h,
7295 bfd_boolean force_local)
7297 struct ppc_link_hash_entry *eh;
7298 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7300 eh = (struct ppc_link_hash_entry *) h;
7301 if (eh->is_func_descriptor)
7303 struct ppc_link_hash_entry *fh = eh->oh;
7308 struct ppc_link_hash_table *htab;
7311 /* We aren't supposed to use alloca in BFD because on
7312 systems which do not have alloca the version in libiberty
7313 calls xmalloc, which might cause the program to crash
7314 when it runs out of memory. This function doesn't have a
7315 return status, so there's no way to gracefully return an
7316 error. So cheat. We know that string[-1] can be safely
7317 accessed; It's either a string in an ELF string table,
7318 or allocated in an objalloc structure. */
7320 p = eh->elf.root.root.string - 1;
7323 htab = ppc_hash_table (info);
7327 fh = (struct ppc_link_hash_entry *)
7328 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7331 /* Unfortunately, if it so happens that the string we were
7332 looking for was allocated immediately before this string,
7333 then we overwrote the string terminator. That's the only
7334 reason the lookup should fail. */
7337 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7338 while (q >= eh->elf.root.root.string && *q == *p)
7340 if (q < eh->elf.root.root.string && *p == '.')
7341 fh = (struct ppc_link_hash_entry *)
7342 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7351 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7356 get_sym_h (struct elf_link_hash_entry **hp,
7357 Elf_Internal_Sym **symp,
7359 unsigned char **tls_maskp,
7360 Elf_Internal_Sym **locsymsp,
7361 unsigned long r_symndx,
7364 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7366 if (r_symndx >= symtab_hdr->sh_info)
7368 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7369 struct elf_link_hash_entry *h;
7371 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7372 h = elf_follow_link (h);
7380 if (symsecp != NULL)
7382 asection *symsec = NULL;
7383 if (h->root.type == bfd_link_hash_defined
7384 || h->root.type == bfd_link_hash_defweak)
7385 symsec = h->root.u.def.section;
7389 if (tls_maskp != NULL)
7391 struct ppc_link_hash_entry *eh;
7393 eh = (struct ppc_link_hash_entry *) h;
7394 *tls_maskp = &eh->tls_mask;
7399 Elf_Internal_Sym *sym;
7400 Elf_Internal_Sym *locsyms = *locsymsp;
7402 if (locsyms == NULL)
7404 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7405 if (locsyms == NULL)
7406 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7407 symtab_hdr->sh_info,
7408 0, NULL, NULL, NULL);
7409 if (locsyms == NULL)
7411 *locsymsp = locsyms;
7413 sym = locsyms + r_symndx;
7421 if (symsecp != NULL)
7422 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7424 if (tls_maskp != NULL)
7426 struct got_entry **lgot_ents;
7427 unsigned char *tls_mask;
7430 lgot_ents = elf_local_got_ents (ibfd);
7431 if (lgot_ents != NULL)
7433 struct plt_entry **local_plt = (struct plt_entry **)
7434 (lgot_ents + symtab_hdr->sh_info);
7435 unsigned char *lgot_masks = (unsigned char *)
7436 (local_plt + symtab_hdr->sh_info);
7437 tls_mask = &lgot_masks[r_symndx];
7439 *tls_maskp = tls_mask;
7445 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7446 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7447 type suitable for optimization, and 1 otherwise. */
7450 get_tls_mask (unsigned char **tls_maskp,
7451 unsigned long *toc_symndx,
7452 bfd_vma *toc_addend,
7453 Elf_Internal_Sym **locsymsp,
7454 const Elf_Internal_Rela *rel,
7457 unsigned long r_symndx;
7459 struct elf_link_hash_entry *h;
7460 Elf_Internal_Sym *sym;
7464 r_symndx = ELF64_R_SYM (rel->r_info);
7465 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7468 if ((*tls_maskp != NULL && **tls_maskp != 0)
7470 || ppc64_elf_section_data (sec) == NULL
7471 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7474 /* Look inside a TOC section too. */
7477 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7478 off = h->root.u.def.value;
7481 off = sym->st_value;
7482 off += rel->r_addend;
7483 BFD_ASSERT (off % 8 == 0);
7484 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7485 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7486 if (toc_symndx != NULL)
7487 *toc_symndx = r_symndx;
7488 if (toc_addend != NULL)
7489 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7490 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7492 if ((h == NULL || is_static_defined (h))
7493 && (next_r == -1 || next_r == -2))
7498 /* Find (or create) an entry in the tocsave hash table. */
7500 static struct tocsave_entry *
7501 tocsave_find (struct ppc_link_hash_table *htab,
7502 enum insert_option insert,
7503 Elf_Internal_Sym **local_syms,
7504 const Elf_Internal_Rela *irela,
7507 unsigned long r_indx;
7508 struct elf_link_hash_entry *h;
7509 Elf_Internal_Sym *sym;
7510 struct tocsave_entry ent, *p;
7512 struct tocsave_entry **slot;
7514 r_indx = ELF64_R_SYM (irela->r_info);
7515 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7517 if (ent.sec == NULL || ent.sec->output_section == NULL)
7519 (*_bfd_error_handler)
7520 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7525 ent.offset = h->root.u.def.value;
7527 ent.offset = sym->st_value;
7528 ent.offset += irela->r_addend;
7530 hash = tocsave_htab_hash (&ent);
7531 slot = ((struct tocsave_entry **)
7532 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7538 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7547 /* Adjust all global syms defined in opd sections. In gcc generated
7548 code for the old ABI, these will already have been done. */
7551 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7553 struct ppc_link_hash_entry *eh;
7555 struct _opd_sec_data *opd;
7557 if (h->root.type == bfd_link_hash_indirect)
7560 if (h->root.type != bfd_link_hash_defined
7561 && h->root.type != bfd_link_hash_defweak)
7564 eh = (struct ppc_link_hash_entry *) h;
7565 if (eh->adjust_done)
7568 sym_sec = eh->elf.root.u.def.section;
7569 opd = get_opd_info (sym_sec);
7570 if (opd != NULL && opd->adjust != NULL)
7572 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7575 /* This entry has been deleted. */
7576 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7579 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7580 if (discarded_section (dsec))
7582 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7586 eh->elf.root.u.def.value = 0;
7587 eh->elf.root.u.def.section = dsec;
7590 eh->elf.root.u.def.value += adjust;
7591 eh->adjust_done = 1;
7596 /* Handles decrementing dynamic reloc counts for the reloc specified by
7597 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7598 have already been determined. */
7601 dec_dynrel_count (bfd_vma r_info,
7603 struct bfd_link_info *info,
7604 Elf_Internal_Sym **local_syms,
7605 struct elf_link_hash_entry *h,
7606 Elf_Internal_Sym *sym)
7608 enum elf_ppc64_reloc_type r_type;
7609 asection *sym_sec = NULL;
7611 /* Can this reloc be dynamic? This switch, and later tests here
7612 should be kept in sync with the code in check_relocs. */
7613 r_type = ELF64_R_TYPE (r_info);
7619 case R_PPC64_TPREL16:
7620 case R_PPC64_TPREL16_LO:
7621 case R_PPC64_TPREL16_HI:
7622 case R_PPC64_TPREL16_HA:
7623 case R_PPC64_TPREL16_DS:
7624 case R_PPC64_TPREL16_LO_DS:
7625 case R_PPC64_TPREL16_HIGH:
7626 case R_PPC64_TPREL16_HIGHA:
7627 case R_PPC64_TPREL16_HIGHER:
7628 case R_PPC64_TPREL16_HIGHERA:
7629 case R_PPC64_TPREL16_HIGHEST:
7630 case R_PPC64_TPREL16_HIGHESTA:
7631 if (!bfd_link_pic (info))
7634 case R_PPC64_TPREL64:
7635 case R_PPC64_DTPMOD64:
7636 case R_PPC64_DTPREL64:
7637 case R_PPC64_ADDR64:
7641 case R_PPC64_ADDR14:
7642 case R_PPC64_ADDR14_BRNTAKEN:
7643 case R_PPC64_ADDR14_BRTAKEN:
7644 case R_PPC64_ADDR16:
7645 case R_PPC64_ADDR16_DS:
7646 case R_PPC64_ADDR16_HA:
7647 case R_PPC64_ADDR16_HI:
7648 case R_PPC64_ADDR16_HIGH:
7649 case R_PPC64_ADDR16_HIGHA:
7650 case R_PPC64_ADDR16_HIGHER:
7651 case R_PPC64_ADDR16_HIGHERA:
7652 case R_PPC64_ADDR16_HIGHEST:
7653 case R_PPC64_ADDR16_HIGHESTA:
7654 case R_PPC64_ADDR16_LO:
7655 case R_PPC64_ADDR16_LO_DS:
7656 case R_PPC64_ADDR24:
7657 case R_PPC64_ADDR32:
7658 case R_PPC64_UADDR16:
7659 case R_PPC64_UADDR32:
7660 case R_PPC64_UADDR64:
7665 if (local_syms != NULL)
7667 unsigned long r_symndx;
7668 bfd *ibfd = sec->owner;
7670 r_symndx = ELF64_R_SYM (r_info);
7671 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7675 if ((bfd_link_pic (info)
7676 && (must_be_dyn_reloc (info, r_type)
7678 && (!SYMBOLIC_BIND (info, h)
7679 || h->root.type == bfd_link_hash_defweak
7680 || !h->def_regular))))
7681 || (ELIMINATE_COPY_RELOCS
7682 && !bfd_link_pic (info)
7684 && (h->root.type == bfd_link_hash_defweak
7685 || !h->def_regular)))
7692 struct elf_dyn_relocs *p;
7693 struct elf_dyn_relocs **pp;
7694 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7696 /* elf_gc_sweep may have already removed all dyn relocs associated
7697 with local syms for a given section. Also, symbol flags are
7698 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7699 report a dynreloc miscount. */
7700 if (*pp == NULL && info->gc_sections)
7703 while ((p = *pp) != NULL)
7707 if (!must_be_dyn_reloc (info, r_type))
7719 struct ppc_dyn_relocs *p;
7720 struct ppc_dyn_relocs **pp;
7722 bfd_boolean is_ifunc;
7724 if (local_syms == NULL)
7725 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7726 if (sym_sec == NULL)
7729 vpp = &elf_section_data (sym_sec)->local_dynrel;
7730 pp = (struct ppc_dyn_relocs **) vpp;
7732 if (*pp == NULL && info->gc_sections)
7735 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7736 while ((p = *pp) != NULL)
7738 if (p->sec == sec && p->ifunc == is_ifunc)
7749 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7751 bfd_set_error (bfd_error_bad_value);
7755 /* Remove unused Official Procedure Descriptor entries. Currently we
7756 only remove those associated with functions in discarded link-once
7757 sections, or weakly defined functions that have been overridden. It
7758 would be possible to remove many more entries for statically linked
7762 ppc64_elf_edit_opd (struct bfd_link_info *info)
7765 bfd_boolean some_edited = FALSE;
7766 asection *need_pad = NULL;
7767 struct ppc_link_hash_table *htab;
7769 htab = ppc_hash_table (info);
7773 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7776 Elf_Internal_Rela *relstart, *rel, *relend;
7777 Elf_Internal_Shdr *symtab_hdr;
7778 Elf_Internal_Sym *local_syms;
7779 struct _opd_sec_data *opd;
7780 bfd_boolean need_edit, add_aux_fields, broken;
7781 bfd_size_type cnt_16b = 0;
7783 if (!is_ppc64_elf (ibfd))
7786 sec = bfd_get_section_by_name (ibfd, ".opd");
7787 if (sec == NULL || sec->size == 0)
7790 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7793 if (sec->output_section == bfd_abs_section_ptr)
7796 /* Look through the section relocs. */
7797 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7801 symtab_hdr = &elf_symtab_hdr (ibfd);
7803 /* Read the relocations. */
7804 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7806 if (relstart == NULL)
7809 /* First run through the relocs to check they are sane, and to
7810 determine whether we need to edit this opd section. */
7814 relend = relstart + sec->reloc_count;
7815 for (rel = relstart; rel < relend; )
7817 enum elf_ppc64_reloc_type r_type;
7818 unsigned long r_symndx;
7820 struct elf_link_hash_entry *h;
7821 Elf_Internal_Sym *sym;
7824 /* .opd contains an array of 16 or 24 byte entries. We're
7825 only interested in the reloc pointing to a function entry
7827 offset = rel->r_offset;
7828 if (rel + 1 == relend
7829 || rel[1].r_offset != offset + 8)
7831 /* If someone messes with .opd alignment then after a
7832 "ld -r" we might have padding in the middle of .opd.
7833 Also, there's nothing to prevent someone putting
7834 something silly in .opd with the assembler. No .opd
7835 optimization for them! */
7837 (*_bfd_error_handler)
7838 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7843 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7844 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7846 (*_bfd_error_handler)
7847 (_("%B: unexpected reloc type %u in .opd section"),
7853 r_symndx = ELF64_R_SYM (rel->r_info);
7854 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7858 if (sym_sec == NULL || sym_sec->owner == NULL)
7860 const char *sym_name;
7862 sym_name = h->root.root.string;
7864 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7867 (*_bfd_error_handler)
7868 (_("%B: undefined sym `%s' in .opd section"),
7874 /* opd entries are always for functions defined in the
7875 current input bfd. If the symbol isn't defined in the
7876 input bfd, then we won't be using the function in this
7877 bfd; It must be defined in a linkonce section in another
7878 bfd, or is weak. It's also possible that we are
7879 discarding the function due to a linker script /DISCARD/,
7880 which we test for via the output_section. */
7881 if (sym_sec->owner != ibfd
7882 || sym_sec->output_section == bfd_abs_section_ptr)
7886 if (rel + 1 == relend
7887 || (rel + 2 < relend
7888 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7893 if (sec->size == offset + 24)
7898 if (sec->size == offset + 16)
7905 else if (rel + 1 < relend
7906 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7907 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7909 if (rel[0].r_offset == offset + 16)
7911 else if (rel[0].r_offset != offset + 24)
7918 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7920 if (!broken && (need_edit || add_aux_fields))
7922 Elf_Internal_Rela *write_rel;
7923 Elf_Internal_Shdr *rel_hdr;
7924 bfd_byte *rptr, *wptr;
7925 bfd_byte *new_contents;
7928 new_contents = NULL;
7929 amt = OPD_NDX (sec->size) * sizeof (long);
7930 opd = &ppc64_elf_section_data (sec)->u.opd;
7931 opd->adjust = bfd_zalloc (sec->owner, amt);
7932 if (opd->adjust == NULL)
7934 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7936 /* This seems a waste of time as input .opd sections are all
7937 zeros as generated by gcc, but I suppose there's no reason
7938 this will always be so. We might start putting something in
7939 the third word of .opd entries. */
7940 if ((sec->flags & SEC_IN_MEMORY) == 0)
7943 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7948 if (local_syms != NULL
7949 && symtab_hdr->contents != (unsigned char *) local_syms)
7951 if (elf_section_data (sec)->relocs != relstart)
7955 sec->contents = loc;
7956 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7959 elf_section_data (sec)->relocs = relstart;
7961 new_contents = sec->contents;
7964 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7965 if (new_contents == NULL)
7969 wptr = new_contents;
7970 rptr = sec->contents;
7971 write_rel = relstart;
7972 for (rel = relstart; rel < relend; )
7974 unsigned long r_symndx;
7976 struct elf_link_hash_entry *h;
7977 struct ppc_link_hash_entry *fdh = NULL;
7978 Elf_Internal_Sym *sym;
7980 Elf_Internal_Rela *next_rel;
7983 r_symndx = ELF64_R_SYM (rel->r_info);
7984 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7989 if (next_rel + 1 == relend
7990 || (next_rel + 2 < relend
7991 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7994 /* See if the .opd entry is full 24 byte or
7995 16 byte (with fd_aux entry overlapped with next
7998 if (next_rel == relend)
8000 if (sec->size == rel->r_offset + 16)
8003 else if (next_rel->r_offset == rel->r_offset + 16)
8007 && h->root.root.string[0] == '.')
8009 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8011 && fdh->elf.root.type != bfd_link_hash_defined
8012 && fdh->elf.root.type != bfd_link_hash_defweak)
8016 skip = (sym_sec->owner != ibfd
8017 || sym_sec->output_section == bfd_abs_section_ptr);
8020 if (fdh != NULL && sym_sec->owner == ibfd)
8022 /* Arrange for the function descriptor sym
8024 fdh->elf.root.u.def.value = 0;
8025 fdh->elf.root.u.def.section = sym_sec;
8027 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8029 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8034 if (!dec_dynrel_count (rel->r_info, sec, info,
8038 if (++rel == next_rel)
8041 r_symndx = ELF64_R_SYM (rel->r_info);
8042 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8049 /* We'll be keeping this opd entry. */
8054 /* Redefine the function descriptor symbol to
8055 this location in the opd section. It is
8056 necessary to update the value here rather
8057 than using an array of adjustments as we do
8058 for local symbols, because various places
8059 in the generic ELF code use the value
8060 stored in u.def.value. */
8061 fdh->elf.root.u.def.value = wptr - new_contents;
8062 fdh->adjust_done = 1;
8065 /* Local syms are a bit tricky. We could
8066 tweak them as they can be cached, but
8067 we'd need to look through the local syms
8068 for the function descriptor sym which we
8069 don't have at the moment. So keep an
8070 array of adjustments. */
8071 adjust = (wptr - new_contents) - (rptr - sec->contents);
8072 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8075 memcpy (wptr, rptr, opd_ent_size);
8076 wptr += opd_ent_size;
8077 if (add_aux_fields && opd_ent_size == 16)
8079 memset (wptr, '\0', 8);
8083 /* We need to adjust any reloc offsets to point to the
8085 for ( ; rel != next_rel; ++rel)
8087 rel->r_offset += adjust;
8088 if (write_rel != rel)
8089 memcpy (write_rel, rel, sizeof (*rel));
8094 rptr += opd_ent_size;
8097 sec->size = wptr - new_contents;
8098 sec->reloc_count = write_rel - relstart;
8101 free (sec->contents);
8102 sec->contents = new_contents;
8105 /* Fudge the header size too, as this is used later in
8106 elf_bfd_final_link if we are emitting relocs. */
8107 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8108 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8111 else if (elf_section_data (sec)->relocs != relstart)
8114 if (local_syms != NULL
8115 && symtab_hdr->contents != (unsigned char *) local_syms)
8117 if (!info->keep_memory)
8120 symtab_hdr->contents = (unsigned char *) local_syms;
8125 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8127 /* If we are doing a final link and the last .opd entry is just 16 byte
8128 long, add a 8 byte padding after it. */
8129 if (need_pad != NULL && !bfd_link_relocatable (info))
8133 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8135 BFD_ASSERT (need_pad->size > 0);
8137 p = bfd_malloc (need_pad->size + 8);
8141 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8142 p, 0, need_pad->size))
8145 need_pad->contents = p;
8146 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8150 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8154 need_pad->contents = p;
8157 memset (need_pad->contents + need_pad->size, 0, 8);
8158 need_pad->size += 8;
8164 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8167 ppc64_elf_tls_setup (struct bfd_link_info *info)
8169 struct ppc_link_hash_table *htab;
8171 htab = ppc_hash_table (info);
8175 if (abiversion (info->output_bfd) == 1)
8178 if (htab->params->no_multi_toc)
8179 htab->do_multi_toc = 0;
8180 else if (!htab->do_multi_toc)
8181 htab->params->no_multi_toc = 1;
8183 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8184 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8185 FALSE, FALSE, TRUE));
8186 /* Move dynamic linking info to the function descriptor sym. */
8187 if (htab->tls_get_addr != NULL)
8188 func_desc_adjust (&htab->tls_get_addr->elf, info);
8189 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8190 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8191 FALSE, FALSE, TRUE));
8192 if (htab->params->tls_get_addr_opt)
8194 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8196 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8197 FALSE, FALSE, TRUE);
8199 func_desc_adjust (opt, info);
8200 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8201 FALSE, FALSE, TRUE);
8203 && (opt_fd->root.type == bfd_link_hash_defined
8204 || opt_fd->root.type == bfd_link_hash_defweak))
8206 /* If glibc supports an optimized __tls_get_addr call stub,
8207 signalled by the presence of __tls_get_addr_opt, and we'll
8208 be calling __tls_get_addr via a plt call stub, then
8209 make __tls_get_addr point to __tls_get_addr_opt. */
8210 tga_fd = &htab->tls_get_addr_fd->elf;
8211 if (htab->elf.dynamic_sections_created
8213 && (tga_fd->type == STT_FUNC
8214 || tga_fd->needs_plt)
8215 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8216 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8217 && tga_fd->root.type == bfd_link_hash_undefweak)))
8219 struct plt_entry *ent;
8221 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8222 if (ent->plt.refcount > 0)
8226 tga_fd->root.type = bfd_link_hash_indirect;
8227 tga_fd->root.u.i.link = &opt_fd->root;
8228 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8229 opt_fd->forced_local = 0;
8230 if (opt_fd->dynindx != -1)
8232 /* Use __tls_get_addr_opt in dynamic relocations. */
8233 opt_fd->dynindx = -1;
8234 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8235 opt_fd->dynstr_index);
8236 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8239 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8240 tga = &htab->tls_get_addr->elf;
8241 if (opt != NULL && tga != NULL)
8243 tga->root.type = bfd_link_hash_indirect;
8244 tga->root.u.i.link = &opt->root;
8245 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8246 opt->forced_local = 0;
8247 _bfd_elf_link_hash_hide_symbol (info, opt,
8249 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8251 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8252 htab->tls_get_addr_fd->is_func_descriptor = 1;
8253 if (htab->tls_get_addr != NULL)
8255 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8256 htab->tls_get_addr->is_func = 1;
8261 else if (htab->params->tls_get_addr_opt < 0)
8262 htab->params->tls_get_addr_opt = 0;
8264 return _bfd_elf_tls_setup (info->output_bfd, info);
8267 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8271 branch_reloc_hash_match (const bfd *ibfd,
8272 const Elf_Internal_Rela *rel,
8273 const struct ppc_link_hash_entry *hash1,
8274 const struct ppc_link_hash_entry *hash2)
8276 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8277 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8278 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8280 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8282 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8283 struct elf_link_hash_entry *h;
8285 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8286 h = elf_follow_link (h);
8287 if (h == &hash1->elf || h == &hash2->elf)
8293 /* Run through all the TLS relocs looking for optimization
8294 opportunities. The linker has been hacked (see ppc64elf.em) to do
8295 a preliminary section layout so that we know the TLS segment
8296 offsets. We can't optimize earlier because some optimizations need
8297 to know the tp offset, and we need to optimize before allocating
8298 dynamic relocations. */
8301 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8305 struct ppc_link_hash_table *htab;
8306 unsigned char *toc_ref;
8309 if (!bfd_link_executable (info))
8312 htab = ppc_hash_table (info);
8316 /* Make two passes over the relocs. On the first pass, mark toc
8317 entries involved with tls relocs, and check that tls relocs
8318 involved in setting up a tls_get_addr call are indeed followed by
8319 such a call. If they are not, we can't do any tls optimization.
8320 On the second pass twiddle tls_mask flags to notify
8321 relocate_section that optimization can be done, and adjust got
8322 and plt refcounts. */
8324 for (pass = 0; pass < 2; ++pass)
8325 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8327 Elf_Internal_Sym *locsyms = NULL;
8328 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8330 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8331 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8333 Elf_Internal_Rela *relstart, *rel, *relend;
8334 bfd_boolean found_tls_get_addr_arg = 0;
8336 /* Read the relocations. */
8337 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8339 if (relstart == NULL)
8345 relend = relstart + sec->reloc_count;
8346 for (rel = relstart; rel < relend; rel++)
8348 enum elf_ppc64_reloc_type r_type;
8349 unsigned long r_symndx;
8350 struct elf_link_hash_entry *h;
8351 Elf_Internal_Sym *sym;
8353 unsigned char *tls_mask;
8354 unsigned char tls_set, tls_clear, tls_type = 0;
8356 bfd_boolean ok_tprel, is_local;
8357 long toc_ref_index = 0;
8358 int expecting_tls_get_addr = 0;
8359 bfd_boolean ret = FALSE;
8361 r_symndx = ELF64_R_SYM (rel->r_info);
8362 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8366 if (elf_section_data (sec)->relocs != relstart)
8368 if (toc_ref != NULL)
8371 && (elf_symtab_hdr (ibfd).contents
8372 != (unsigned char *) locsyms))
8379 if (h->root.type == bfd_link_hash_defined
8380 || h->root.type == bfd_link_hash_defweak)
8381 value = h->root.u.def.value;
8382 else if (h->root.type == bfd_link_hash_undefweak)
8386 found_tls_get_addr_arg = 0;
8391 /* Symbols referenced by TLS relocs must be of type
8392 STT_TLS. So no need for .opd local sym adjust. */
8393 value = sym->st_value;
8402 && h->root.type == bfd_link_hash_undefweak)
8404 else if (sym_sec != NULL
8405 && sym_sec->output_section != NULL)
8407 value += sym_sec->output_offset;
8408 value += sym_sec->output_section->vma;
8409 value -= htab->elf.tls_sec->vma;
8410 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8411 < (bfd_vma) 1 << 32);
8415 r_type = ELF64_R_TYPE (rel->r_info);
8416 /* If this section has old-style __tls_get_addr calls
8417 without marker relocs, then check that each
8418 __tls_get_addr call reloc is preceded by a reloc
8419 that conceivably belongs to the __tls_get_addr arg
8420 setup insn. If we don't find matching arg setup
8421 relocs, don't do any tls optimization. */
8423 && sec->has_tls_get_addr_call
8425 && (h == &htab->tls_get_addr->elf
8426 || h == &htab->tls_get_addr_fd->elf)
8427 && !found_tls_get_addr_arg
8428 && is_branch_reloc (r_type))
8430 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8431 "TLS optimization disabled\n"),
8432 ibfd, sec, rel->r_offset);
8437 found_tls_get_addr_arg = 0;
8440 case R_PPC64_GOT_TLSLD16:
8441 case R_PPC64_GOT_TLSLD16_LO:
8442 expecting_tls_get_addr = 1;
8443 found_tls_get_addr_arg = 1;
8446 case R_PPC64_GOT_TLSLD16_HI:
8447 case R_PPC64_GOT_TLSLD16_HA:
8448 /* These relocs should never be against a symbol
8449 defined in a shared lib. Leave them alone if
8450 that turns out to be the case. */
8457 tls_type = TLS_TLS | TLS_LD;
8460 case R_PPC64_GOT_TLSGD16:
8461 case R_PPC64_GOT_TLSGD16_LO:
8462 expecting_tls_get_addr = 1;
8463 found_tls_get_addr_arg = 1;
8466 case R_PPC64_GOT_TLSGD16_HI:
8467 case R_PPC64_GOT_TLSGD16_HA:
8473 tls_set = TLS_TLS | TLS_TPRELGD;
8475 tls_type = TLS_TLS | TLS_GD;
8478 case R_PPC64_GOT_TPREL16_DS:
8479 case R_PPC64_GOT_TPREL16_LO_DS:
8480 case R_PPC64_GOT_TPREL16_HI:
8481 case R_PPC64_GOT_TPREL16_HA:
8486 tls_clear = TLS_TPREL;
8487 tls_type = TLS_TLS | TLS_TPREL;
8494 found_tls_get_addr_arg = 1;
8499 case R_PPC64_TOC16_LO:
8500 if (sym_sec == NULL || sym_sec != toc)
8503 /* Mark this toc entry as referenced by a TLS
8504 code sequence. We can do that now in the
8505 case of R_PPC64_TLS, and after checking for
8506 tls_get_addr for the TOC16 relocs. */
8507 if (toc_ref == NULL)
8508 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8509 if (toc_ref == NULL)
8513 value = h->root.u.def.value;
8515 value = sym->st_value;
8516 value += rel->r_addend;
8519 BFD_ASSERT (value < toc->size
8520 && toc->output_offset % 8 == 0);
8521 toc_ref_index = (value + toc->output_offset) / 8;
8522 if (r_type == R_PPC64_TLS
8523 || r_type == R_PPC64_TLSGD
8524 || r_type == R_PPC64_TLSLD)
8526 toc_ref[toc_ref_index] = 1;
8530 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8535 expecting_tls_get_addr = 2;
8538 case R_PPC64_TPREL64:
8542 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8547 tls_set = TLS_EXPLICIT;
8548 tls_clear = TLS_TPREL;
8553 case R_PPC64_DTPMOD64:
8557 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8559 if (rel + 1 < relend
8561 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8562 && rel[1].r_offset == rel->r_offset + 8)
8566 tls_set = TLS_EXPLICIT | TLS_GD;
8569 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8578 tls_set = TLS_EXPLICIT;
8589 if (!expecting_tls_get_addr
8590 || !sec->has_tls_get_addr_call)
8593 if (rel + 1 < relend
8594 && branch_reloc_hash_match (ibfd, rel + 1,
8596 htab->tls_get_addr_fd))
8598 if (expecting_tls_get_addr == 2)
8600 /* Check for toc tls entries. */
8601 unsigned char *toc_tls;
8604 retval = get_tls_mask (&toc_tls, NULL, NULL,
8609 if (toc_tls != NULL)
8611 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8612 found_tls_get_addr_arg = 1;
8614 toc_ref[toc_ref_index] = 1;
8620 if (expecting_tls_get_addr != 1)
8623 /* Uh oh, we didn't find the expected call. We
8624 could just mark this symbol to exclude it
8625 from tls optimization but it's safer to skip
8626 the entire optimization. */
8627 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8628 "TLS optimization disabled\n"),
8629 ibfd, sec, rel->r_offset);
8634 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8636 struct plt_entry *ent;
8637 for (ent = htab->tls_get_addr->elf.plt.plist;
8640 if (ent->addend == 0)
8642 if (ent->plt.refcount > 0)
8644 ent->plt.refcount -= 1;
8645 expecting_tls_get_addr = 0;
8651 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8653 struct plt_entry *ent;
8654 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8657 if (ent->addend == 0)
8659 if (ent->plt.refcount > 0)
8660 ent->plt.refcount -= 1;
8668 if ((tls_set & TLS_EXPLICIT) == 0)
8670 struct got_entry *ent;
8672 /* Adjust got entry for this reloc. */
8676 ent = elf_local_got_ents (ibfd)[r_symndx];
8678 for (; ent != NULL; ent = ent->next)
8679 if (ent->addend == rel->r_addend
8680 && ent->owner == ibfd
8681 && ent->tls_type == tls_type)
8688 /* We managed to get rid of a got entry. */
8689 if (ent->got.refcount > 0)
8690 ent->got.refcount -= 1;
8695 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8696 we'll lose one or two dyn relocs. */
8697 if (!dec_dynrel_count (rel->r_info, sec, info,
8701 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8703 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8709 *tls_mask |= tls_set;
8710 *tls_mask &= ~tls_clear;
8713 if (elf_section_data (sec)->relocs != relstart)
8718 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8720 if (!info->keep_memory)
8723 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8727 if (toc_ref != NULL)
8732 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8733 the values of any global symbols in a toc section that has been
8734 edited. Globals in toc sections should be a rarity, so this function
8735 sets a flag if any are found in toc sections other than the one just
8736 edited, so that futher hash table traversals can be avoided. */
8738 struct adjust_toc_info
8741 unsigned long *skip;
8742 bfd_boolean global_toc_syms;
8745 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8748 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8750 struct ppc_link_hash_entry *eh;
8751 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8754 if (h->root.type != bfd_link_hash_defined
8755 && h->root.type != bfd_link_hash_defweak)
8758 eh = (struct ppc_link_hash_entry *) h;
8759 if (eh->adjust_done)
8762 if (eh->elf.root.u.def.section == toc_inf->toc)
8764 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8765 i = toc_inf->toc->rawsize >> 3;
8767 i = eh->elf.root.u.def.value >> 3;
8769 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8771 (*_bfd_error_handler)
8772 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8775 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8776 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8779 eh->elf.root.u.def.value -= toc_inf->skip[i];
8780 eh->adjust_done = 1;
8782 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8783 toc_inf->global_toc_syms = TRUE;
8788 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8791 ok_lo_toc_insn (unsigned int insn)
8793 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8794 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8795 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8796 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8797 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8798 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8799 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8800 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8801 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8802 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8803 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8804 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8805 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8806 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8807 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8809 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8810 && ((insn & 3) == 0 || (insn & 3) == 3))
8811 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8814 /* Examine all relocs referencing .toc sections in order to remove
8815 unused .toc entries. */
8818 ppc64_elf_edit_toc (struct bfd_link_info *info)
8821 struct adjust_toc_info toc_inf;
8822 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8824 htab->do_toc_opt = 1;
8825 toc_inf.global_toc_syms = TRUE;
8826 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8828 asection *toc, *sec;
8829 Elf_Internal_Shdr *symtab_hdr;
8830 Elf_Internal_Sym *local_syms;
8831 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8832 unsigned long *skip, *drop;
8833 unsigned char *used;
8834 unsigned char *keep, last, some_unused;
8836 if (!is_ppc64_elf (ibfd))
8839 toc = bfd_get_section_by_name (ibfd, ".toc");
8842 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8843 || discarded_section (toc))
8848 symtab_hdr = &elf_symtab_hdr (ibfd);
8850 /* Look at sections dropped from the final link. */
8853 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8855 if (sec->reloc_count == 0
8856 || !discarded_section (sec)
8857 || get_opd_info (sec)
8858 || (sec->flags & SEC_ALLOC) == 0
8859 || (sec->flags & SEC_DEBUGGING) != 0)
8862 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8863 if (relstart == NULL)
8866 /* Run through the relocs to see which toc entries might be
8868 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8870 enum elf_ppc64_reloc_type r_type;
8871 unsigned long r_symndx;
8873 struct elf_link_hash_entry *h;
8874 Elf_Internal_Sym *sym;
8877 r_type = ELF64_R_TYPE (rel->r_info);
8884 case R_PPC64_TOC16_LO:
8885 case R_PPC64_TOC16_HI:
8886 case R_PPC64_TOC16_HA:
8887 case R_PPC64_TOC16_DS:
8888 case R_PPC64_TOC16_LO_DS:
8892 r_symndx = ELF64_R_SYM (rel->r_info);
8893 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8901 val = h->root.u.def.value;
8903 val = sym->st_value;
8904 val += rel->r_addend;
8906 if (val >= toc->size)
8909 /* Anything in the toc ought to be aligned to 8 bytes.
8910 If not, don't mark as unused. */
8916 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8921 skip[val >> 3] = ref_from_discarded;
8924 if (elf_section_data (sec)->relocs != relstart)
8928 /* For largetoc loads of address constants, we can convert
8929 . addis rx,2,addr@got@ha
8930 . ld ry,addr@got@l(rx)
8932 . addis rx,2,addr@toc@ha
8933 . addi ry,rx,addr@toc@l
8934 when addr is within 2G of the toc pointer. This then means
8935 that the word storing "addr" in the toc is no longer needed. */
8937 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8938 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8939 && toc->reloc_count != 0)
8941 /* Read toc relocs. */
8942 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8944 if (toc_relocs == NULL)
8947 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8949 enum elf_ppc64_reloc_type r_type;
8950 unsigned long r_symndx;
8952 struct elf_link_hash_entry *h;
8953 Elf_Internal_Sym *sym;
8956 r_type = ELF64_R_TYPE (rel->r_info);
8957 if (r_type != R_PPC64_ADDR64)
8960 r_symndx = ELF64_R_SYM (rel->r_info);
8961 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8966 || sym_sec->output_section == NULL
8967 || discarded_section (sym_sec))
8970 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8975 if (h->type == STT_GNU_IFUNC)
8977 val = h->root.u.def.value;
8981 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8983 val = sym->st_value;
8985 val += rel->r_addend;
8986 val += sym_sec->output_section->vma + sym_sec->output_offset;
8988 /* We don't yet know the exact toc pointer value, but we
8989 know it will be somewhere in the toc section. Don't
8990 optimize if the difference from any possible toc
8991 pointer is outside [ff..f80008000, 7fff7fff]. */
8992 addr = toc->output_section->vma + TOC_BASE_OFF;
8993 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8996 addr = toc->output_section->vma + toc->output_section->rawsize;
8997 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9002 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9007 skip[rel->r_offset >> 3]
9008 |= can_optimize | ((rel - toc_relocs) << 2);
9015 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9019 if (local_syms != NULL
9020 && symtab_hdr->contents != (unsigned char *) local_syms)
9024 && elf_section_data (sec)->relocs != relstart)
9026 if (toc_relocs != NULL
9027 && elf_section_data (toc)->relocs != toc_relocs)
9034 /* Now check all kept sections that might reference the toc.
9035 Check the toc itself last. */
9036 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9039 sec = (sec == toc ? NULL
9040 : sec->next == NULL ? toc
9041 : sec->next == toc && toc->next ? toc->next
9046 if (sec->reloc_count == 0
9047 || discarded_section (sec)
9048 || get_opd_info (sec)
9049 || (sec->flags & SEC_ALLOC) == 0
9050 || (sec->flags & SEC_DEBUGGING) != 0)
9053 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9055 if (relstart == NULL)
9061 /* Mark toc entries referenced as used. */
9065 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9067 enum elf_ppc64_reloc_type r_type;
9068 unsigned long r_symndx;
9070 struct elf_link_hash_entry *h;
9071 Elf_Internal_Sym *sym;
9073 enum {no_check, check_lo, check_ha} insn_check;
9075 r_type = ELF64_R_TYPE (rel->r_info);
9079 insn_check = no_check;
9082 case R_PPC64_GOT_TLSLD16_HA:
9083 case R_PPC64_GOT_TLSGD16_HA:
9084 case R_PPC64_GOT_TPREL16_HA:
9085 case R_PPC64_GOT_DTPREL16_HA:
9086 case R_PPC64_GOT16_HA:
9087 case R_PPC64_TOC16_HA:
9088 insn_check = check_ha;
9091 case R_PPC64_GOT_TLSLD16_LO:
9092 case R_PPC64_GOT_TLSGD16_LO:
9093 case R_PPC64_GOT_TPREL16_LO_DS:
9094 case R_PPC64_GOT_DTPREL16_LO_DS:
9095 case R_PPC64_GOT16_LO:
9096 case R_PPC64_GOT16_LO_DS:
9097 case R_PPC64_TOC16_LO:
9098 case R_PPC64_TOC16_LO_DS:
9099 insn_check = check_lo;
9103 if (insn_check != no_check)
9105 bfd_vma off = rel->r_offset & ~3;
9106 unsigned char buf[4];
9109 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9114 insn = bfd_get_32 (ibfd, buf);
9115 if (insn_check == check_lo
9116 ? !ok_lo_toc_insn (insn)
9117 : ((insn & ((0x3f << 26) | 0x1f << 16))
9118 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9122 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9123 sprintf (str, "%#08x", insn);
9124 info->callbacks->einfo
9125 (_("%P: %H: toc optimization is not supported for"
9126 " %s instruction.\n"),
9127 ibfd, sec, rel->r_offset & ~3, str);
9134 case R_PPC64_TOC16_LO:
9135 case R_PPC64_TOC16_HI:
9136 case R_PPC64_TOC16_HA:
9137 case R_PPC64_TOC16_DS:
9138 case R_PPC64_TOC16_LO_DS:
9139 /* In case we're taking addresses of toc entries. */
9140 case R_PPC64_ADDR64:
9147 r_symndx = ELF64_R_SYM (rel->r_info);
9148 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9159 val = h->root.u.def.value;
9161 val = sym->st_value;
9162 val += rel->r_addend;
9164 if (val >= toc->size)
9167 if ((skip[val >> 3] & can_optimize) != 0)
9174 case R_PPC64_TOC16_HA:
9177 case R_PPC64_TOC16_LO_DS:
9178 off = rel->r_offset;
9179 off += (bfd_big_endian (ibfd) ? -2 : 3);
9180 if (!bfd_get_section_contents (ibfd, sec, &opc,
9186 if ((opc & (0x3f << 2)) == (58u << 2))
9191 /* Wrong sort of reloc, or not a ld. We may
9192 as well clear ref_from_discarded too. */
9199 /* For the toc section, we only mark as used if this
9200 entry itself isn't unused. */
9201 else if ((used[rel->r_offset >> 3]
9202 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9205 /* Do all the relocs again, to catch reference
9214 if (elf_section_data (sec)->relocs != relstart)
9218 /* Merge the used and skip arrays. Assume that TOC
9219 doublewords not appearing as either used or unused belong
9220 to to an entry more than one doubleword in size. */
9221 for (drop = skip, keep = used, last = 0, some_unused = 0;
9222 drop < skip + (toc->size + 7) / 8;
9227 *drop &= ~ref_from_discarded;
9228 if ((*drop & can_optimize) != 0)
9232 else if ((*drop & ref_from_discarded) != 0)
9235 last = ref_from_discarded;
9245 bfd_byte *contents, *src;
9247 Elf_Internal_Sym *sym;
9248 bfd_boolean local_toc_syms = FALSE;
9250 /* Shuffle the toc contents, and at the same time convert the
9251 skip array from booleans into offsets. */
9252 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9255 elf_section_data (toc)->this_hdr.contents = contents;
9257 for (src = contents, off = 0, drop = skip;
9258 src < contents + toc->size;
9261 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9266 memcpy (src - off, src, 8);
9270 toc->rawsize = toc->size;
9271 toc->size = src - contents - off;
9273 /* Adjust addends for relocs against the toc section sym,
9274 and optimize any accesses we can. */
9275 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9277 if (sec->reloc_count == 0
9278 || discarded_section (sec))
9281 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9283 if (relstart == NULL)
9286 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9288 enum elf_ppc64_reloc_type r_type;
9289 unsigned long r_symndx;
9291 struct elf_link_hash_entry *h;
9294 r_type = ELF64_R_TYPE (rel->r_info);
9301 case R_PPC64_TOC16_LO:
9302 case R_PPC64_TOC16_HI:
9303 case R_PPC64_TOC16_HA:
9304 case R_PPC64_TOC16_DS:
9305 case R_PPC64_TOC16_LO_DS:
9306 case R_PPC64_ADDR64:
9310 r_symndx = ELF64_R_SYM (rel->r_info);
9311 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9319 val = h->root.u.def.value;
9322 val = sym->st_value;
9324 local_toc_syms = TRUE;
9327 val += rel->r_addend;
9329 if (val > toc->rawsize)
9331 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9333 else if ((skip[val >> 3] & can_optimize) != 0)
9335 Elf_Internal_Rela *tocrel
9336 = toc_relocs + (skip[val >> 3] >> 2);
9337 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9341 case R_PPC64_TOC16_HA:
9342 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9345 case R_PPC64_TOC16_LO_DS:
9346 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9350 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9352 info->callbacks->einfo
9353 (_("%P: %H: %s references "
9354 "optimized away TOC entry\n"),
9355 ibfd, sec, rel->r_offset,
9356 ppc64_elf_howto_table[r_type]->name);
9357 bfd_set_error (bfd_error_bad_value);
9360 rel->r_addend = tocrel->r_addend;
9361 elf_section_data (sec)->relocs = relstart;
9365 if (h != NULL || sym->st_value != 0)
9368 rel->r_addend -= skip[val >> 3];
9369 elf_section_data (sec)->relocs = relstart;
9372 if (elf_section_data (sec)->relocs != relstart)
9376 /* We shouldn't have local or global symbols defined in the TOC,
9377 but handle them anyway. */
9378 if (local_syms != NULL)
9379 for (sym = local_syms;
9380 sym < local_syms + symtab_hdr->sh_info;
9382 if (sym->st_value != 0
9383 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9387 if (sym->st_value > toc->rawsize)
9388 i = toc->rawsize >> 3;
9390 i = sym->st_value >> 3;
9392 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9395 (*_bfd_error_handler)
9396 (_("%s defined on removed toc entry"),
9397 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9400 while ((skip[i] & (ref_from_discarded | can_optimize)));
9401 sym->st_value = (bfd_vma) i << 3;
9404 sym->st_value -= skip[i];
9405 symtab_hdr->contents = (unsigned char *) local_syms;
9408 /* Adjust any global syms defined in this toc input section. */
9409 if (toc_inf.global_toc_syms)
9412 toc_inf.skip = skip;
9413 toc_inf.global_toc_syms = FALSE;
9414 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9418 if (toc->reloc_count != 0)
9420 Elf_Internal_Shdr *rel_hdr;
9421 Elf_Internal_Rela *wrel;
9424 /* Remove unused toc relocs, and adjust those we keep. */
9425 if (toc_relocs == NULL)
9426 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9428 if (toc_relocs == NULL)
9432 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9433 if ((skip[rel->r_offset >> 3]
9434 & (ref_from_discarded | can_optimize)) == 0)
9436 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9437 wrel->r_info = rel->r_info;
9438 wrel->r_addend = rel->r_addend;
9441 else if (!dec_dynrel_count (rel->r_info, toc, info,
9442 &local_syms, NULL, NULL))
9445 elf_section_data (toc)->relocs = toc_relocs;
9446 toc->reloc_count = wrel - toc_relocs;
9447 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9448 sz = rel_hdr->sh_entsize;
9449 rel_hdr->sh_size = toc->reloc_count * sz;
9452 else if (toc_relocs != NULL
9453 && elf_section_data (toc)->relocs != toc_relocs)
9456 if (local_syms != NULL
9457 && symtab_hdr->contents != (unsigned char *) local_syms)
9459 if (!info->keep_memory)
9462 symtab_hdr->contents = (unsigned char *) local_syms;
9470 /* Return true iff input section I references the TOC using
9471 instructions limited to +/-32k offsets. */
9474 ppc64_elf_has_small_toc_reloc (asection *i)
9476 return (is_ppc64_elf (i->owner)
9477 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9480 /* Allocate space for one GOT entry. */
9483 allocate_got (struct elf_link_hash_entry *h,
9484 struct bfd_link_info *info,
9485 struct got_entry *gent)
9487 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9489 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9490 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9492 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9493 ? 2 : 1) * sizeof (Elf64_External_Rela);
9494 asection *got = ppc64_elf_tdata (gent->owner)->got;
9496 gent->got.offset = got->size;
9497 got->size += entsize;
9499 dyn = htab->elf.dynamic_sections_created;
9500 if (h->type == STT_GNU_IFUNC)
9502 htab->elf.irelplt->size += rentsize;
9503 htab->got_reli_size += rentsize;
9505 else if ((bfd_link_pic (info)
9506 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9507 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9508 || h->root.type != bfd_link_hash_undefweak))
9510 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9511 relgot->size += rentsize;
9515 /* This function merges got entries in the same toc group. */
9518 merge_got_entries (struct got_entry **pent)
9520 struct got_entry *ent, *ent2;
9522 for (ent = *pent; ent != NULL; ent = ent->next)
9523 if (!ent->is_indirect)
9524 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9525 if (!ent2->is_indirect
9526 && ent2->addend == ent->addend
9527 && ent2->tls_type == ent->tls_type
9528 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9530 ent2->is_indirect = TRUE;
9531 ent2->got.ent = ent;
9535 /* Allocate space in .plt, .got and associated reloc sections for
9539 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9541 struct bfd_link_info *info;
9542 struct ppc_link_hash_table *htab;
9544 struct ppc_link_hash_entry *eh;
9545 struct elf_dyn_relocs *p;
9546 struct got_entry **pgent, *gent;
9548 if (h->root.type == bfd_link_hash_indirect)
9551 info = (struct bfd_link_info *) inf;
9552 htab = ppc_hash_table (info);
9556 eh = (struct ppc_link_hash_entry *) h;
9557 /* Run through the TLS GD got entries first if we're changing them
9559 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9560 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9561 if (gent->got.refcount > 0
9562 && (gent->tls_type & TLS_GD) != 0)
9564 /* This was a GD entry that has been converted to TPREL. If
9565 there happens to be a TPREL entry we can use that one. */
9566 struct got_entry *ent;
9567 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9568 if (ent->got.refcount > 0
9569 && (ent->tls_type & TLS_TPREL) != 0
9570 && ent->addend == gent->addend
9571 && ent->owner == gent->owner)
9573 gent->got.refcount = 0;
9577 /* If not, then we'll be using our own TPREL entry. */
9578 if (gent->got.refcount != 0)
9579 gent->tls_type = TLS_TLS | TLS_TPREL;
9582 /* Remove any list entry that won't generate a word in the GOT before
9583 we call merge_got_entries. Otherwise we risk merging to empty
9585 pgent = &h->got.glist;
9586 while ((gent = *pgent) != NULL)
9587 if (gent->got.refcount > 0)
9589 if ((gent->tls_type & TLS_LD) != 0
9592 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9593 *pgent = gent->next;
9596 pgent = &gent->next;
9599 *pgent = gent->next;
9601 if (!htab->do_multi_toc)
9602 merge_got_entries (&h->got.glist);
9604 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9605 if (!gent->is_indirect)
9607 /* Make sure this symbol is output as a dynamic symbol.
9608 Undefined weak syms won't yet be marked as dynamic,
9609 nor will all TLS symbols. */
9610 if (h->dynindx == -1
9612 && h->type != STT_GNU_IFUNC
9613 && htab->elf.dynamic_sections_created)
9615 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9619 if (!is_ppc64_elf (gent->owner))
9622 allocate_got (h, info, gent);
9625 if (eh->dyn_relocs != NULL
9626 && (htab->elf.dynamic_sections_created
9627 || h->type == STT_GNU_IFUNC))
9629 /* In the shared -Bsymbolic case, discard space allocated for
9630 dynamic pc-relative relocs against symbols which turn out to
9631 be defined in regular objects. For the normal shared case,
9632 discard space for relocs that have become local due to symbol
9633 visibility changes. */
9635 if (bfd_link_pic (info))
9637 /* Relocs that use pc_count are those that appear on a call
9638 insn, or certain REL relocs (see must_be_dyn_reloc) that
9639 can be generated via assembly. We want calls to
9640 protected symbols to resolve directly to the function
9641 rather than going via the plt. If people want function
9642 pointer comparisons to work as expected then they should
9643 avoid writing weird assembly. */
9644 if (SYMBOL_CALLS_LOCAL (info, h))
9646 struct elf_dyn_relocs **pp;
9648 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9650 p->count -= p->pc_count;
9659 /* Also discard relocs on undefined weak syms with
9660 non-default visibility. */
9661 if (eh->dyn_relocs != NULL
9662 && h->root.type == bfd_link_hash_undefweak)
9664 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9665 eh->dyn_relocs = NULL;
9667 /* Make sure this symbol is output as a dynamic symbol.
9668 Undefined weak syms won't yet be marked as dynamic. */
9669 else if (h->dynindx == -1
9670 && !h->forced_local)
9672 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9677 else if (h->type == STT_GNU_IFUNC)
9679 if (!h->non_got_ref)
9680 eh->dyn_relocs = NULL;
9682 else if (ELIMINATE_COPY_RELOCS)
9684 /* For the non-shared case, discard space for relocs against
9685 symbols which turn out to need copy relocs or are not
9691 /* Make sure this symbol is output as a dynamic symbol.
9692 Undefined weak syms won't yet be marked as dynamic. */
9693 if (h->dynindx == -1
9694 && !h->forced_local)
9696 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9700 /* If that succeeded, we know we'll be keeping all the
9702 if (h->dynindx != -1)
9706 eh->dyn_relocs = NULL;
9711 /* Finally, allocate space. */
9712 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9714 asection *sreloc = elf_section_data (p->sec)->sreloc;
9715 if (eh->elf.type == STT_GNU_IFUNC)
9716 sreloc = htab->elf.irelplt;
9717 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9721 if ((htab->elf.dynamic_sections_created
9723 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9724 || h->type == STT_GNU_IFUNC)
9726 struct plt_entry *pent;
9727 bfd_boolean doneone = FALSE;
9728 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9729 if (pent->plt.refcount > 0)
9731 if (!htab->elf.dynamic_sections_created
9732 || h->dynindx == -1)
9735 pent->plt.offset = s->size;
9736 s->size += PLT_ENTRY_SIZE (htab);
9737 s = htab->elf.irelplt;
9741 /* If this is the first .plt entry, make room for the special
9745 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9747 pent->plt.offset = s->size;
9749 /* Make room for this entry. */
9750 s->size += PLT_ENTRY_SIZE (htab);
9752 /* Make room for the .glink code. */
9755 s->size += GLINK_CALL_STUB_SIZE;
9758 /* We need bigger stubs past index 32767. */
9759 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9766 /* We also need to make an entry in the .rela.plt section. */
9767 s = htab->elf.srelplt;
9769 s->size += sizeof (Elf64_External_Rela);
9773 pent->plt.offset = (bfd_vma) -1;
9776 h->plt.plist = NULL;
9782 h->plt.plist = NULL;
9789 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9790 to set up space for global entry stubs. These are put in glink,
9791 after the branch table. */
9794 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9796 struct bfd_link_info *info;
9797 struct ppc_link_hash_table *htab;
9798 struct plt_entry *pent;
9801 if (h->root.type == bfd_link_hash_indirect)
9804 if (!h->pointer_equality_needed)
9811 htab = ppc_hash_table (info);
9816 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9817 if (pent->plt.offset != (bfd_vma) -1
9818 && pent->addend == 0)
9820 /* For ELFv2, if this symbol is not defined in a regular file
9821 and we are not generating a shared library or pie, then we
9822 need to define the symbol in the executable on a call stub.
9823 This is to avoid text relocations. */
9824 s->size = (s->size + 15) & -16;
9825 h->root.u.def.section = s;
9826 h->root.u.def.value = s->size;
9833 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9834 read-only sections. */
9837 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9839 if (h->root.type == bfd_link_hash_indirect)
9842 if (readonly_dynrelocs (h))
9844 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9846 /* Not an error, just cut short the traversal. */
9852 /* Set the sizes of the dynamic sections. */
9855 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9856 struct bfd_link_info *info)
9858 struct ppc_link_hash_table *htab;
9863 struct got_entry *first_tlsld;
9865 htab = ppc_hash_table (info);
9869 dynobj = htab->elf.dynobj;
9873 if (htab->elf.dynamic_sections_created)
9875 /* Set the contents of the .interp section to the interpreter. */
9876 if (bfd_link_executable (info) && !info->nointerp)
9878 s = bfd_get_linker_section (dynobj, ".interp");
9881 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9882 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9886 /* Set up .got offsets for local syms, and space for local dynamic
9888 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9890 struct got_entry **lgot_ents;
9891 struct got_entry **end_lgot_ents;
9892 struct plt_entry **local_plt;
9893 struct plt_entry **end_local_plt;
9894 unsigned char *lgot_masks;
9895 bfd_size_type locsymcount;
9896 Elf_Internal_Shdr *symtab_hdr;
9898 if (!is_ppc64_elf (ibfd))
9901 for (s = ibfd->sections; s != NULL; s = s->next)
9903 struct ppc_dyn_relocs *p;
9905 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9907 if (!bfd_is_abs_section (p->sec)
9908 && bfd_is_abs_section (p->sec->output_section))
9910 /* Input section has been discarded, either because
9911 it is a copy of a linkonce section or due to
9912 linker script /DISCARD/, so we'll be discarding
9915 else if (p->count != 0)
9917 asection *srel = elf_section_data (p->sec)->sreloc;
9919 srel = htab->elf.irelplt;
9920 srel->size += p->count * sizeof (Elf64_External_Rela);
9921 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9922 info->flags |= DF_TEXTREL;
9927 lgot_ents = elf_local_got_ents (ibfd);
9931 symtab_hdr = &elf_symtab_hdr (ibfd);
9932 locsymcount = symtab_hdr->sh_info;
9933 end_lgot_ents = lgot_ents + locsymcount;
9934 local_plt = (struct plt_entry **) end_lgot_ents;
9935 end_local_plt = local_plt + locsymcount;
9936 lgot_masks = (unsigned char *) end_local_plt;
9937 s = ppc64_elf_tdata (ibfd)->got;
9938 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9940 struct got_entry **pent, *ent;
9943 while ((ent = *pent) != NULL)
9944 if (ent->got.refcount > 0)
9946 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9948 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9953 unsigned int ent_size = 8;
9954 unsigned int rel_size = sizeof (Elf64_External_Rela);
9956 ent->got.offset = s->size;
9957 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9962 s->size += ent_size;
9963 if ((*lgot_masks & PLT_IFUNC) != 0)
9965 htab->elf.irelplt->size += rel_size;
9966 htab->got_reli_size += rel_size;
9968 else if (bfd_link_pic (info))
9970 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9971 srel->size += rel_size;
9980 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9981 for (; local_plt < end_local_plt; ++local_plt)
9983 struct plt_entry *ent;
9985 for (ent = *local_plt; ent != NULL; ent = ent->next)
9986 if (ent->plt.refcount > 0)
9989 ent->plt.offset = s->size;
9990 s->size += PLT_ENTRY_SIZE (htab);
9992 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9995 ent->plt.offset = (bfd_vma) -1;
9999 /* Allocate global sym .plt and .got entries, and space for global
10000 sym dynamic relocs. */
10001 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10002 /* Stash the end of glink branch table. */
10003 if (htab->glink != NULL)
10004 htab->glink->rawsize = htab->glink->size;
10006 if (!htab->opd_abi && !bfd_link_pic (info))
10007 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10009 first_tlsld = NULL;
10010 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10012 struct got_entry *ent;
10014 if (!is_ppc64_elf (ibfd))
10017 ent = ppc64_tlsld_got (ibfd);
10018 if (ent->got.refcount > 0)
10020 if (!htab->do_multi_toc && first_tlsld != NULL)
10022 ent->is_indirect = TRUE;
10023 ent->got.ent = first_tlsld;
10027 if (first_tlsld == NULL)
10029 s = ppc64_elf_tdata (ibfd)->got;
10030 ent->got.offset = s->size;
10033 if (bfd_link_pic (info))
10035 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10036 srel->size += sizeof (Elf64_External_Rela);
10041 ent->got.offset = (bfd_vma) -1;
10044 /* We now have determined the sizes of the various dynamic sections.
10045 Allocate memory for them. */
10047 for (s = dynobj->sections; s != NULL; s = s->next)
10049 if ((s->flags & SEC_LINKER_CREATED) == 0)
10052 if (s == htab->brlt || s == htab->relbrlt)
10053 /* These haven't been allocated yet; don't strip. */
10055 else if (s == htab->elf.sgot
10056 || s == htab->elf.splt
10057 || s == htab->elf.iplt
10058 || s == htab->glink
10059 || s == htab->dynbss)
10061 /* Strip this section if we don't need it; see the
10064 else if (s == htab->glink_eh_frame)
10066 if (!bfd_is_abs_section (s->output_section))
10067 /* Not sized yet. */
10070 else if (CONST_STRNEQ (s->name, ".rela"))
10074 if (s != htab->elf.srelplt)
10077 /* We use the reloc_count field as a counter if we need
10078 to copy relocs into the output file. */
10079 s->reloc_count = 0;
10084 /* It's not one of our sections, so don't allocate space. */
10090 /* If we don't need this section, strip it from the
10091 output file. This is mostly to handle .rela.bss and
10092 .rela.plt. We must create both sections in
10093 create_dynamic_sections, because they must be created
10094 before the linker maps input sections to output
10095 sections. The linker does that before
10096 adjust_dynamic_symbol is called, and it is that
10097 function which decides whether anything needs to go
10098 into these sections. */
10099 s->flags |= SEC_EXCLUDE;
10103 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10106 /* Allocate memory for the section contents. We use bfd_zalloc
10107 here in case unused entries are not reclaimed before the
10108 section's contents are written out. This should not happen,
10109 but this way if it does we get a R_PPC64_NONE reloc in .rela
10110 sections instead of garbage.
10111 We also rely on the section contents being zero when writing
10113 s->contents = bfd_zalloc (dynobj, s->size);
10114 if (s->contents == NULL)
10118 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10120 if (!is_ppc64_elf (ibfd))
10123 s = ppc64_elf_tdata (ibfd)->got;
10124 if (s != NULL && s != htab->elf.sgot)
10127 s->flags |= SEC_EXCLUDE;
10130 s->contents = bfd_zalloc (ibfd, s->size);
10131 if (s->contents == NULL)
10135 s = ppc64_elf_tdata (ibfd)->relgot;
10139 s->flags |= SEC_EXCLUDE;
10142 s->contents = bfd_zalloc (ibfd, s->size);
10143 if (s->contents == NULL)
10146 s->reloc_count = 0;
10151 if (htab->elf.dynamic_sections_created)
10153 bfd_boolean tls_opt;
10155 /* Add some entries to the .dynamic section. We fill in the
10156 values later, in ppc64_elf_finish_dynamic_sections, but we
10157 must add the entries now so that we get the correct size for
10158 the .dynamic section. The DT_DEBUG entry is filled in by the
10159 dynamic linker and used by the debugger. */
10160 #define add_dynamic_entry(TAG, VAL) \
10161 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10163 if (bfd_link_executable (info))
10165 if (!add_dynamic_entry (DT_DEBUG, 0))
10169 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10171 if (!add_dynamic_entry (DT_PLTGOT, 0)
10172 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10173 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10174 || !add_dynamic_entry (DT_JMPREL, 0)
10175 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10179 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10181 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10182 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10186 tls_opt = (htab->params->tls_get_addr_opt
10187 && htab->tls_get_addr_fd != NULL
10188 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10189 if (tls_opt || !htab->opd_abi)
10191 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10197 if (!add_dynamic_entry (DT_RELA, 0)
10198 || !add_dynamic_entry (DT_RELASZ, 0)
10199 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10202 /* If any dynamic relocs apply to a read-only section,
10203 then we need a DT_TEXTREL entry. */
10204 if ((info->flags & DF_TEXTREL) == 0)
10205 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10207 if ((info->flags & DF_TEXTREL) != 0)
10209 if (!add_dynamic_entry (DT_TEXTREL, 0))
10214 #undef add_dynamic_entry
10219 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10222 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10224 if (h->plt.plist != NULL
10226 && !h->pointer_equality_needed)
10229 return _bfd_elf_hash_symbol (h);
10232 /* Determine the type of stub needed, if any, for a call. */
10234 static inline enum ppc_stub_type
10235 ppc_type_of_stub (asection *input_sec,
10236 const Elf_Internal_Rela *rel,
10237 struct ppc_link_hash_entry **hash,
10238 struct plt_entry **plt_ent,
10239 bfd_vma destination,
10240 unsigned long local_off)
10242 struct ppc_link_hash_entry *h = *hash;
10244 bfd_vma branch_offset;
10245 bfd_vma max_branch_offset;
10246 enum elf_ppc64_reloc_type r_type;
10250 struct plt_entry *ent;
10251 struct ppc_link_hash_entry *fdh = h;
10253 && h->oh->is_func_descriptor)
10255 fdh = ppc_follow_link (h->oh);
10259 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10260 if (ent->addend == rel->r_addend
10261 && ent->plt.offset != (bfd_vma) -1)
10264 return ppc_stub_plt_call;
10267 /* Here, we know we don't have a plt entry. If we don't have a
10268 either a defined function descriptor or a defined entry symbol
10269 in a regular object file, then it is pointless trying to make
10270 any other type of stub. */
10271 if (!is_static_defined (&fdh->elf)
10272 && !is_static_defined (&h->elf))
10273 return ppc_stub_none;
10275 else if (elf_local_got_ents (input_sec->owner) != NULL)
10277 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10278 struct plt_entry **local_plt = (struct plt_entry **)
10279 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10280 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10282 if (local_plt[r_symndx] != NULL)
10284 struct plt_entry *ent;
10286 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10287 if (ent->addend == rel->r_addend
10288 && ent->plt.offset != (bfd_vma) -1)
10291 return ppc_stub_plt_call;
10296 /* Determine where the call point is. */
10297 location = (input_sec->output_offset
10298 + input_sec->output_section->vma
10301 branch_offset = destination - location;
10302 r_type = ELF64_R_TYPE (rel->r_info);
10304 /* Determine if a long branch stub is needed. */
10305 max_branch_offset = 1 << 25;
10306 if (r_type != R_PPC64_REL24)
10307 max_branch_offset = 1 << 15;
10309 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10310 /* We need a stub. Figure out whether a long_branch or plt_branch
10311 is needed later. */
10312 return ppc_stub_long_branch;
10314 return ppc_stub_none;
10317 /* With power7 weakly ordered memory model, it is possible for ld.so
10318 to update a plt entry in one thread and have another thread see a
10319 stale zero toc entry. To avoid this we need some sort of acquire
10320 barrier in the call stub. One solution is to make the load of the
10321 toc word seem to appear to depend on the load of the function entry
10322 word. Another solution is to test for r2 being zero, and branch to
10323 the appropriate glink entry if so.
10325 . fake dep barrier compare
10326 . ld 12,xxx(2) ld 12,xxx(2)
10327 . mtctr 12 mtctr 12
10328 . xor 11,12,12 ld 2,xxx+8(2)
10329 . add 2,2,11 cmpldi 2,0
10330 . ld 2,xxx+8(2) bnectr+
10331 . bctr b <glink_entry>
10333 The solution involving the compare turns out to be faster, so
10334 that's what we use unless the branch won't reach. */
10336 #define ALWAYS_USE_FAKE_DEP 0
10337 #define ALWAYS_EMIT_R2SAVE 0
10339 #define PPC_LO(v) ((v) & 0xffff)
10340 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10341 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10343 static inline unsigned int
10344 plt_stub_size (struct ppc_link_hash_table *htab,
10345 struct ppc_stub_hash_entry *stub_entry,
10348 unsigned size = 12;
10350 if (ALWAYS_EMIT_R2SAVE
10351 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10353 if (PPC_HA (off) != 0)
10358 if (htab->params->plt_static_chain)
10360 if (htab->params->plt_thread_safe
10361 && htab->elf.dynamic_sections_created
10362 && stub_entry->h != NULL
10363 && stub_entry->h->elf.dynindx != -1)
10365 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10368 if (stub_entry->h != NULL
10369 && (stub_entry->h == htab->tls_get_addr_fd
10370 || stub_entry->h == htab->tls_get_addr)
10371 && htab->params->tls_get_addr_opt)
10376 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10377 then return the padding needed to do so. */
10378 static inline unsigned int
10379 plt_stub_pad (struct ppc_link_hash_table *htab,
10380 struct ppc_stub_hash_entry *stub_entry,
10383 int stub_align = 1 << htab->params->plt_stub_align;
10384 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10385 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10387 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10388 > ((stub_size - 1) & -stub_align))
10389 return stub_align - (stub_off & (stub_align - 1));
10393 /* Build a .plt call stub. */
10395 static inline bfd_byte *
10396 build_plt_stub (struct ppc_link_hash_table *htab,
10397 struct ppc_stub_hash_entry *stub_entry,
10398 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10400 bfd *obfd = htab->params->stub_bfd;
10401 bfd_boolean plt_load_toc = htab->opd_abi;
10402 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10403 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10404 && htab->elf.dynamic_sections_created
10405 && stub_entry->h != NULL
10406 && stub_entry->h->elf.dynindx != -1);
10407 bfd_boolean use_fake_dep = plt_thread_safe;
10408 bfd_vma cmp_branch_off = 0;
10410 if (!ALWAYS_USE_FAKE_DEP
10413 && !((stub_entry->h == htab->tls_get_addr_fd
10414 || stub_entry->h == htab->tls_get_addr)
10415 && htab->params->tls_get_addr_opt))
10417 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10418 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10419 / PLT_ENTRY_SIZE (htab));
10420 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10423 if (pltindex > 32768)
10424 glinkoff += (pltindex - 32768) * 4;
10426 + htab->glink->output_offset
10427 + htab->glink->output_section->vma);
10428 from = (p - stub_entry->group->stub_sec->contents
10429 + 4 * (ALWAYS_EMIT_R2SAVE
10430 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10431 + 4 * (PPC_HA (offset) != 0)
10432 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10433 != PPC_HA (offset))
10434 + 4 * (plt_static_chain != 0)
10436 + stub_entry->group->stub_sec->output_offset
10437 + stub_entry->group->stub_sec->output_section->vma);
10438 cmp_branch_off = to - from;
10439 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10442 if (PPC_HA (offset) != 0)
10446 if (ALWAYS_EMIT_R2SAVE
10447 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10448 r[0].r_offset += 4;
10449 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10450 r[1].r_offset = r[0].r_offset + 4;
10451 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10452 r[1].r_addend = r[0].r_addend;
10455 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10457 r[2].r_offset = r[1].r_offset + 4;
10458 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10459 r[2].r_addend = r[0].r_addend;
10463 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10464 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10465 r[2].r_addend = r[0].r_addend + 8;
10466 if (plt_static_chain)
10468 r[3].r_offset = r[2].r_offset + 4;
10469 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10470 r[3].r_addend = r[0].r_addend + 16;
10475 if (ALWAYS_EMIT_R2SAVE
10476 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10477 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10480 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10481 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10485 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10486 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10489 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10491 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10494 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10499 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10500 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10502 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10503 if (plt_static_chain)
10504 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10511 if (ALWAYS_EMIT_R2SAVE
10512 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10513 r[0].r_offset += 4;
10514 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10517 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10519 r[1].r_offset = r[0].r_offset + 4;
10520 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10521 r[1].r_addend = r[0].r_addend;
10525 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10526 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10527 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10528 if (plt_static_chain)
10530 r[2].r_offset = r[1].r_offset + 4;
10531 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10532 r[2].r_addend = r[0].r_addend + 8;
10537 if (ALWAYS_EMIT_R2SAVE
10538 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10539 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10540 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10542 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10544 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10547 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10552 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10553 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10555 if (plt_static_chain)
10556 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10557 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10560 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10562 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10563 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10564 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10567 bfd_put_32 (obfd, BCTR, p), p += 4;
10571 /* Build a special .plt call stub for __tls_get_addr. */
10573 #define LD_R11_0R3 0xe9630000
10574 #define LD_R12_0R3 0xe9830000
10575 #define MR_R0_R3 0x7c601b78
10576 #define CMPDI_R11_0 0x2c2b0000
10577 #define ADD_R3_R12_R13 0x7c6c6a14
10578 #define BEQLR 0x4d820020
10579 #define MR_R3_R0 0x7c030378
10580 #define STD_R11_0R1 0xf9610000
10581 #define BCTRL 0x4e800421
10582 #define LD_R11_0R1 0xe9610000
10583 #define MTLR_R11 0x7d6803a6
10585 static inline bfd_byte *
10586 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10587 struct ppc_stub_hash_entry *stub_entry,
10588 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10590 bfd *obfd = htab->params->stub_bfd;
10592 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10593 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10594 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10595 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10596 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10597 bfd_put_32 (obfd, BEQLR, p), p += 4;
10598 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10599 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10600 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10603 r[0].r_offset += 9 * 4;
10604 p = build_plt_stub (htab, stub_entry, p, offset, r);
10605 bfd_put_32 (obfd, BCTRL, p - 4);
10607 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10608 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10609 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10610 bfd_put_32 (obfd, BLR, p), p += 4;
10615 static Elf_Internal_Rela *
10616 get_relocs (asection *sec, int count)
10618 Elf_Internal_Rela *relocs;
10619 struct bfd_elf_section_data *elfsec_data;
10621 elfsec_data = elf_section_data (sec);
10622 relocs = elfsec_data->relocs;
10623 if (relocs == NULL)
10625 bfd_size_type relsize;
10626 relsize = sec->reloc_count * sizeof (*relocs);
10627 relocs = bfd_alloc (sec->owner, relsize);
10628 if (relocs == NULL)
10630 elfsec_data->relocs = relocs;
10631 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10632 sizeof (Elf_Internal_Shdr));
10633 if (elfsec_data->rela.hdr == NULL)
10635 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10636 * sizeof (Elf64_External_Rela));
10637 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10638 sec->reloc_count = 0;
10640 relocs += sec->reloc_count;
10641 sec->reloc_count += count;
10646 get_r2off (struct bfd_link_info *info,
10647 struct ppc_stub_hash_entry *stub_entry)
10649 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10650 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10654 /* Support linking -R objects. Get the toc pointer from the
10657 if (!htab->opd_abi)
10659 asection *opd = stub_entry->h->elf.root.u.def.section;
10660 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10662 if (strcmp (opd->name, ".opd") != 0
10663 || opd->reloc_count != 0)
10665 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10666 stub_entry->h->elf.root.root.string);
10667 bfd_set_error (bfd_error_bad_value);
10668 return (bfd_vma) -1;
10670 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10671 return (bfd_vma) -1;
10672 r2off = bfd_get_64 (opd->owner, buf);
10673 r2off -= elf_gp (info->output_bfd);
10675 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10680 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10682 struct ppc_stub_hash_entry *stub_entry;
10683 struct ppc_branch_hash_entry *br_entry;
10684 struct bfd_link_info *info;
10685 struct ppc_link_hash_table *htab;
10690 Elf_Internal_Rela *r;
10693 /* Massage our args to the form they really have. */
10694 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10697 htab = ppc_hash_table (info);
10701 /* Make a note of the offset within the stubs for this entry. */
10702 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10703 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10705 htab->stub_count[stub_entry->stub_type - 1] += 1;
10706 switch (stub_entry->stub_type)
10708 case ppc_stub_long_branch:
10709 case ppc_stub_long_branch_r2off:
10710 /* Branches are relative. This is where we are going to. */
10711 dest = (stub_entry->target_value
10712 + stub_entry->target_section->output_offset
10713 + stub_entry->target_section->output_section->vma);
10714 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10717 /* And this is where we are coming from. */
10718 off -= (stub_entry->stub_offset
10719 + stub_entry->group->stub_sec->output_offset
10720 + stub_entry->group->stub_sec->output_section->vma);
10723 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10725 bfd_vma r2off = get_r2off (info, stub_entry);
10727 if (r2off == (bfd_vma) -1)
10729 htab->stub_error = TRUE;
10732 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10735 if (PPC_HA (r2off) != 0)
10737 bfd_put_32 (htab->params->stub_bfd,
10738 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10742 if (PPC_LO (r2off) != 0)
10744 bfd_put_32 (htab->params->stub_bfd,
10745 ADDI_R2_R2 | PPC_LO (r2off), loc);
10751 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10753 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10755 info->callbacks->einfo
10756 (_("%P: long branch stub `%s' offset overflow\n"),
10757 stub_entry->root.string);
10758 htab->stub_error = TRUE;
10762 if (info->emitrelocations)
10764 r = get_relocs (stub_entry->group->stub_sec, 1);
10767 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10768 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10769 r->r_addend = dest;
10770 if (stub_entry->h != NULL)
10772 struct elf_link_hash_entry **hashes;
10773 unsigned long symndx;
10774 struct ppc_link_hash_entry *h;
10776 hashes = elf_sym_hashes (htab->params->stub_bfd);
10777 if (hashes == NULL)
10779 bfd_size_type hsize;
10781 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10782 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10783 if (hashes == NULL)
10785 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10786 htab->stub_globals = 1;
10788 symndx = htab->stub_globals++;
10790 hashes[symndx] = &h->elf;
10791 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10792 if (h->oh != NULL && h->oh->is_func)
10793 h = ppc_follow_link (h->oh);
10794 if (h->elf.root.u.def.section != stub_entry->target_section)
10795 /* H is an opd symbol. The addend must be zero. */
10799 off = (h->elf.root.u.def.value
10800 + h->elf.root.u.def.section->output_offset
10801 + h->elf.root.u.def.section->output_section->vma);
10802 r->r_addend -= off;
10808 case ppc_stub_plt_branch:
10809 case ppc_stub_plt_branch_r2off:
10810 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10811 stub_entry->root.string + 9,
10813 if (br_entry == NULL)
10815 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10816 stub_entry->root.string);
10817 htab->stub_error = TRUE;
10821 dest = (stub_entry->target_value
10822 + stub_entry->target_section->output_offset
10823 + stub_entry->target_section->output_section->vma);
10824 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10825 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10827 bfd_put_64 (htab->brlt->owner, dest,
10828 htab->brlt->contents + br_entry->offset);
10830 if (br_entry->iter == htab->stub_iteration)
10832 br_entry->iter = 0;
10834 if (htab->relbrlt != NULL)
10836 /* Create a reloc for the branch lookup table entry. */
10837 Elf_Internal_Rela rela;
10840 rela.r_offset = (br_entry->offset
10841 + htab->brlt->output_offset
10842 + htab->brlt->output_section->vma);
10843 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10844 rela.r_addend = dest;
10846 rl = htab->relbrlt->contents;
10847 rl += (htab->relbrlt->reloc_count++
10848 * sizeof (Elf64_External_Rela));
10849 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10851 else if (info->emitrelocations)
10853 r = get_relocs (htab->brlt, 1);
10856 /* brlt, being SEC_LINKER_CREATED does not go through the
10857 normal reloc processing. Symbols and offsets are not
10858 translated from input file to output file form, so
10859 set up the offset per the output file. */
10860 r->r_offset = (br_entry->offset
10861 + htab->brlt->output_offset
10862 + htab->brlt->output_section->vma);
10863 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10864 r->r_addend = dest;
10868 dest = (br_entry->offset
10869 + htab->brlt->output_offset
10870 + htab->brlt->output_section->vma);
10873 - elf_gp (htab->brlt->output_section->owner)
10874 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10876 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10878 info->callbacks->einfo
10879 (_("%P: linkage table error against `%T'\n"),
10880 stub_entry->root.string);
10881 bfd_set_error (bfd_error_bad_value);
10882 htab->stub_error = TRUE;
10886 if (info->emitrelocations)
10888 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10891 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10892 if (bfd_big_endian (info->output_bfd))
10893 r[0].r_offset += 2;
10894 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10895 r[0].r_offset += 4;
10896 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10897 r[0].r_addend = dest;
10898 if (PPC_HA (off) != 0)
10900 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10901 r[1].r_offset = r[0].r_offset + 4;
10902 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10903 r[1].r_addend = r[0].r_addend;
10907 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10909 if (PPC_HA (off) != 0)
10912 bfd_put_32 (htab->params->stub_bfd,
10913 ADDIS_R12_R2 | PPC_HA (off), loc);
10915 bfd_put_32 (htab->params->stub_bfd,
10916 LD_R12_0R12 | PPC_LO (off), loc);
10921 bfd_put_32 (htab->params->stub_bfd,
10922 LD_R12_0R2 | PPC_LO (off), loc);
10927 bfd_vma r2off = get_r2off (info, stub_entry);
10929 if (r2off == (bfd_vma) -1)
10931 htab->stub_error = TRUE;
10935 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10938 if (PPC_HA (off) != 0)
10941 bfd_put_32 (htab->params->stub_bfd,
10942 ADDIS_R12_R2 | PPC_HA (off), loc);
10944 bfd_put_32 (htab->params->stub_bfd,
10945 LD_R12_0R12 | PPC_LO (off), loc);
10948 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10950 if (PPC_HA (r2off) != 0)
10954 bfd_put_32 (htab->params->stub_bfd,
10955 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10957 if (PPC_LO (r2off) != 0)
10961 bfd_put_32 (htab->params->stub_bfd,
10962 ADDI_R2_R2 | PPC_LO (r2off), loc);
10966 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10968 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10971 case ppc_stub_plt_call:
10972 case ppc_stub_plt_call_r2save:
10973 if (stub_entry->h != NULL
10974 && stub_entry->h->is_func_descriptor
10975 && stub_entry->h->oh != NULL)
10977 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10979 /* If the old-ABI "dot-symbol" is undefined make it weak so
10980 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
10981 if (fh->elf.root.type == bfd_link_hash_undefined)
10982 fh->elf.root.type = bfd_link_hash_undefweak;
10983 /* Stop undo_symbol_twiddle changing it back to undefined. */
10984 fh->was_undefined = 0;
10987 /* Now build the stub. */
10988 dest = stub_entry->plt_ent->plt.offset & ~1;
10989 if (dest >= (bfd_vma) -2)
10992 plt = htab->elf.splt;
10993 if (!htab->elf.dynamic_sections_created
10994 || stub_entry->h == NULL
10995 || stub_entry->h->elf.dynindx == -1)
10996 plt = htab->elf.iplt;
10998 dest += plt->output_offset + plt->output_section->vma;
11000 if (stub_entry->h == NULL
11001 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11003 Elf_Internal_Rela rela;
11006 rela.r_offset = dest;
11008 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11010 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11011 rela.r_addend = (stub_entry->target_value
11012 + stub_entry->target_section->output_offset
11013 + stub_entry->target_section->output_section->vma);
11015 rl = (htab->elf.irelplt->contents
11016 + (htab->elf.irelplt->reloc_count++
11017 * sizeof (Elf64_External_Rela)));
11018 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11019 stub_entry->plt_ent->plt.offset |= 1;
11023 - elf_gp (plt->output_section->owner)
11024 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11026 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11028 info->callbacks->einfo
11029 (_("%P: linkage table error against `%T'\n"),
11030 stub_entry->h != NULL
11031 ? stub_entry->h->elf.root.root.string
11033 bfd_set_error (bfd_error_bad_value);
11034 htab->stub_error = TRUE;
11038 if (htab->params->plt_stub_align != 0)
11040 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11042 stub_entry->group->stub_sec->size += pad;
11043 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11048 if (info->emitrelocations)
11050 r = get_relocs (stub_entry->group->stub_sec,
11051 ((PPC_HA (off) != 0)
11053 ? 2 + (htab->params->plt_static_chain
11054 && PPC_HA (off + 16) == PPC_HA (off))
11058 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11059 if (bfd_big_endian (info->output_bfd))
11060 r[0].r_offset += 2;
11061 r[0].r_addend = dest;
11063 if (stub_entry->h != NULL
11064 && (stub_entry->h == htab->tls_get_addr_fd
11065 || stub_entry->h == htab->tls_get_addr)
11066 && htab->params->tls_get_addr_opt)
11067 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11069 p = build_plt_stub (htab, stub_entry, loc, off, r);
11073 case ppc_stub_save_res:
11081 stub_entry->group->stub_sec->size += size;
11083 if (htab->params->emit_stub_syms)
11085 struct elf_link_hash_entry *h;
11088 const char *const stub_str[] = { "long_branch",
11089 "long_branch_r2off",
11091 "plt_branch_r2off",
11095 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11096 len2 = strlen (stub_entry->root.string);
11097 name = bfd_malloc (len1 + len2 + 2);
11100 memcpy (name, stub_entry->root.string, 9);
11101 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11102 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11103 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11106 if (h->root.type == bfd_link_hash_new)
11108 h->root.type = bfd_link_hash_defined;
11109 h->root.u.def.section = stub_entry->group->stub_sec;
11110 h->root.u.def.value = stub_entry->stub_offset;
11111 h->ref_regular = 1;
11112 h->def_regular = 1;
11113 h->ref_regular_nonweak = 1;
11114 h->forced_local = 1;
11116 h->root.linker_def = 1;
11123 /* As above, but don't actually build the stub. Just bump offset so
11124 we know stub section sizes, and select plt_branch stubs where
11125 long_branch stubs won't do. */
11128 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11130 struct ppc_stub_hash_entry *stub_entry;
11131 struct bfd_link_info *info;
11132 struct ppc_link_hash_table *htab;
11136 /* Massage our args to the form they really have. */
11137 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11140 htab = ppc_hash_table (info);
11144 if (stub_entry->h != NULL
11145 && stub_entry->h->save_res
11146 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11147 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11149 /* Don't make stubs to out-of-line register save/restore
11150 functions. Instead, emit copies of the functions. */
11151 stub_entry->group->needs_save_res = 1;
11152 stub_entry->stub_type = ppc_stub_save_res;
11156 if (stub_entry->stub_type == ppc_stub_plt_call
11157 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11160 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11161 if (off >= (bfd_vma) -2)
11163 plt = htab->elf.splt;
11164 if (!htab->elf.dynamic_sections_created
11165 || stub_entry->h == NULL
11166 || stub_entry->h->elf.dynindx == -1)
11167 plt = htab->elf.iplt;
11168 off += (plt->output_offset
11169 + plt->output_section->vma
11170 - elf_gp (plt->output_section->owner)
11171 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11173 size = plt_stub_size (htab, stub_entry, off);
11174 if (htab->params->plt_stub_align)
11175 size += plt_stub_pad (htab, stub_entry, off);
11176 if (info->emitrelocations)
11178 stub_entry->group->stub_sec->reloc_count
11179 += ((PPC_HA (off) != 0)
11181 ? 2 + (htab->params->plt_static_chain
11182 && PPC_HA (off + 16) == PPC_HA (off))
11184 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11189 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11192 bfd_vma local_off = 0;
11194 off = (stub_entry->target_value
11195 + stub_entry->target_section->output_offset
11196 + stub_entry->target_section->output_section->vma);
11197 off -= (stub_entry->group->stub_sec->size
11198 + stub_entry->group->stub_sec->output_offset
11199 + stub_entry->group->stub_sec->output_section->vma);
11201 /* Reset the stub type from the plt variant in case we now
11202 can reach with a shorter stub. */
11203 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11204 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11207 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11209 r2off = get_r2off (info, stub_entry);
11210 if (r2off == (bfd_vma) -1)
11212 htab->stub_error = TRUE;
11216 if (PPC_HA (r2off) != 0)
11218 if (PPC_LO (r2off) != 0)
11223 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11225 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11226 Do the same for -R objects without function descriptors. */
11227 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11228 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11230 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11232 struct ppc_branch_hash_entry *br_entry;
11234 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11235 stub_entry->root.string + 9,
11237 if (br_entry == NULL)
11239 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11240 stub_entry->root.string);
11241 htab->stub_error = TRUE;
11245 if (br_entry->iter != htab->stub_iteration)
11247 br_entry->iter = htab->stub_iteration;
11248 br_entry->offset = htab->brlt->size;
11249 htab->brlt->size += 8;
11251 if (htab->relbrlt != NULL)
11252 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11253 else if (info->emitrelocations)
11255 htab->brlt->reloc_count += 1;
11256 htab->brlt->flags |= SEC_RELOC;
11260 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11261 off = (br_entry->offset
11262 + htab->brlt->output_offset
11263 + htab->brlt->output_section->vma
11264 - elf_gp (htab->brlt->output_section->owner)
11265 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11267 if (info->emitrelocations)
11269 stub_entry->group->stub_sec->reloc_count
11270 += 1 + (PPC_HA (off) != 0);
11271 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11274 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11277 if (PPC_HA (off) != 0)
11283 if (PPC_HA (off) != 0)
11286 if (PPC_HA (r2off) != 0)
11288 if (PPC_LO (r2off) != 0)
11292 else if (info->emitrelocations)
11294 stub_entry->group->stub_sec->reloc_count += 1;
11295 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11299 stub_entry->group->stub_sec->size += size;
11303 /* Set up various things so that we can make a list of input sections
11304 for each output section included in the link. Returns -1 on error,
11305 0 when no stubs will be needed, and 1 on success. */
11308 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11312 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11317 htab->sec_info_arr_size = bfd_get_next_section_id ();
11318 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11319 htab->sec_info = bfd_zmalloc (amt);
11320 if (htab->sec_info == NULL)
11323 /* Set toc_off for com, und, abs and ind sections. */
11324 for (id = 0; id < 3; id++)
11325 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11330 /* Set up for first pass at multitoc partitioning. */
11333 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11335 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11337 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11338 htab->toc_bfd = NULL;
11339 htab->toc_first_sec = NULL;
11342 /* The linker repeatedly calls this function for each TOC input section
11343 and linker generated GOT section. Group input bfds such that the toc
11344 within a group is less than 64k in size. */
11347 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11349 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11350 bfd_vma addr, off, limit;
11355 if (!htab->second_toc_pass)
11357 /* Keep track of the first .toc or .got section for this input bfd. */
11358 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11362 htab->toc_bfd = isec->owner;
11363 htab->toc_first_sec = isec;
11366 addr = isec->output_offset + isec->output_section->vma;
11367 off = addr - htab->toc_curr;
11368 limit = 0x80008000;
11369 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11371 if (off + isec->size > limit)
11373 addr = (htab->toc_first_sec->output_offset
11374 + htab->toc_first_sec->output_section->vma);
11375 htab->toc_curr = addr;
11376 htab->toc_curr &= -TOC_BASE_ALIGN;
11379 /* toc_curr is the base address of this toc group. Set elf_gp
11380 for the input section to be the offset relative to the
11381 output toc base plus 0x8000. Making the input elf_gp an
11382 offset allows us to move the toc as a whole without
11383 recalculating input elf_gp. */
11384 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11385 off += TOC_BASE_OFF;
11387 /* Die if someone uses a linker script that doesn't keep input
11388 file .toc and .got together. */
11390 && elf_gp (isec->owner) != 0
11391 && elf_gp (isec->owner) != off)
11394 elf_gp (isec->owner) = off;
11398 /* During the second pass toc_first_sec points to the start of
11399 a toc group, and toc_curr is used to track the old elf_gp.
11400 We use toc_bfd to ensure we only look at each bfd once. */
11401 if (htab->toc_bfd == isec->owner)
11403 htab->toc_bfd = isec->owner;
11405 if (htab->toc_first_sec == NULL
11406 || htab->toc_curr != elf_gp (isec->owner))
11408 htab->toc_curr = elf_gp (isec->owner);
11409 htab->toc_first_sec = isec;
11411 addr = (htab->toc_first_sec->output_offset
11412 + htab->toc_first_sec->output_section->vma);
11413 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11414 elf_gp (isec->owner) = off;
11419 /* Called via elf_link_hash_traverse to merge GOT entries for global
11423 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11425 if (h->root.type == bfd_link_hash_indirect)
11428 merge_got_entries (&h->got.glist);
11433 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11437 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11439 struct got_entry *gent;
11441 if (h->root.type == bfd_link_hash_indirect)
11444 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11445 if (!gent->is_indirect)
11446 allocate_got (h, (struct bfd_link_info *) inf, gent);
11450 /* Called on the first multitoc pass after the last call to
11451 ppc64_elf_next_toc_section. This function removes duplicate GOT
11455 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11457 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11458 struct bfd *ibfd, *ibfd2;
11459 bfd_boolean done_something;
11461 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11463 if (!htab->do_multi_toc)
11466 /* Merge global sym got entries within a toc group. */
11467 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11469 /* And tlsld_got. */
11470 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11472 struct got_entry *ent, *ent2;
11474 if (!is_ppc64_elf (ibfd))
11477 ent = ppc64_tlsld_got (ibfd);
11478 if (!ent->is_indirect
11479 && ent->got.offset != (bfd_vma) -1)
11481 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11483 if (!is_ppc64_elf (ibfd2))
11486 ent2 = ppc64_tlsld_got (ibfd2);
11487 if (!ent2->is_indirect
11488 && ent2->got.offset != (bfd_vma) -1
11489 && elf_gp (ibfd2) == elf_gp (ibfd))
11491 ent2->is_indirect = TRUE;
11492 ent2->got.ent = ent;
11498 /* Zap sizes of got sections. */
11499 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11500 htab->elf.irelplt->size -= htab->got_reli_size;
11501 htab->got_reli_size = 0;
11503 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11505 asection *got, *relgot;
11507 if (!is_ppc64_elf (ibfd))
11510 got = ppc64_elf_tdata (ibfd)->got;
11513 got->rawsize = got->size;
11515 relgot = ppc64_elf_tdata (ibfd)->relgot;
11516 relgot->rawsize = relgot->size;
11521 /* Now reallocate the got, local syms first. We don't need to
11522 allocate section contents again since we never increase size. */
11523 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11525 struct got_entry **lgot_ents;
11526 struct got_entry **end_lgot_ents;
11527 struct plt_entry **local_plt;
11528 struct plt_entry **end_local_plt;
11529 unsigned char *lgot_masks;
11530 bfd_size_type locsymcount;
11531 Elf_Internal_Shdr *symtab_hdr;
11534 if (!is_ppc64_elf (ibfd))
11537 lgot_ents = elf_local_got_ents (ibfd);
11541 symtab_hdr = &elf_symtab_hdr (ibfd);
11542 locsymcount = symtab_hdr->sh_info;
11543 end_lgot_ents = lgot_ents + locsymcount;
11544 local_plt = (struct plt_entry **) end_lgot_ents;
11545 end_local_plt = local_plt + locsymcount;
11546 lgot_masks = (unsigned char *) end_local_plt;
11547 s = ppc64_elf_tdata (ibfd)->got;
11548 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11550 struct got_entry *ent;
11552 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11554 unsigned int ent_size = 8;
11555 unsigned int rel_size = sizeof (Elf64_External_Rela);
11557 ent->got.offset = s->size;
11558 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11563 s->size += ent_size;
11564 if ((*lgot_masks & PLT_IFUNC) != 0)
11566 htab->elf.irelplt->size += rel_size;
11567 htab->got_reli_size += rel_size;
11569 else if (bfd_link_pic (info))
11571 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11572 srel->size += rel_size;
11578 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11580 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11582 struct got_entry *ent;
11584 if (!is_ppc64_elf (ibfd))
11587 ent = ppc64_tlsld_got (ibfd);
11588 if (!ent->is_indirect
11589 && ent->got.offset != (bfd_vma) -1)
11591 asection *s = ppc64_elf_tdata (ibfd)->got;
11592 ent->got.offset = s->size;
11594 if (bfd_link_pic (info))
11596 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11597 srel->size += sizeof (Elf64_External_Rela);
11602 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11603 if (!done_something)
11604 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11608 if (!is_ppc64_elf (ibfd))
11611 got = ppc64_elf_tdata (ibfd)->got;
11614 done_something = got->rawsize != got->size;
11615 if (done_something)
11620 if (done_something)
11621 (*htab->params->layout_sections_again) ();
11623 /* Set up for second pass over toc sections to recalculate elf_gp
11624 on input sections. */
11625 htab->toc_bfd = NULL;
11626 htab->toc_first_sec = NULL;
11627 htab->second_toc_pass = TRUE;
11628 return done_something;
11631 /* Called after second pass of multitoc partitioning. */
11634 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11636 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11638 /* After the second pass, toc_curr tracks the TOC offset used
11639 for code sections below in ppc64_elf_next_input_section. */
11640 htab->toc_curr = TOC_BASE_OFF;
11643 /* No toc references were found in ISEC. If the code in ISEC makes no
11644 calls, then there's no need to use toc adjusting stubs when branching
11645 into ISEC. Actually, indirect calls from ISEC are OK as they will
11646 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11647 needed, and 2 if a cyclical call-graph was found but no other reason
11648 for a stub was detected. If called from the top level, a return of
11649 2 means the same as a return of 0. */
11652 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11656 /* Mark this section as checked. */
11657 isec->call_check_done = 1;
11659 /* We know none of our code bearing sections will need toc stubs. */
11660 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11663 if (isec->size == 0)
11666 if (isec->output_section == NULL)
11670 if (isec->reloc_count != 0)
11672 Elf_Internal_Rela *relstart, *rel;
11673 Elf_Internal_Sym *local_syms;
11674 struct ppc_link_hash_table *htab;
11676 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11677 info->keep_memory);
11678 if (relstart == NULL)
11681 /* Look for branches to outside of this section. */
11683 htab = ppc_hash_table (info);
11687 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11689 enum elf_ppc64_reloc_type r_type;
11690 unsigned long r_symndx;
11691 struct elf_link_hash_entry *h;
11692 struct ppc_link_hash_entry *eh;
11693 Elf_Internal_Sym *sym;
11695 struct _opd_sec_data *opd;
11699 r_type = ELF64_R_TYPE (rel->r_info);
11700 if (r_type != R_PPC64_REL24
11701 && r_type != R_PPC64_REL14
11702 && r_type != R_PPC64_REL14_BRTAKEN
11703 && r_type != R_PPC64_REL14_BRNTAKEN)
11706 r_symndx = ELF64_R_SYM (rel->r_info);
11707 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11714 /* Calls to dynamic lib functions go through a plt call stub
11716 eh = (struct ppc_link_hash_entry *) h;
11718 && (eh->elf.plt.plist != NULL
11720 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11726 if (sym_sec == NULL)
11727 /* Ignore other undefined symbols. */
11730 /* Assume branches to other sections not included in the
11731 link need stubs too, to cover -R and absolute syms. */
11732 if (sym_sec->output_section == NULL)
11739 sym_value = sym->st_value;
11742 if (h->root.type != bfd_link_hash_defined
11743 && h->root.type != bfd_link_hash_defweak)
11745 sym_value = h->root.u.def.value;
11747 sym_value += rel->r_addend;
11749 /* If this branch reloc uses an opd sym, find the code section. */
11750 opd = get_opd_info (sym_sec);
11753 if (h == NULL && opd->adjust != NULL)
11757 adjust = opd->adjust[OPD_NDX (sym_value)];
11759 /* Assume deleted functions won't ever be called. */
11761 sym_value += adjust;
11764 dest = opd_entry_value (sym_sec, sym_value,
11765 &sym_sec, NULL, FALSE);
11766 if (dest == (bfd_vma) -1)
11771 + sym_sec->output_offset
11772 + sym_sec->output_section->vma);
11774 /* Ignore branch to self. */
11775 if (sym_sec == isec)
11778 /* If the called function uses the toc, we need a stub. */
11779 if (sym_sec->has_toc_reloc
11780 || sym_sec->makes_toc_func_call)
11786 /* Assume any branch that needs a long branch stub might in fact
11787 need a plt_branch stub. A plt_branch stub uses r2. */
11788 else if (dest - (isec->output_offset
11789 + isec->output_section->vma
11790 + rel->r_offset) + (1 << 25)
11791 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11799 /* If calling back to a section in the process of being
11800 tested, we can't say for sure that no toc adjusting stubs
11801 are needed, so don't return zero. */
11802 else if (sym_sec->call_check_in_progress)
11805 /* Branches to another section that itself doesn't have any TOC
11806 references are OK. Recursively call ourselves to check. */
11807 else if (!sym_sec->call_check_done)
11811 /* Mark current section as indeterminate, so that other
11812 sections that call back to current won't be marked as
11814 isec->call_check_in_progress = 1;
11815 recur = toc_adjusting_stub_needed (info, sym_sec);
11816 isec->call_check_in_progress = 0;
11827 if (local_syms != NULL
11828 && (elf_symtab_hdr (isec->owner).contents
11829 != (unsigned char *) local_syms))
11831 if (elf_section_data (isec)->relocs != relstart)
11836 && isec->map_head.s != NULL
11837 && (strcmp (isec->output_section->name, ".init") == 0
11838 || strcmp (isec->output_section->name, ".fini") == 0))
11840 if (isec->map_head.s->has_toc_reloc
11841 || isec->map_head.s->makes_toc_func_call)
11843 else if (!isec->map_head.s->call_check_done)
11846 isec->call_check_in_progress = 1;
11847 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11848 isec->call_check_in_progress = 0;
11855 isec->makes_toc_func_call = 1;
11860 /* The linker repeatedly calls this function for each input section,
11861 in the order that input sections are linked into output sections.
11862 Build lists of input sections to determine groupings between which
11863 we may insert linker stubs. */
11866 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11868 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11873 if ((isec->output_section->flags & SEC_CODE) != 0
11874 && isec->output_section->id < htab->sec_info_arr_size)
11876 /* This happens to make the list in reverse order,
11877 which is what we want. */
11878 htab->sec_info[isec->id].u.list
11879 = htab->sec_info[isec->output_section->id].u.list;
11880 htab->sec_info[isec->output_section->id].u.list = isec;
11883 if (htab->multi_toc_needed)
11885 /* Analyse sections that aren't already flagged as needing a
11886 valid toc pointer. Exclude .fixup for the linux kernel.
11887 .fixup contains branches, but only back to the function that
11888 hit an exception. */
11889 if (!(isec->has_toc_reloc
11890 || (isec->flags & SEC_CODE) == 0
11891 || strcmp (isec->name, ".fixup") == 0
11892 || isec->call_check_done))
11894 if (toc_adjusting_stub_needed (info, isec) < 0)
11897 /* Make all sections use the TOC assigned for this object file.
11898 This will be wrong for pasted sections; We fix that in
11899 check_pasted_section(). */
11900 if (elf_gp (isec->owner) != 0)
11901 htab->toc_curr = elf_gp (isec->owner);
11904 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11908 /* Check that all .init and .fini sections use the same toc, if they
11909 have toc relocs. */
11912 check_pasted_section (struct bfd_link_info *info, const char *name)
11914 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11918 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11919 bfd_vma toc_off = 0;
11922 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11923 if (i->has_toc_reloc)
11926 toc_off = htab->sec_info[i->id].toc_off;
11927 else if (toc_off != htab->sec_info[i->id].toc_off)
11932 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11933 if (i->makes_toc_func_call)
11935 toc_off = htab->sec_info[i->id].toc_off;
11939 /* Make sure the whole pasted function uses the same toc offset. */
11941 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11942 htab->sec_info[i->id].toc_off = toc_off;
11948 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11950 return (check_pasted_section (info, ".init")
11951 & check_pasted_section (info, ".fini"));
11954 /* See whether we can group stub sections together. Grouping stub
11955 sections may result in fewer stubs. More importantly, we need to
11956 put all .init* and .fini* stubs at the beginning of the .init or
11957 .fini output sections respectively, because glibc splits the
11958 _init and _fini functions into multiple parts. Putting a stub in
11959 the middle of a function is not a good idea. */
11962 group_sections (struct bfd_link_info *info,
11963 bfd_size_type stub_group_size,
11964 bfd_boolean stubs_always_before_branch)
11966 struct ppc_link_hash_table *htab;
11968 bfd_size_type stub14_group_size;
11969 bfd_boolean suppress_size_errors;
11971 htab = ppc_hash_table (info);
11975 suppress_size_errors = FALSE;
11976 stub14_group_size = stub_group_size >> 10;
11977 if (stub_group_size == 1)
11979 /* Default values. */
11980 if (stubs_always_before_branch)
11982 stub_group_size = 0x1e00000;
11983 stub14_group_size = 0x7800;
11987 stub_group_size = 0x1c00000;
11988 stub14_group_size = 0x7000;
11990 suppress_size_errors = TRUE;
11993 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11997 if (osec->id >= htab->sec_info_arr_size)
12000 tail = htab->sec_info[osec->id].u.list;
12001 while (tail != NULL)
12005 bfd_size_type total;
12006 bfd_boolean big_sec;
12008 struct map_stub *group;
12011 total = tail->size;
12012 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12013 && ppc64_elf_section_data (tail)->has_14bit_branch
12014 ? stub14_group_size : stub_group_size);
12015 if (big_sec && !suppress_size_errors)
12016 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12017 tail->owner, tail);
12018 curr_toc = htab->sec_info[tail->id].toc_off;
12020 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12021 && ((total += curr->output_offset - prev->output_offset)
12022 < (ppc64_elf_section_data (prev) != NULL
12023 && ppc64_elf_section_data (prev)->has_14bit_branch
12024 ? stub14_group_size : stub_group_size))
12025 && htab->sec_info[prev->id].toc_off == curr_toc)
12028 /* OK, the size from the start of CURR to the end is less
12029 than stub_group_size and thus can be handled by one stub
12030 section. (or the tail section is itself larger than
12031 stub_group_size, in which case we may be toast.) We
12032 should really be keeping track of the total size of stubs
12033 added here, as stubs contribute to the final output
12034 section size. That's a little tricky, and this way will
12035 only break if stubs added make the total size more than
12036 2^25, ie. for the default stub_group_size, if stubs total
12037 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12038 group = bfd_alloc (curr->owner, sizeof (*group));
12041 group->link_sec = curr;
12042 group->stub_sec = NULL;
12043 group->needs_save_res = 0;
12044 group->next = htab->group;
12045 htab->group = group;
12048 prev = htab->sec_info[tail->id].u.list;
12049 /* Set up this stub group. */
12050 htab->sec_info[tail->id].u.group = group;
12052 while (tail != curr && (tail = prev) != NULL);
12054 /* But wait, there's more! Input sections up to stub_group_size
12055 bytes before the stub section can be handled by it too.
12056 Don't do this if we have a really large section after the
12057 stubs, as adding more stubs increases the chance that
12058 branches may not reach into the stub section. */
12059 if (!stubs_always_before_branch && !big_sec)
12062 while (prev != NULL
12063 && ((total += tail->output_offset - prev->output_offset)
12064 < (ppc64_elf_section_data (prev) != NULL
12065 && ppc64_elf_section_data (prev)->has_14bit_branch
12066 ? stub14_group_size : stub_group_size))
12067 && htab->sec_info[prev->id].toc_off == curr_toc)
12070 prev = htab->sec_info[tail->id].u.list;
12071 htab->sec_info[tail->id].u.group = group;
12080 static const unsigned char glink_eh_frame_cie[] =
12082 0, 0, 0, 16, /* length. */
12083 0, 0, 0, 0, /* id. */
12084 1, /* CIE version. */
12085 'z', 'R', 0, /* Augmentation string. */
12086 4, /* Code alignment. */
12087 0x78, /* Data alignment. */
12089 1, /* Augmentation size. */
12090 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12091 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12095 /* Stripping output sections is normally done before dynamic section
12096 symbols have been allocated. This function is called later, and
12097 handles cases like htab->brlt which is mapped to its own output
12101 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12103 if (isec->size == 0
12104 && isec->output_section->size == 0
12105 && !(isec->output_section->flags & SEC_KEEP)
12106 && !bfd_section_removed_from_list (info->output_bfd,
12107 isec->output_section)
12108 && elf_section_data (isec->output_section)->dynindx == 0)
12110 isec->output_section->flags |= SEC_EXCLUDE;
12111 bfd_section_list_remove (info->output_bfd, isec->output_section);
12112 info->output_bfd->section_count--;
12116 /* Determine and set the size of the stub section for a final link.
12118 The basic idea here is to examine all the relocations looking for
12119 PC-relative calls to a target that is unreachable with a "bl"
12123 ppc64_elf_size_stubs (struct bfd_link_info *info)
12125 bfd_size_type stub_group_size;
12126 bfd_boolean stubs_always_before_branch;
12127 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12132 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12133 htab->params->plt_thread_safe = 1;
12134 if (!htab->opd_abi)
12135 htab->params->plt_thread_safe = 0;
12136 else if (htab->params->plt_thread_safe == -1)
12138 static const char *const thread_starter[] =
12142 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12144 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12145 "mq_notify", "create_timer",
12150 "GOMP_parallel_start",
12151 "GOMP_parallel_loop_static",
12152 "GOMP_parallel_loop_static_start",
12153 "GOMP_parallel_loop_dynamic",
12154 "GOMP_parallel_loop_dynamic_start",
12155 "GOMP_parallel_loop_guided",
12156 "GOMP_parallel_loop_guided_start",
12157 "GOMP_parallel_loop_runtime",
12158 "GOMP_parallel_loop_runtime_start",
12159 "GOMP_parallel_sections",
12160 "GOMP_parallel_sections_start",
12166 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12168 struct elf_link_hash_entry *h;
12169 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12170 FALSE, FALSE, TRUE);
12171 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12172 if (htab->params->plt_thread_safe)
12176 stubs_always_before_branch = htab->params->group_size < 0;
12177 if (htab->params->group_size < 0)
12178 stub_group_size = -htab->params->group_size;
12180 stub_group_size = htab->params->group_size;
12182 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12188 unsigned int bfd_indx;
12189 struct map_stub *group;
12190 asection *stub_sec;
12192 htab->stub_iteration += 1;
12194 for (input_bfd = info->input_bfds, bfd_indx = 0;
12196 input_bfd = input_bfd->link.next, bfd_indx++)
12198 Elf_Internal_Shdr *symtab_hdr;
12200 Elf_Internal_Sym *local_syms = NULL;
12202 if (!is_ppc64_elf (input_bfd))
12205 /* We'll need the symbol table in a second. */
12206 symtab_hdr = &elf_symtab_hdr (input_bfd);
12207 if (symtab_hdr->sh_info == 0)
12210 /* Walk over each section attached to the input bfd. */
12211 for (section = input_bfd->sections;
12213 section = section->next)
12215 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12217 /* If there aren't any relocs, then there's nothing more
12219 if ((section->flags & SEC_RELOC) == 0
12220 || (section->flags & SEC_ALLOC) == 0
12221 || (section->flags & SEC_LOAD) == 0
12222 || (section->flags & SEC_CODE) == 0
12223 || section->reloc_count == 0)
12226 /* If this section is a link-once section that will be
12227 discarded, then don't create any stubs. */
12228 if (section->output_section == NULL
12229 || section->output_section->owner != info->output_bfd)
12232 /* Get the relocs. */
12234 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12235 info->keep_memory);
12236 if (internal_relocs == NULL)
12237 goto error_ret_free_local;
12239 /* Now examine each relocation. */
12240 irela = internal_relocs;
12241 irelaend = irela + section->reloc_count;
12242 for (; irela < irelaend; irela++)
12244 enum elf_ppc64_reloc_type r_type;
12245 unsigned int r_indx;
12246 enum ppc_stub_type stub_type;
12247 struct ppc_stub_hash_entry *stub_entry;
12248 asection *sym_sec, *code_sec;
12249 bfd_vma sym_value, code_value;
12250 bfd_vma destination;
12251 unsigned long local_off;
12252 bfd_boolean ok_dest;
12253 struct ppc_link_hash_entry *hash;
12254 struct ppc_link_hash_entry *fdh;
12255 struct elf_link_hash_entry *h;
12256 Elf_Internal_Sym *sym;
12258 const asection *id_sec;
12259 struct _opd_sec_data *opd;
12260 struct plt_entry *plt_ent;
12262 r_type = ELF64_R_TYPE (irela->r_info);
12263 r_indx = ELF64_R_SYM (irela->r_info);
12265 if (r_type >= R_PPC64_max)
12267 bfd_set_error (bfd_error_bad_value);
12268 goto error_ret_free_internal;
12271 /* Only look for stubs on branch instructions. */
12272 if (r_type != R_PPC64_REL24
12273 && r_type != R_PPC64_REL14
12274 && r_type != R_PPC64_REL14_BRTAKEN
12275 && r_type != R_PPC64_REL14_BRNTAKEN)
12278 /* Now determine the call target, its name, value,
12280 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12281 r_indx, input_bfd))
12282 goto error_ret_free_internal;
12283 hash = (struct ppc_link_hash_entry *) h;
12290 sym_value = sym->st_value;
12291 if (sym_sec != NULL
12292 && sym_sec->output_section != NULL)
12295 else if (hash->elf.root.type == bfd_link_hash_defined
12296 || hash->elf.root.type == bfd_link_hash_defweak)
12298 sym_value = hash->elf.root.u.def.value;
12299 if (sym_sec->output_section != NULL)
12302 else if (hash->elf.root.type == bfd_link_hash_undefweak
12303 || hash->elf.root.type == bfd_link_hash_undefined)
12305 /* Recognise an old ABI func code entry sym, and
12306 use the func descriptor sym instead if it is
12308 if (hash->elf.root.root.string[0] == '.'
12309 && (fdh = lookup_fdh (hash, htab)) != NULL)
12311 if (fdh->elf.root.type == bfd_link_hash_defined
12312 || fdh->elf.root.type == bfd_link_hash_defweak)
12314 sym_sec = fdh->elf.root.u.def.section;
12315 sym_value = fdh->elf.root.u.def.value;
12316 if (sym_sec->output_section != NULL)
12325 bfd_set_error (bfd_error_bad_value);
12326 goto error_ret_free_internal;
12333 sym_value += irela->r_addend;
12334 destination = (sym_value
12335 + sym_sec->output_offset
12336 + sym_sec->output_section->vma);
12337 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12342 code_sec = sym_sec;
12343 code_value = sym_value;
12344 opd = get_opd_info (sym_sec);
12349 if (hash == NULL && opd->adjust != NULL)
12351 long adjust = opd->adjust[OPD_NDX (sym_value)];
12354 code_value += adjust;
12355 sym_value += adjust;
12357 dest = opd_entry_value (sym_sec, sym_value,
12358 &code_sec, &code_value, FALSE);
12359 if (dest != (bfd_vma) -1)
12361 destination = dest;
12364 /* Fixup old ABI sym to point at code
12366 hash->elf.root.type = bfd_link_hash_defweak;
12367 hash->elf.root.u.def.section = code_sec;
12368 hash->elf.root.u.def.value = code_value;
12373 /* Determine what (if any) linker stub is needed. */
12375 stub_type = ppc_type_of_stub (section, irela, &hash,
12376 &plt_ent, destination,
12379 if (stub_type != ppc_stub_plt_call)
12381 /* Check whether we need a TOC adjusting stub.
12382 Since the linker pastes together pieces from
12383 different object files when creating the
12384 _init and _fini functions, it may be that a
12385 call to what looks like a local sym is in
12386 fact a call needing a TOC adjustment. */
12387 if (code_sec != NULL
12388 && code_sec->output_section != NULL
12389 && (htab->sec_info[code_sec->id].toc_off
12390 != htab->sec_info[section->id].toc_off)
12391 && (code_sec->has_toc_reloc
12392 || code_sec->makes_toc_func_call))
12393 stub_type = ppc_stub_long_branch_r2off;
12396 if (stub_type == ppc_stub_none)
12399 /* __tls_get_addr calls might be eliminated. */
12400 if (stub_type != ppc_stub_plt_call
12402 && (hash == htab->tls_get_addr
12403 || hash == htab->tls_get_addr_fd)
12404 && section->has_tls_reloc
12405 && irela != internal_relocs)
12407 /* Get tls info. */
12408 unsigned char *tls_mask;
12410 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12411 irela - 1, input_bfd))
12412 goto error_ret_free_internal;
12413 if (*tls_mask != 0)
12417 if (stub_type == ppc_stub_plt_call
12418 && irela + 1 < irelaend
12419 && irela[1].r_offset == irela->r_offset + 4
12420 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12422 if (!tocsave_find (htab, INSERT,
12423 &local_syms, irela + 1, input_bfd))
12424 goto error_ret_free_internal;
12426 else if (stub_type == ppc_stub_plt_call)
12427 stub_type = ppc_stub_plt_call_r2save;
12429 /* Support for grouping stub sections. */
12430 id_sec = htab->sec_info[section->id].u.group->link_sec;
12432 /* Get the name of this stub. */
12433 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12435 goto error_ret_free_internal;
12437 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12438 stub_name, FALSE, FALSE);
12439 if (stub_entry != NULL)
12441 /* The proper stub has already been created. */
12443 if (stub_type == ppc_stub_plt_call_r2save)
12444 stub_entry->stub_type = stub_type;
12448 stub_entry = ppc_add_stub (stub_name, section, info);
12449 if (stub_entry == NULL)
12452 error_ret_free_internal:
12453 if (elf_section_data (section)->relocs == NULL)
12454 free (internal_relocs);
12455 error_ret_free_local:
12456 if (local_syms != NULL
12457 && (symtab_hdr->contents
12458 != (unsigned char *) local_syms))
12463 stub_entry->stub_type = stub_type;
12464 if (stub_type != ppc_stub_plt_call
12465 && stub_type != ppc_stub_plt_call_r2save)
12467 stub_entry->target_value = code_value;
12468 stub_entry->target_section = code_sec;
12472 stub_entry->target_value = sym_value;
12473 stub_entry->target_section = sym_sec;
12475 stub_entry->h = hash;
12476 stub_entry->plt_ent = plt_ent;
12477 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12479 if (stub_entry->h != NULL)
12480 htab->stub_globals += 1;
12483 /* We're done with the internal relocs, free them. */
12484 if (elf_section_data (section)->relocs != internal_relocs)
12485 free (internal_relocs);
12488 if (local_syms != NULL
12489 && symtab_hdr->contents != (unsigned char *) local_syms)
12491 if (!info->keep_memory)
12494 symtab_hdr->contents = (unsigned char *) local_syms;
12498 /* We may have added some stubs. Find out the new size of the
12500 for (stub_sec = htab->params->stub_bfd->sections;
12502 stub_sec = stub_sec->next)
12503 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12505 stub_sec->rawsize = stub_sec->size;
12506 stub_sec->size = 0;
12507 stub_sec->reloc_count = 0;
12508 stub_sec->flags &= ~SEC_RELOC;
12511 htab->brlt->size = 0;
12512 htab->brlt->reloc_count = 0;
12513 htab->brlt->flags &= ~SEC_RELOC;
12514 if (htab->relbrlt != NULL)
12515 htab->relbrlt->size = 0;
12517 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12519 for (group = htab->group; group != NULL; group = group->next)
12520 if (group->needs_save_res)
12521 group->stub_sec->size += htab->sfpr->size;
12523 if (info->emitrelocations
12524 && htab->glink != NULL && htab->glink->size != 0)
12526 htab->glink->reloc_count = 1;
12527 htab->glink->flags |= SEC_RELOC;
12530 if (htab->glink_eh_frame != NULL
12531 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12532 && htab->glink_eh_frame->output_section->size != 0)
12534 size_t size = 0, align;
12536 for (stub_sec = htab->params->stub_bfd->sections;
12538 stub_sec = stub_sec->next)
12539 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12541 if (htab->glink != NULL && htab->glink->size != 0)
12544 size += sizeof (glink_eh_frame_cie);
12546 align <<= htab->glink_eh_frame->output_section->alignment_power;
12548 size = (size + align) & ~align;
12549 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12550 htab->glink_eh_frame->size = size;
12553 if (htab->params->plt_stub_align != 0)
12554 for (stub_sec = htab->params->stub_bfd->sections;
12556 stub_sec = stub_sec->next)
12557 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12558 stub_sec->size = ((stub_sec->size
12559 + (1 << htab->params->plt_stub_align) - 1)
12560 & -(1 << htab->params->plt_stub_align));
12562 for (stub_sec = htab->params->stub_bfd->sections;
12564 stub_sec = stub_sec->next)
12565 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12566 && stub_sec->rawsize != stub_sec->size)
12569 /* Exit from this loop when no stubs have been added, and no stubs
12570 have changed size. */
12571 if (stub_sec == NULL
12572 && (htab->glink_eh_frame == NULL
12573 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12576 /* Ask the linker to do its stuff. */
12577 (*htab->params->layout_sections_again) ();
12580 if (htab->glink_eh_frame != NULL
12581 && htab->glink_eh_frame->size != 0)
12584 bfd_byte *p, *last_fde;
12585 size_t last_fde_len, size, align, pad;
12586 asection *stub_sec;
12588 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12591 htab->glink_eh_frame->contents = p;
12594 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12595 /* CIE length (rewrite in case little-endian). */
12596 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12597 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12598 p += sizeof (glink_eh_frame_cie);
12600 for (stub_sec = htab->params->stub_bfd->sections;
12602 stub_sec = stub_sec->next)
12603 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12608 bfd_put_32 (htab->elf.dynobj, 20, p);
12611 val = p - htab->glink_eh_frame->contents;
12612 bfd_put_32 (htab->elf.dynobj, val, p);
12614 /* Offset to stub section, written later. */
12616 /* stub section size. */
12617 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12619 /* Augmentation. */
12624 if (htab->glink != NULL && htab->glink->size != 0)
12629 bfd_put_32 (htab->elf.dynobj, 20, p);
12632 val = p - htab->glink_eh_frame->contents;
12633 bfd_put_32 (htab->elf.dynobj, val, p);
12635 /* Offset to .glink, written later. */
12638 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12640 /* Augmentation. */
12643 *p++ = DW_CFA_advance_loc + 1;
12644 *p++ = DW_CFA_register;
12646 *p++ = htab->opd_abi ? 12 : 0;
12647 *p++ = DW_CFA_advance_loc + 4;
12648 *p++ = DW_CFA_restore_extended;
12651 /* Subsume any padding into the last FDE if user .eh_frame
12652 sections are aligned more than glink_eh_frame. Otherwise any
12653 zero padding will be seen as a terminator. */
12654 size = p - htab->glink_eh_frame->contents;
12656 align <<= htab->glink_eh_frame->output_section->alignment_power;
12658 pad = ((size + align) & ~align) - size;
12659 htab->glink_eh_frame->size = size + pad;
12660 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12663 maybe_strip_output (info, htab->brlt);
12664 if (htab->glink_eh_frame != NULL)
12665 maybe_strip_output (info, htab->glink_eh_frame);
12670 /* Called after we have determined section placement. If sections
12671 move, we'll be called again. Provide a value for TOCstart. */
12674 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12677 bfd_vma TOCstart, adjust;
12681 struct elf_link_hash_entry *h;
12682 struct elf_link_hash_table *htab = elf_hash_table (info);
12684 if (is_elf_hash_table (htab)
12685 && htab->hgot != NULL)
12689 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12690 if (is_elf_hash_table (htab))
12694 && h->root.type == bfd_link_hash_defined
12695 && !h->root.linker_def
12696 && (!is_elf_hash_table (htab)
12697 || h->def_regular))
12699 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12700 + h->root.u.def.section->output_offset
12701 + h->root.u.def.section->output_section->vma);
12702 _bfd_set_gp_value (obfd, TOCstart);
12707 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12708 order. The TOC starts where the first of these sections starts. */
12709 s = bfd_get_section_by_name (obfd, ".got");
12710 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12711 s = bfd_get_section_by_name (obfd, ".toc");
12712 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12713 s = bfd_get_section_by_name (obfd, ".tocbss");
12714 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12715 s = bfd_get_section_by_name (obfd, ".plt");
12716 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12718 /* This may happen for
12719 o references to TOC base (SYM@toc / TOC[tc0]) without a
12721 o bad linker script
12722 o --gc-sections and empty TOC sections
12724 FIXME: Warn user? */
12726 /* Look for a likely section. We probably won't even be
12728 for (s = obfd->sections; s != NULL; s = s->next)
12729 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12731 == (SEC_ALLOC | SEC_SMALL_DATA))
12734 for (s = obfd->sections; s != NULL; s = s->next)
12735 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12736 == (SEC_ALLOC | SEC_SMALL_DATA))
12739 for (s = obfd->sections; s != NULL; s = s->next)
12740 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12744 for (s = obfd->sections; s != NULL; s = s->next)
12745 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12751 TOCstart = s->output_section->vma + s->output_offset;
12753 /* Force alignment. */
12754 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12755 TOCstart -= adjust;
12756 _bfd_set_gp_value (obfd, TOCstart);
12758 if (info != NULL && s != NULL)
12760 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12764 if (htab->elf.hgot != NULL)
12766 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12767 htab->elf.hgot->root.u.def.section = s;
12772 struct bfd_link_hash_entry *bh = NULL;
12773 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12774 s, TOC_BASE_OFF - adjust,
12775 NULL, FALSE, FALSE, &bh);
12781 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12782 write out any global entry stubs. */
12785 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12787 struct bfd_link_info *info;
12788 struct ppc_link_hash_table *htab;
12789 struct plt_entry *pent;
12792 if (h->root.type == bfd_link_hash_indirect)
12795 if (!h->pointer_equality_needed)
12798 if (h->def_regular)
12802 htab = ppc_hash_table (info);
12807 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12808 if (pent->plt.offset != (bfd_vma) -1
12809 && pent->addend == 0)
12815 p = s->contents + h->root.u.def.value;
12816 plt = htab->elf.splt;
12817 if (!htab->elf.dynamic_sections_created
12818 || h->dynindx == -1)
12819 plt = htab->elf.iplt;
12820 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12821 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12823 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12825 info->callbacks->einfo
12826 (_("%P: linkage table error against `%T'\n"),
12827 h->root.root.string);
12828 bfd_set_error (bfd_error_bad_value);
12829 htab->stub_error = TRUE;
12832 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12833 if (htab->params->emit_stub_syms)
12835 size_t len = strlen (h->root.root.string);
12836 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12841 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12842 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12845 if (h->root.type == bfd_link_hash_new)
12847 h->root.type = bfd_link_hash_defined;
12848 h->root.u.def.section = s;
12849 h->root.u.def.value = p - s->contents;
12850 h->ref_regular = 1;
12851 h->def_regular = 1;
12852 h->ref_regular_nonweak = 1;
12853 h->forced_local = 1;
12855 h->root.linker_def = 1;
12859 if (PPC_HA (off) != 0)
12861 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12864 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12866 bfd_put_32 (s->owner, MTCTR_R12, p);
12868 bfd_put_32 (s->owner, BCTR, p);
12874 /* Build all the stubs associated with the current output file.
12875 The stubs are kept in a hash table attached to the main linker
12876 hash table. This function is called via gldelf64ppc_finish. */
12879 ppc64_elf_build_stubs (struct bfd_link_info *info,
12882 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12883 struct map_stub *group;
12884 asection *stub_sec;
12886 int stub_sec_count = 0;
12891 /* Allocate memory to hold the linker stubs. */
12892 for (stub_sec = htab->params->stub_bfd->sections;
12894 stub_sec = stub_sec->next)
12895 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12896 && stub_sec->size != 0)
12898 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12899 if (stub_sec->contents == NULL)
12901 /* We want to check that built size is the same as calculated
12902 size. rawsize is a convenient location to use. */
12903 stub_sec->rawsize = stub_sec->size;
12904 stub_sec->size = 0;
12907 if (htab->glink != NULL && htab->glink->size != 0)
12912 /* Build the .glink plt call stub. */
12913 if (htab->params->emit_stub_syms)
12915 struct elf_link_hash_entry *h;
12916 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12917 TRUE, FALSE, FALSE);
12920 if (h->root.type == bfd_link_hash_new)
12922 h->root.type = bfd_link_hash_defined;
12923 h->root.u.def.section = htab->glink;
12924 h->root.u.def.value = 8;
12925 h->ref_regular = 1;
12926 h->def_regular = 1;
12927 h->ref_regular_nonweak = 1;
12928 h->forced_local = 1;
12930 h->root.linker_def = 1;
12933 plt0 = (htab->elf.splt->output_section->vma
12934 + htab->elf.splt->output_offset
12936 if (info->emitrelocations)
12938 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12941 r->r_offset = (htab->glink->output_offset
12942 + htab->glink->output_section->vma);
12943 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12944 r->r_addend = plt0;
12946 p = htab->glink->contents;
12947 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12948 bfd_put_64 (htab->glink->owner, plt0, p);
12952 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12954 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12956 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12958 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12960 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12962 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12964 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12966 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12968 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12970 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12975 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12977 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12979 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12981 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12983 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12985 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12987 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12989 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12991 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12993 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12995 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12997 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13000 bfd_put_32 (htab->glink->owner, BCTR, p);
13002 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13004 bfd_put_32 (htab->glink->owner, NOP, p);
13008 /* Build the .glink lazy link call stubs. */
13010 while (p < htab->glink->contents + htab->glink->rawsize)
13016 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13021 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13023 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13028 bfd_put_32 (htab->glink->owner,
13029 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13034 /* Build .glink global entry stubs. */
13035 if (htab->glink->size > htab->glink->rawsize)
13036 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13039 if (htab->brlt != NULL && htab->brlt->size != 0)
13041 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13043 if (htab->brlt->contents == NULL)
13046 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13048 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13049 htab->relbrlt->size);
13050 if (htab->relbrlt->contents == NULL)
13054 /* Build the stubs as directed by the stub hash table. */
13055 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13057 for (group = htab->group; group != NULL; group = group->next)
13058 if (group->needs_save_res)
13060 stub_sec = group->stub_sec;
13061 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13063 if (htab->params->emit_stub_syms)
13067 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13068 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13071 stub_sec->size += htab->sfpr->size;
13074 if (htab->relbrlt != NULL)
13075 htab->relbrlt->reloc_count = 0;
13077 if (htab->params->plt_stub_align != 0)
13078 for (stub_sec = htab->params->stub_bfd->sections;
13080 stub_sec = stub_sec->next)
13081 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13082 stub_sec->size = ((stub_sec->size
13083 + (1 << htab->params->plt_stub_align) - 1)
13084 & -(1 << htab->params->plt_stub_align));
13086 for (stub_sec = htab->params->stub_bfd->sections;
13088 stub_sec = stub_sec->next)
13089 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13091 stub_sec_count += 1;
13092 if (stub_sec->rawsize != stub_sec->size)
13096 /* Note that the glink_eh_frame check here is not only testing that
13097 the generated size matched the calculated size but also that
13098 bfd_elf_discard_info didn't make any changes to the section. */
13099 if (stub_sec != NULL
13100 || (htab->glink_eh_frame != NULL
13101 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13103 htab->stub_error = TRUE;
13104 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13107 if (htab->stub_error)
13112 *stats = bfd_malloc (500);
13113 if (*stats == NULL)
13116 sprintf (*stats, _("linker stubs in %u group%s\n"
13118 " toc adjust %lu\n"
13119 " long branch %lu\n"
13120 " long toc adj %lu\n"
13122 " plt call toc %lu\n"
13123 " global entry %lu"),
13125 stub_sec_count == 1 ? "" : "s",
13126 htab->stub_count[ppc_stub_long_branch - 1],
13127 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13128 htab->stub_count[ppc_stub_plt_branch - 1],
13129 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13130 htab->stub_count[ppc_stub_plt_call - 1],
13131 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13132 htab->stub_count[ppc_stub_global_entry - 1]);
13137 /* This function undoes the changes made by add_symbol_adjust. */
13140 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13142 struct ppc_link_hash_entry *eh;
13144 if (h->root.type == bfd_link_hash_indirect)
13147 eh = (struct ppc_link_hash_entry *) h;
13148 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13151 eh->elf.root.type = bfd_link_hash_undefined;
13156 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13158 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13161 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13164 /* What to do when ld finds relocations against symbols defined in
13165 discarded sections. */
13167 static unsigned int
13168 ppc64_elf_action_discarded (asection *sec)
13170 if (strcmp (".opd", sec->name) == 0)
13173 if (strcmp (".toc", sec->name) == 0)
13176 if (strcmp (".toc1", sec->name) == 0)
13179 return _bfd_elf_default_action_discarded (sec);
13182 /* The RELOCATE_SECTION function is called by the ELF backend linker
13183 to handle the relocations for a section.
13185 The relocs are always passed as Rela structures; if the section
13186 actually uses Rel structures, the r_addend field will always be
13189 This function is responsible for adjust the section contents as
13190 necessary, and (if using Rela relocs and generating a
13191 relocatable output file) adjusting the reloc addend as
13194 This function does not have to worry about setting the reloc
13195 address or the reloc symbol index.
13197 LOCAL_SYMS is a pointer to the swapped in local symbols.
13199 LOCAL_SECTIONS is an array giving the section in the input file
13200 corresponding to the st_shndx field of each local symbol.
13202 The global hash table entry for the global symbols can be found
13203 via elf_sym_hashes (input_bfd).
13205 When generating relocatable output, this function must handle
13206 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13207 going to be the section symbol corresponding to the output
13208 section, which means that the addend must be adjusted
13212 ppc64_elf_relocate_section (bfd *output_bfd,
13213 struct bfd_link_info *info,
13215 asection *input_section,
13216 bfd_byte *contents,
13217 Elf_Internal_Rela *relocs,
13218 Elf_Internal_Sym *local_syms,
13219 asection **local_sections)
13221 struct ppc_link_hash_table *htab;
13222 Elf_Internal_Shdr *symtab_hdr;
13223 struct elf_link_hash_entry **sym_hashes;
13224 Elf_Internal_Rela *rel;
13225 Elf_Internal_Rela *wrel;
13226 Elf_Internal_Rela *relend;
13227 Elf_Internal_Rela outrel;
13229 struct got_entry **local_got_ents;
13231 bfd_boolean ret = TRUE;
13232 bfd_boolean is_opd;
13233 /* Assume 'at' branch hints. */
13234 bfd_boolean is_isa_v2 = TRUE;
13235 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13237 /* Initialize howto table if needed. */
13238 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13241 htab = ppc_hash_table (info);
13245 /* Don't relocate stub sections. */
13246 if (input_section->owner == htab->params->stub_bfd)
13249 BFD_ASSERT (is_ppc64_elf (input_bfd));
13251 local_got_ents = elf_local_got_ents (input_bfd);
13252 TOCstart = elf_gp (output_bfd);
13253 symtab_hdr = &elf_symtab_hdr (input_bfd);
13254 sym_hashes = elf_sym_hashes (input_bfd);
13255 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13257 rel = wrel = relocs;
13258 relend = relocs + input_section->reloc_count;
13259 for (; rel < relend; wrel++, rel++)
13261 enum elf_ppc64_reloc_type r_type;
13263 bfd_reloc_status_type r;
13264 Elf_Internal_Sym *sym;
13266 struct elf_link_hash_entry *h_elf;
13267 struct ppc_link_hash_entry *h;
13268 struct ppc_link_hash_entry *fdh;
13269 const char *sym_name;
13270 unsigned long r_symndx, toc_symndx;
13271 bfd_vma toc_addend;
13272 unsigned char tls_mask, tls_gd, tls_type;
13273 unsigned char sym_type;
13274 bfd_vma relocation;
13275 bfd_boolean unresolved_reloc;
13276 bfd_boolean warned;
13277 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13280 struct ppc_stub_hash_entry *stub_entry;
13281 bfd_vma max_br_offset;
13283 Elf_Internal_Rela orig_rel;
13284 reloc_howto_type *howto;
13285 struct reloc_howto_struct alt_howto;
13290 r_type = ELF64_R_TYPE (rel->r_info);
13291 r_symndx = ELF64_R_SYM (rel->r_info);
13293 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13294 symbol of the previous ADDR64 reloc. The symbol gives us the
13295 proper TOC base to use. */
13296 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13298 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13300 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13306 unresolved_reloc = FALSE;
13309 if (r_symndx < symtab_hdr->sh_info)
13311 /* It's a local symbol. */
13312 struct _opd_sec_data *opd;
13314 sym = local_syms + r_symndx;
13315 sec = local_sections[r_symndx];
13316 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13317 sym_type = ELF64_ST_TYPE (sym->st_info);
13318 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13319 opd = get_opd_info (sec);
13320 if (opd != NULL && opd->adjust != NULL)
13322 long adjust = opd->adjust[OPD_NDX (sym->st_value
13328 /* If this is a relocation against the opd section sym
13329 and we have edited .opd, adjust the reloc addend so
13330 that ld -r and ld --emit-relocs output is correct.
13331 If it is a reloc against some other .opd symbol,
13332 then the symbol value will be adjusted later. */
13333 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13334 rel->r_addend += adjust;
13336 relocation += adjust;
13342 bfd_boolean ignored;
13344 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13345 r_symndx, symtab_hdr, sym_hashes,
13346 h_elf, sec, relocation,
13347 unresolved_reloc, warned, ignored);
13348 sym_name = h_elf->root.root.string;
13349 sym_type = h_elf->type;
13351 && sec->owner == output_bfd
13352 && strcmp (sec->name, ".opd") == 0)
13354 /* This is a symbol defined in a linker script. All
13355 such are defined in output sections, even those
13356 defined by simple assignment from a symbol defined in
13357 an input section. Transfer the symbol to an
13358 appropriate input .opd section, so that a branch to
13359 this symbol will be mapped to the location specified
13360 by the opd entry. */
13361 struct bfd_link_order *lo;
13362 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13363 if (lo->type == bfd_indirect_link_order)
13365 asection *isec = lo->u.indirect.section;
13366 if (h_elf->root.u.def.value >= isec->output_offset
13367 && h_elf->root.u.def.value < (isec->output_offset
13370 h_elf->root.u.def.value -= isec->output_offset;
13371 h_elf->root.u.def.section = isec;
13378 h = (struct ppc_link_hash_entry *) h_elf;
13380 if (sec != NULL && discarded_section (sec))
13382 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13383 input_bfd, input_section,
13384 contents + rel->r_offset);
13385 wrel->r_offset = rel->r_offset;
13387 wrel->r_addend = 0;
13389 /* For ld -r, remove relocations in debug sections against
13390 sections defined in discarded sections. Not done for
13391 non-debug to preserve relocs in .eh_frame which the
13392 eh_frame editing code expects to be present. */
13393 if (bfd_link_relocatable (info)
13394 && (input_section->flags & SEC_DEBUGGING))
13400 if (bfd_link_relocatable (info))
13403 if (h != NULL && &h->elf == htab->elf.hgot)
13405 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13406 sec = bfd_abs_section_ptr;
13407 unresolved_reloc = FALSE;
13410 /* TLS optimizations. Replace instruction sequences and relocs
13411 based on information we collected in tls_optimize. We edit
13412 RELOCS so that --emit-relocs will output something sensible
13413 for the final instruction stream. */
13418 tls_mask = h->tls_mask;
13419 else if (local_got_ents != NULL)
13421 struct plt_entry **local_plt = (struct plt_entry **)
13422 (local_got_ents + symtab_hdr->sh_info);
13423 unsigned char *lgot_masks = (unsigned char *)
13424 (local_plt + symtab_hdr->sh_info);
13425 tls_mask = lgot_masks[r_symndx];
13428 && (r_type == R_PPC64_TLS
13429 || r_type == R_PPC64_TLSGD
13430 || r_type == R_PPC64_TLSLD))
13432 /* Check for toc tls entries. */
13433 unsigned char *toc_tls;
13435 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13436 &local_syms, rel, input_bfd))
13440 tls_mask = *toc_tls;
13443 /* Check that tls relocs are used with tls syms, and non-tls
13444 relocs are used with non-tls syms. */
13445 if (r_symndx != STN_UNDEF
13446 && r_type != R_PPC64_NONE
13448 || h->elf.root.type == bfd_link_hash_defined
13449 || h->elf.root.type == bfd_link_hash_defweak)
13450 && (IS_PPC64_TLS_RELOC (r_type)
13451 != (sym_type == STT_TLS
13452 || (sym_type == STT_SECTION
13453 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13456 && (r_type == R_PPC64_TLS
13457 || r_type == R_PPC64_TLSGD
13458 || r_type == R_PPC64_TLSLD))
13459 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13462 info->callbacks->einfo
13463 (!IS_PPC64_TLS_RELOC (r_type)
13464 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13465 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13466 input_bfd, input_section, rel->r_offset,
13467 ppc64_elf_howto_table[r_type]->name,
13471 /* Ensure reloc mapping code below stays sane. */
13472 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13473 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13474 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13475 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13476 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13477 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13478 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13479 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13480 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13481 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13489 case R_PPC64_LO_DS_OPT:
13490 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13491 if ((insn & (0x3f << 26)) != 58u << 26)
13493 insn += (14u << 26) - (58u << 26);
13494 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13495 r_type = R_PPC64_TOC16_LO;
13496 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13499 case R_PPC64_TOC16:
13500 case R_PPC64_TOC16_LO:
13501 case R_PPC64_TOC16_DS:
13502 case R_PPC64_TOC16_LO_DS:
13504 /* Check for toc tls entries. */
13505 unsigned char *toc_tls;
13508 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13509 &local_syms, rel, input_bfd);
13515 tls_mask = *toc_tls;
13516 if (r_type == R_PPC64_TOC16_DS
13517 || r_type == R_PPC64_TOC16_LO_DS)
13520 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13525 /* If we found a GD reloc pair, then we might be
13526 doing a GD->IE transition. */
13529 tls_gd = TLS_TPRELGD;
13530 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13533 else if (retval == 3)
13535 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13543 case R_PPC64_GOT_TPREL16_HI:
13544 case R_PPC64_GOT_TPREL16_HA:
13546 && (tls_mask & TLS_TPREL) == 0)
13548 rel->r_offset -= d_offset;
13549 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13550 r_type = R_PPC64_NONE;
13551 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13555 case R_PPC64_GOT_TPREL16_DS:
13556 case R_PPC64_GOT_TPREL16_LO_DS:
13558 && (tls_mask & TLS_TPREL) == 0)
13561 insn = bfd_get_32 (output_bfd,
13562 contents + rel->r_offset - d_offset);
13564 insn |= 0x3c0d0000; /* addis 0,13,0 */
13565 bfd_put_32 (output_bfd, insn,
13566 contents + rel->r_offset - d_offset);
13567 r_type = R_PPC64_TPREL16_HA;
13568 if (toc_symndx != 0)
13570 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13571 rel->r_addend = toc_addend;
13572 /* We changed the symbol. Start over in order to
13573 get h, sym, sec etc. right. */
13577 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13583 && (tls_mask & TLS_TPREL) == 0)
13585 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13586 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13589 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13590 /* Was PPC64_TLS which sits on insn boundary, now
13591 PPC64_TPREL16_LO which is at low-order half-word. */
13592 rel->r_offset += d_offset;
13593 r_type = R_PPC64_TPREL16_LO;
13594 if (toc_symndx != 0)
13596 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13597 rel->r_addend = toc_addend;
13598 /* We changed the symbol. Start over in order to
13599 get h, sym, sec etc. right. */
13603 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13607 case R_PPC64_GOT_TLSGD16_HI:
13608 case R_PPC64_GOT_TLSGD16_HA:
13609 tls_gd = TLS_TPRELGD;
13610 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13614 case R_PPC64_GOT_TLSLD16_HI:
13615 case R_PPC64_GOT_TLSLD16_HA:
13616 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13619 if ((tls_mask & tls_gd) != 0)
13620 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13621 + R_PPC64_GOT_TPREL16_DS);
13624 rel->r_offset -= d_offset;
13625 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13626 r_type = R_PPC64_NONE;
13628 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13632 case R_PPC64_GOT_TLSGD16:
13633 case R_PPC64_GOT_TLSGD16_LO:
13634 tls_gd = TLS_TPRELGD;
13635 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13639 case R_PPC64_GOT_TLSLD16:
13640 case R_PPC64_GOT_TLSLD16_LO:
13641 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13643 unsigned int insn1, insn2, insn3;
13647 offset = (bfd_vma) -1;
13648 /* If not using the newer R_PPC64_TLSGD/LD to mark
13649 __tls_get_addr calls, we must trust that the call
13650 stays with its arg setup insns, ie. that the next
13651 reloc is the __tls_get_addr call associated with
13652 the current reloc. Edit both insns. */
13653 if (input_section->has_tls_get_addr_call
13654 && rel + 1 < relend
13655 && branch_reloc_hash_match (input_bfd, rel + 1,
13656 htab->tls_get_addr,
13657 htab->tls_get_addr_fd))
13658 offset = rel[1].r_offset;
13659 /* We read the low GOT_TLS (or TOC16) insn because we
13660 need to keep the destination reg. It may be
13661 something other than the usual r3, and moved to r3
13662 before the call by intervening code. */
13663 insn1 = bfd_get_32 (output_bfd,
13664 contents + rel->r_offset - d_offset);
13665 if ((tls_mask & tls_gd) != 0)
13668 insn1 &= (0x1f << 21) | (0x1f << 16);
13669 insn1 |= 58 << 26; /* ld */
13670 insn2 = 0x7c636a14; /* add 3,3,13 */
13671 if (offset != (bfd_vma) -1)
13672 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13673 if ((tls_mask & TLS_EXPLICIT) == 0)
13674 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13675 + R_PPC64_GOT_TPREL16_DS);
13677 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13678 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13683 insn1 &= 0x1f << 21;
13684 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13685 insn2 = 0x38630000; /* addi 3,3,0 */
13688 /* Was an LD reloc. */
13690 sec = local_sections[toc_symndx];
13692 r_symndx < symtab_hdr->sh_info;
13694 if (local_sections[r_symndx] == sec)
13696 if (r_symndx >= symtab_hdr->sh_info)
13697 r_symndx = STN_UNDEF;
13698 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13699 if (r_symndx != STN_UNDEF)
13700 rel->r_addend -= (local_syms[r_symndx].st_value
13701 + sec->output_offset
13702 + sec->output_section->vma);
13704 else if (toc_symndx != 0)
13706 r_symndx = toc_symndx;
13707 rel->r_addend = toc_addend;
13709 r_type = R_PPC64_TPREL16_HA;
13710 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13711 if (offset != (bfd_vma) -1)
13713 rel[1].r_info = ELF64_R_INFO (r_symndx,
13714 R_PPC64_TPREL16_LO);
13715 rel[1].r_offset = offset + d_offset;
13716 rel[1].r_addend = rel->r_addend;
13719 bfd_put_32 (output_bfd, insn1,
13720 contents + rel->r_offset - d_offset);
13721 if (offset != (bfd_vma) -1)
13723 insn3 = bfd_get_32 (output_bfd,
13724 contents + offset + 4);
13726 || insn3 == CROR_151515 || insn3 == CROR_313131)
13728 rel[1].r_offset += 4;
13729 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13732 bfd_put_32 (output_bfd, insn2, contents + offset);
13734 if ((tls_mask & tls_gd) == 0
13735 && (tls_gd == 0 || toc_symndx != 0))
13737 /* We changed the symbol. Start over in order
13738 to get h, sym, sec etc. right. */
13744 case R_PPC64_TLSGD:
13745 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13747 unsigned int insn2, insn3;
13748 bfd_vma offset = rel->r_offset;
13750 if ((tls_mask & TLS_TPRELGD) != 0)
13753 r_type = R_PPC64_NONE;
13754 insn2 = 0x7c636a14; /* add 3,3,13 */
13759 if (toc_symndx != 0)
13761 r_symndx = toc_symndx;
13762 rel->r_addend = toc_addend;
13764 r_type = R_PPC64_TPREL16_LO;
13765 rel->r_offset = offset + d_offset;
13766 insn2 = 0x38630000; /* addi 3,3,0 */
13768 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13769 /* Zap the reloc on the _tls_get_addr call too. */
13770 BFD_ASSERT (offset == rel[1].r_offset);
13771 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13772 insn3 = bfd_get_32 (output_bfd,
13773 contents + offset + 4);
13775 || insn3 == CROR_151515 || insn3 == CROR_313131)
13777 rel->r_offset += 4;
13778 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13781 bfd_put_32 (output_bfd, insn2, contents + offset);
13782 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13787 case R_PPC64_TLSLD:
13788 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13790 unsigned int insn2, insn3;
13791 bfd_vma offset = rel->r_offset;
13794 sec = local_sections[toc_symndx];
13796 r_symndx < symtab_hdr->sh_info;
13798 if (local_sections[r_symndx] == sec)
13800 if (r_symndx >= symtab_hdr->sh_info)
13801 r_symndx = STN_UNDEF;
13802 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13803 if (r_symndx != STN_UNDEF)
13804 rel->r_addend -= (local_syms[r_symndx].st_value
13805 + sec->output_offset
13806 + sec->output_section->vma);
13808 r_type = R_PPC64_TPREL16_LO;
13809 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13810 rel->r_offset = offset + d_offset;
13811 /* Zap the reloc on the _tls_get_addr call too. */
13812 BFD_ASSERT (offset == rel[1].r_offset);
13813 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13814 insn2 = 0x38630000; /* addi 3,3,0 */
13815 insn3 = bfd_get_32 (output_bfd,
13816 contents + offset + 4);
13818 || insn3 == CROR_151515 || insn3 == CROR_313131)
13820 rel->r_offset += 4;
13821 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13824 bfd_put_32 (output_bfd, insn2, contents + offset);
13829 case R_PPC64_DTPMOD64:
13830 if (rel + 1 < relend
13831 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13832 && rel[1].r_offset == rel->r_offset + 8)
13834 if ((tls_mask & TLS_GD) == 0)
13836 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13837 if ((tls_mask & TLS_TPRELGD) != 0)
13838 r_type = R_PPC64_TPREL64;
13841 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13842 r_type = R_PPC64_NONE;
13844 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13849 if ((tls_mask & TLS_LD) == 0)
13851 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13852 r_type = R_PPC64_NONE;
13853 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13858 case R_PPC64_TPREL64:
13859 if ((tls_mask & TLS_TPREL) == 0)
13861 r_type = R_PPC64_NONE;
13862 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13866 case R_PPC64_ENTRY:
13867 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13868 if (!bfd_link_pic (info)
13869 && !info->traditional_format
13870 && relocation + 0x80008000 <= 0xffffffff)
13872 unsigned int insn1, insn2;
13874 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13875 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13876 if ((insn1 & ~0xfffc) == LD_R2_0R12
13877 && insn2 == ADD_R2_R2_R12)
13879 bfd_put_32 (output_bfd,
13880 LIS_R2 + PPC_HA (relocation),
13881 contents + rel->r_offset);
13882 bfd_put_32 (output_bfd,
13883 ADDI_R2_R2 + PPC_LO (relocation),
13884 contents + rel->r_offset + 4);
13889 relocation -= (rel->r_offset
13890 + input_section->output_offset
13891 + input_section->output_section->vma);
13892 if (relocation + 0x80008000 <= 0xffffffff)
13894 unsigned int insn1, insn2;
13896 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13897 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13898 if ((insn1 & ~0xfffc) == LD_R2_0R12
13899 && insn2 == ADD_R2_R2_R12)
13901 bfd_put_32 (output_bfd,
13902 ADDIS_R2_R12 + PPC_HA (relocation),
13903 contents + rel->r_offset);
13904 bfd_put_32 (output_bfd,
13905 ADDI_R2_R2 + PPC_LO (relocation),
13906 contents + rel->r_offset + 4);
13912 case R_PPC64_REL16_HA:
13913 /* If we are generating a non-PIC executable, edit
13914 . 0: addis 2,12,.TOC.-0b@ha
13915 . addi 2,2,.TOC.-0b@l
13916 used by ELFv2 global entry points to set up r2, to
13919 if .TOC. is in range. */
13920 if (!bfd_link_pic (info)
13921 && !info->traditional_format
13923 && rel->r_addend == d_offset
13924 && h != NULL && &h->elf == htab->elf.hgot
13925 && rel + 1 < relend
13926 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13927 && rel[1].r_offset == rel->r_offset + 4
13928 && rel[1].r_addend == rel->r_addend + 4
13929 && relocation + 0x80008000 <= 0xffffffff)
13931 unsigned int insn1, insn2;
13932 bfd_vma offset = rel->r_offset - d_offset;
13933 insn1 = bfd_get_32 (output_bfd, contents + offset);
13934 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13935 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13936 && (insn2 & 0xffff0000) == ADDI_R2_R2)
13938 r_type = R_PPC64_ADDR16_HA;
13939 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13940 rel->r_addend -= d_offset;
13941 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13942 rel[1].r_addend -= d_offset + 4;
13943 bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13949 /* Handle other relocations that tweak non-addend part of insn. */
13951 max_br_offset = 1 << 25;
13952 addend = rel->r_addend;
13953 reloc_dest = DEST_NORMAL;
13959 case R_PPC64_TOCSAVE:
13960 if (relocation + addend == (rel->r_offset
13961 + input_section->output_offset
13962 + input_section->output_section->vma)
13963 && tocsave_find (htab, NO_INSERT,
13964 &local_syms, rel, input_bfd))
13966 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13968 || insn == CROR_151515 || insn == CROR_313131)
13969 bfd_put_32 (input_bfd,
13970 STD_R2_0R1 + STK_TOC (htab),
13971 contents + rel->r_offset);
13975 /* Branch taken prediction relocations. */
13976 case R_PPC64_ADDR14_BRTAKEN:
13977 case R_PPC64_REL14_BRTAKEN:
13978 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13981 /* Branch not taken prediction relocations. */
13982 case R_PPC64_ADDR14_BRNTAKEN:
13983 case R_PPC64_REL14_BRNTAKEN:
13984 insn |= bfd_get_32 (output_bfd,
13985 contents + rel->r_offset) & ~(0x01 << 21);
13988 case R_PPC64_REL14:
13989 max_br_offset = 1 << 15;
13992 case R_PPC64_REL24:
13993 /* Calls to functions with a different TOC, such as calls to
13994 shared objects, need to alter the TOC pointer. This is
13995 done using a linkage stub. A REL24 branching to these
13996 linkage stubs needs to be followed by a nop, as the nop
13997 will be replaced with an instruction to restore the TOC
14002 && h->oh->is_func_descriptor)
14003 fdh = ppc_follow_link (h->oh);
14004 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14006 if (stub_entry != NULL
14007 && (stub_entry->stub_type == ppc_stub_plt_call
14008 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14009 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14010 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14012 bfd_boolean can_plt_call = FALSE;
14014 /* All of these stubs will modify r2, so there must be a
14015 branch and link followed by a nop. The nop is
14016 replaced by an insn to restore r2. */
14017 if (rel->r_offset + 8 <= input_section->size)
14021 br = bfd_get_32 (input_bfd,
14022 contents + rel->r_offset);
14027 nop = bfd_get_32 (input_bfd,
14028 contents + rel->r_offset + 4);
14030 || nop == CROR_151515 || nop == CROR_313131)
14033 && (h == htab->tls_get_addr_fd
14034 || h == htab->tls_get_addr)
14035 && htab->params->tls_get_addr_opt)
14037 /* Special stub used, leave nop alone. */
14040 bfd_put_32 (input_bfd,
14041 LD_R2_0R1 + STK_TOC (htab),
14042 contents + rel->r_offset + 4);
14043 can_plt_call = TRUE;
14048 if (!can_plt_call && h != NULL)
14050 const char *name = h->elf.root.root.string;
14055 if (strncmp (name, "__libc_start_main", 17) == 0
14056 && (name[17] == 0 || name[17] == '@'))
14058 /* Allow crt1 branch to go via a toc adjusting
14059 stub. Other calls that never return could do
14060 the same, if we could detect such. */
14061 can_plt_call = TRUE;
14067 /* g++ as of 20130507 emits self-calls without a
14068 following nop. This is arguably wrong since we
14069 have conflicting information. On the one hand a
14070 global symbol and on the other a local call
14071 sequence, but don't error for this special case.
14072 It isn't possible to cheaply verify we have
14073 exactly such a call. Allow all calls to the same
14075 asection *code_sec = sec;
14077 if (get_opd_info (sec) != NULL)
14079 bfd_vma off = (relocation + addend
14080 - sec->output_section->vma
14081 - sec->output_offset);
14083 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14085 if (code_sec == input_section)
14086 can_plt_call = TRUE;
14091 if (stub_entry->stub_type == ppc_stub_plt_call
14092 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14093 info->callbacks->einfo
14094 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14095 "recompile with -fPIC\n"),
14096 input_bfd, input_section, rel->r_offset, sym_name);
14098 info->callbacks->einfo
14099 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14100 "(-mcmodel=small toc adjust stub)\n"),
14101 input_bfd, input_section, rel->r_offset, sym_name);
14103 bfd_set_error (bfd_error_bad_value);
14108 && (stub_entry->stub_type == ppc_stub_plt_call
14109 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14110 unresolved_reloc = FALSE;
14113 if ((stub_entry == NULL
14114 || stub_entry->stub_type == ppc_stub_long_branch
14115 || stub_entry->stub_type == ppc_stub_plt_branch)
14116 && get_opd_info (sec) != NULL)
14118 /* The branch destination is the value of the opd entry. */
14119 bfd_vma off = (relocation + addend
14120 - sec->output_section->vma
14121 - sec->output_offset);
14122 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14123 if (dest != (bfd_vma) -1)
14127 reloc_dest = DEST_OPD;
14131 /* If the branch is out of reach we ought to have a long
14133 from = (rel->r_offset
14134 + input_section->output_offset
14135 + input_section->output_section->vma);
14137 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14141 if (stub_entry != NULL
14142 && (stub_entry->stub_type == ppc_stub_long_branch
14143 || stub_entry->stub_type == ppc_stub_plt_branch)
14144 && (r_type == R_PPC64_ADDR14_BRTAKEN
14145 || r_type == R_PPC64_ADDR14_BRNTAKEN
14146 || (relocation + addend - from + max_br_offset
14147 < 2 * max_br_offset)))
14148 /* Don't use the stub if this branch is in range. */
14151 if (stub_entry != NULL)
14153 /* Munge up the value and addend so that we call the stub
14154 rather than the procedure directly. */
14155 asection *stub_sec = stub_entry->group->stub_sec;
14157 if (stub_entry->stub_type == ppc_stub_save_res)
14158 relocation += (stub_sec->output_offset
14159 + stub_sec->output_section->vma
14160 + stub_sec->size - htab->sfpr->size
14161 - htab->sfpr->output_offset
14162 - htab->sfpr->output_section->vma);
14164 relocation = (stub_entry->stub_offset
14165 + stub_sec->output_offset
14166 + stub_sec->output_section->vma);
14168 reloc_dest = DEST_STUB;
14170 if ((stub_entry->stub_type == ppc_stub_plt_call
14171 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14172 && (ALWAYS_EMIT_R2SAVE
14173 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14174 && rel + 1 < relend
14175 && rel[1].r_offset == rel->r_offset + 4
14176 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14184 /* Set 'a' bit. This is 0b00010 in BO field for branch
14185 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14186 for branch on CTR insns (BO == 1a00t or 1a01t). */
14187 if ((insn & (0x14 << 21)) == (0x04 << 21))
14188 insn |= 0x02 << 21;
14189 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14190 insn |= 0x08 << 21;
14196 /* Invert 'y' bit if not the default. */
14197 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14198 insn ^= 0x01 << 21;
14201 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14204 /* NOP out calls to undefined weak functions.
14205 We can thus call a weak function without first
14206 checking whether the function is defined. */
14208 && h->elf.root.type == bfd_link_hash_undefweak
14209 && h->elf.dynindx == -1
14210 && r_type == R_PPC64_REL24
14214 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14220 /* Set `addend'. */
14225 info->callbacks->einfo
14226 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14227 input_bfd, (int) r_type, sym_name);
14229 bfd_set_error (bfd_error_bad_value);
14235 case R_PPC64_TLSGD:
14236 case R_PPC64_TLSLD:
14237 case R_PPC64_TOCSAVE:
14238 case R_PPC64_GNU_VTINHERIT:
14239 case R_PPC64_GNU_VTENTRY:
14240 case R_PPC64_ENTRY:
14243 /* GOT16 relocations. Like an ADDR16 using the symbol's
14244 address in the GOT as relocation value instead of the
14245 symbol's value itself. Also, create a GOT entry for the
14246 symbol and put the symbol value there. */
14247 case R_PPC64_GOT_TLSGD16:
14248 case R_PPC64_GOT_TLSGD16_LO:
14249 case R_PPC64_GOT_TLSGD16_HI:
14250 case R_PPC64_GOT_TLSGD16_HA:
14251 tls_type = TLS_TLS | TLS_GD;
14254 case R_PPC64_GOT_TLSLD16:
14255 case R_PPC64_GOT_TLSLD16_LO:
14256 case R_PPC64_GOT_TLSLD16_HI:
14257 case R_PPC64_GOT_TLSLD16_HA:
14258 tls_type = TLS_TLS | TLS_LD;
14261 case R_PPC64_GOT_TPREL16_DS:
14262 case R_PPC64_GOT_TPREL16_LO_DS:
14263 case R_PPC64_GOT_TPREL16_HI:
14264 case R_PPC64_GOT_TPREL16_HA:
14265 tls_type = TLS_TLS | TLS_TPREL;
14268 case R_PPC64_GOT_DTPREL16_DS:
14269 case R_PPC64_GOT_DTPREL16_LO_DS:
14270 case R_PPC64_GOT_DTPREL16_HI:
14271 case R_PPC64_GOT_DTPREL16_HA:
14272 tls_type = TLS_TLS | TLS_DTPREL;
14275 case R_PPC64_GOT16:
14276 case R_PPC64_GOT16_LO:
14277 case R_PPC64_GOT16_HI:
14278 case R_PPC64_GOT16_HA:
14279 case R_PPC64_GOT16_DS:
14280 case R_PPC64_GOT16_LO_DS:
14283 /* Relocation is to the entry for this symbol in the global
14288 unsigned long indx = 0;
14289 struct got_entry *ent;
14291 if (tls_type == (TLS_TLS | TLS_LD)
14293 || !h->elf.def_dynamic))
14294 ent = ppc64_tlsld_got (input_bfd);
14300 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14301 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14303 || (bfd_link_pic (info)
14304 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14305 /* This is actually a static link, or it is a
14306 -Bsymbolic link and the symbol is defined
14307 locally, or the symbol was forced to be local
14308 because of a version file. */
14312 BFD_ASSERT (h->elf.dynindx != -1);
14313 indx = h->elf.dynindx;
14314 unresolved_reloc = FALSE;
14316 ent = h->elf.got.glist;
14320 if (local_got_ents == NULL)
14322 ent = local_got_ents[r_symndx];
14325 for (; ent != NULL; ent = ent->next)
14326 if (ent->addend == orig_rel.r_addend
14327 && ent->owner == input_bfd
14328 && ent->tls_type == tls_type)
14334 if (ent->is_indirect)
14335 ent = ent->got.ent;
14336 offp = &ent->got.offset;
14337 got = ppc64_elf_tdata (ent->owner)->got;
14341 /* The offset must always be a multiple of 8. We use the
14342 least significant bit to record whether we have already
14343 processed this entry. */
14345 if ((off & 1) != 0)
14349 /* Generate relocs for the dynamic linker, except in
14350 the case of TLSLD where we'll use one entry per
14358 ? h->elf.type == STT_GNU_IFUNC
14359 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14361 relgot = htab->elf.irelplt;
14362 else if ((bfd_link_pic (info) || indx != 0)
14364 || (tls_type == (TLS_TLS | TLS_LD)
14365 && !h->elf.def_dynamic)
14366 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14367 || h->elf.root.type != bfd_link_hash_undefweak))
14368 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14369 if (relgot != NULL)
14371 outrel.r_offset = (got->output_section->vma
14372 + got->output_offset
14374 outrel.r_addend = addend;
14375 if (tls_type & (TLS_LD | TLS_GD))
14377 outrel.r_addend = 0;
14378 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14379 if (tls_type == (TLS_TLS | TLS_GD))
14381 loc = relgot->contents;
14382 loc += (relgot->reloc_count++
14383 * sizeof (Elf64_External_Rela));
14384 bfd_elf64_swap_reloca_out (output_bfd,
14386 outrel.r_offset += 8;
14387 outrel.r_addend = addend;
14389 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14392 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14393 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14394 else if (tls_type == (TLS_TLS | TLS_TPREL))
14395 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14396 else if (indx != 0)
14397 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14401 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14403 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14405 /* Write the .got section contents for the sake
14407 loc = got->contents + off;
14408 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14412 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14414 outrel.r_addend += relocation;
14415 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14417 if (htab->elf.tls_sec == NULL)
14418 outrel.r_addend = 0;
14420 outrel.r_addend -= htab->elf.tls_sec->vma;
14423 loc = relgot->contents;
14424 loc += (relgot->reloc_count++
14425 * sizeof (Elf64_External_Rela));
14426 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14429 /* Init the .got section contents here if we're not
14430 emitting a reloc. */
14433 relocation += addend;
14434 if (tls_type == (TLS_TLS | TLS_LD))
14436 else if (tls_type != 0)
14438 if (htab->elf.tls_sec == NULL)
14442 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14443 if (tls_type == (TLS_TLS | TLS_TPREL))
14444 relocation += DTP_OFFSET - TP_OFFSET;
14447 if (tls_type == (TLS_TLS | TLS_GD))
14449 bfd_put_64 (output_bfd, relocation,
14450 got->contents + off + 8);
14455 bfd_put_64 (output_bfd, relocation,
14456 got->contents + off);
14460 if (off >= (bfd_vma) -2)
14463 relocation = got->output_section->vma + got->output_offset + off;
14464 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14468 case R_PPC64_PLT16_HA:
14469 case R_PPC64_PLT16_HI:
14470 case R_PPC64_PLT16_LO:
14471 case R_PPC64_PLT32:
14472 case R_PPC64_PLT64:
14473 /* Relocation is to the entry for this symbol in the
14474 procedure linkage table. */
14476 struct plt_entry **plt_list = NULL;
14478 plt_list = &h->elf.plt.plist;
14479 else if (local_got_ents != NULL)
14481 struct plt_entry **local_plt = (struct plt_entry **)
14482 (local_got_ents + symtab_hdr->sh_info);
14483 unsigned char *local_got_tls_masks = (unsigned char *)
14484 (local_plt + symtab_hdr->sh_info);
14485 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14486 plt_list = local_plt + r_symndx;
14490 struct plt_entry *ent;
14492 for (ent = *plt_list; ent != NULL; ent = ent->next)
14493 if (ent->plt.offset != (bfd_vma) -1
14494 && ent->addend == orig_rel.r_addend)
14498 plt = htab->elf.splt;
14499 if (!htab->elf.dynamic_sections_created
14501 || h->elf.dynindx == -1)
14502 plt = htab->elf.iplt;
14503 relocation = (plt->output_section->vma
14504 + plt->output_offset
14505 + ent->plt.offset);
14507 unresolved_reloc = FALSE;
14515 /* Relocation value is TOC base. */
14516 relocation = TOCstart;
14517 if (r_symndx == STN_UNDEF)
14518 relocation += htab->sec_info[input_section->id].toc_off;
14519 else if (unresolved_reloc)
14521 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14522 relocation += htab->sec_info[sec->id].toc_off;
14524 unresolved_reloc = TRUE;
14527 /* TOC16 relocs. We want the offset relative to the TOC base,
14528 which is the address of the start of the TOC plus 0x8000.
14529 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14531 case R_PPC64_TOC16:
14532 case R_PPC64_TOC16_LO:
14533 case R_PPC64_TOC16_HI:
14534 case R_PPC64_TOC16_DS:
14535 case R_PPC64_TOC16_LO_DS:
14536 case R_PPC64_TOC16_HA:
14537 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14540 /* Relocate against the beginning of the section. */
14541 case R_PPC64_SECTOFF:
14542 case R_PPC64_SECTOFF_LO:
14543 case R_PPC64_SECTOFF_HI:
14544 case R_PPC64_SECTOFF_DS:
14545 case R_PPC64_SECTOFF_LO_DS:
14546 case R_PPC64_SECTOFF_HA:
14548 addend -= sec->output_section->vma;
14551 case R_PPC64_REL16:
14552 case R_PPC64_REL16_LO:
14553 case R_PPC64_REL16_HI:
14554 case R_PPC64_REL16_HA:
14555 case R_PPC64_REL16DX_HA:
14558 case R_PPC64_REL14:
14559 case R_PPC64_REL14_BRNTAKEN:
14560 case R_PPC64_REL14_BRTAKEN:
14561 case R_PPC64_REL24:
14564 case R_PPC64_TPREL16:
14565 case R_PPC64_TPREL16_LO:
14566 case R_PPC64_TPREL16_HI:
14567 case R_PPC64_TPREL16_HA:
14568 case R_PPC64_TPREL16_DS:
14569 case R_PPC64_TPREL16_LO_DS:
14570 case R_PPC64_TPREL16_HIGH:
14571 case R_PPC64_TPREL16_HIGHA:
14572 case R_PPC64_TPREL16_HIGHER:
14573 case R_PPC64_TPREL16_HIGHERA:
14574 case R_PPC64_TPREL16_HIGHEST:
14575 case R_PPC64_TPREL16_HIGHESTA:
14577 && h->elf.root.type == bfd_link_hash_undefweak
14578 && h->elf.dynindx == -1)
14580 /* Make this relocation against an undefined weak symbol
14581 resolve to zero. This is really just a tweak, since
14582 code using weak externs ought to check that they are
14583 defined before using them. */
14584 bfd_byte *p = contents + rel->r_offset - d_offset;
14586 insn = bfd_get_32 (output_bfd, p);
14587 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14589 bfd_put_32 (output_bfd, insn, p);
14592 if (htab->elf.tls_sec != NULL)
14593 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14594 if (bfd_link_pic (info))
14595 /* The TPREL16 relocs shouldn't really be used in shared
14596 libs as they will result in DT_TEXTREL being set, but
14597 support them anyway. */
14601 case R_PPC64_DTPREL16:
14602 case R_PPC64_DTPREL16_LO:
14603 case R_PPC64_DTPREL16_HI:
14604 case R_PPC64_DTPREL16_HA:
14605 case R_PPC64_DTPREL16_DS:
14606 case R_PPC64_DTPREL16_LO_DS:
14607 case R_PPC64_DTPREL16_HIGH:
14608 case R_PPC64_DTPREL16_HIGHA:
14609 case R_PPC64_DTPREL16_HIGHER:
14610 case R_PPC64_DTPREL16_HIGHERA:
14611 case R_PPC64_DTPREL16_HIGHEST:
14612 case R_PPC64_DTPREL16_HIGHESTA:
14613 if (htab->elf.tls_sec != NULL)
14614 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14617 case R_PPC64_ADDR64_LOCAL:
14618 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14623 case R_PPC64_DTPMOD64:
14628 case R_PPC64_TPREL64:
14629 if (htab->elf.tls_sec != NULL)
14630 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14633 case R_PPC64_DTPREL64:
14634 if (htab->elf.tls_sec != NULL)
14635 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14638 /* Relocations that may need to be propagated if this is a
14640 case R_PPC64_REL30:
14641 case R_PPC64_REL32:
14642 case R_PPC64_REL64:
14643 case R_PPC64_ADDR14:
14644 case R_PPC64_ADDR14_BRNTAKEN:
14645 case R_PPC64_ADDR14_BRTAKEN:
14646 case R_PPC64_ADDR16:
14647 case R_PPC64_ADDR16_DS:
14648 case R_PPC64_ADDR16_HA:
14649 case R_PPC64_ADDR16_HI:
14650 case R_PPC64_ADDR16_HIGH:
14651 case R_PPC64_ADDR16_HIGHA:
14652 case R_PPC64_ADDR16_HIGHER:
14653 case R_PPC64_ADDR16_HIGHERA:
14654 case R_PPC64_ADDR16_HIGHEST:
14655 case R_PPC64_ADDR16_HIGHESTA:
14656 case R_PPC64_ADDR16_LO:
14657 case R_PPC64_ADDR16_LO_DS:
14658 case R_PPC64_ADDR24:
14659 case R_PPC64_ADDR32:
14660 case R_PPC64_ADDR64:
14661 case R_PPC64_UADDR16:
14662 case R_PPC64_UADDR32:
14663 case R_PPC64_UADDR64:
14665 if ((input_section->flags & SEC_ALLOC) == 0)
14668 if (NO_OPD_RELOCS && is_opd)
14671 if ((bfd_link_pic (info)
14673 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14674 || h->elf.root.type != bfd_link_hash_undefweak)
14675 && (must_be_dyn_reloc (info, r_type)
14676 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14677 || (ELIMINATE_COPY_RELOCS
14678 && !bfd_link_pic (info)
14680 && h->elf.dynindx != -1
14681 && !h->elf.non_got_ref
14682 && !h->elf.def_regular)
14683 || (!bfd_link_pic (info)
14685 ? h->elf.type == STT_GNU_IFUNC
14686 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14688 bfd_boolean skip, relocate;
14692 /* When generating a dynamic object, these relocations
14693 are copied into the output file to be resolved at run
14699 out_off = _bfd_elf_section_offset (output_bfd, info,
14700 input_section, rel->r_offset);
14701 if (out_off == (bfd_vma) -1)
14703 else if (out_off == (bfd_vma) -2)
14704 skip = TRUE, relocate = TRUE;
14705 out_off += (input_section->output_section->vma
14706 + input_section->output_offset);
14707 outrel.r_offset = out_off;
14708 outrel.r_addend = rel->r_addend;
14710 /* Optimize unaligned reloc use. */
14711 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14712 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14713 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14714 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14715 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14716 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14717 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14718 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14719 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14722 memset (&outrel, 0, sizeof outrel);
14723 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14725 && r_type != R_PPC64_TOC)
14727 BFD_ASSERT (h->elf.dynindx != -1);
14728 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14732 /* This symbol is local, or marked to become local,
14733 or this is an opd section reloc which must point
14734 at a local function. */
14735 outrel.r_addend += relocation;
14736 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14738 if (is_opd && h != NULL)
14740 /* Lie about opd entries. This case occurs
14741 when building shared libraries and we
14742 reference a function in another shared
14743 lib. The same thing happens for a weak
14744 definition in an application that's
14745 overridden by a strong definition in a
14746 shared lib. (I believe this is a generic
14747 bug in binutils handling of weak syms.)
14748 In these cases we won't use the opd
14749 entry in this lib. */
14750 unresolved_reloc = FALSE;
14753 && r_type == R_PPC64_ADDR64
14755 ? h->elf.type == STT_GNU_IFUNC
14756 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14757 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14760 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14762 /* We need to relocate .opd contents for ld.so.
14763 Prelink also wants simple and consistent rules
14764 for relocs. This make all RELATIVE relocs have
14765 *r_offset equal to r_addend. */
14774 ? h->elf.type == STT_GNU_IFUNC
14775 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14777 info->callbacks->einfo
14778 (_("%P: %H: %s for indirect "
14779 "function `%T' unsupported\n"),
14780 input_bfd, input_section, rel->r_offset,
14781 ppc64_elf_howto_table[r_type]->name,
14785 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14787 else if (sec == NULL || sec->owner == NULL)
14789 bfd_set_error (bfd_error_bad_value);
14796 osec = sec->output_section;
14797 indx = elf_section_data (osec)->dynindx;
14801 if ((osec->flags & SEC_READONLY) == 0
14802 && htab->elf.data_index_section != NULL)
14803 osec = htab->elf.data_index_section;
14805 osec = htab->elf.text_index_section;
14806 indx = elf_section_data (osec)->dynindx;
14808 BFD_ASSERT (indx != 0);
14810 /* We are turning this relocation into one
14811 against a section symbol, so subtract out
14812 the output section's address but not the
14813 offset of the input section in the output
14815 outrel.r_addend -= osec->vma;
14818 outrel.r_info = ELF64_R_INFO (indx, r_type);
14822 sreloc = elf_section_data (input_section)->sreloc;
14824 ? h->elf.type == STT_GNU_IFUNC
14825 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14826 sreloc = htab->elf.irelplt;
14827 if (sreloc == NULL)
14830 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14833 loc = sreloc->contents;
14834 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14835 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14837 /* If this reloc is against an external symbol, it will
14838 be computed at runtime, so there's no need to do
14839 anything now. However, for the sake of prelink ensure
14840 that the section contents are a known value. */
14843 unresolved_reloc = FALSE;
14844 /* The value chosen here is quite arbitrary as ld.so
14845 ignores section contents except for the special
14846 case of .opd where the contents might be accessed
14847 before relocation. Choose zero, as that won't
14848 cause reloc overflow. */
14851 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14852 to improve backward compatibility with older
14854 if (r_type == R_PPC64_ADDR64)
14855 addend = outrel.r_addend;
14856 /* Adjust pc_relative relocs to have zero in *r_offset. */
14857 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14858 addend = (input_section->output_section->vma
14859 + input_section->output_offset
14866 case R_PPC64_GLOB_DAT:
14867 case R_PPC64_JMP_SLOT:
14868 case R_PPC64_JMP_IREL:
14869 case R_PPC64_RELATIVE:
14870 /* We shouldn't ever see these dynamic relocs in relocatable
14872 /* Fall through. */
14874 case R_PPC64_PLTGOT16:
14875 case R_PPC64_PLTGOT16_DS:
14876 case R_PPC64_PLTGOT16_HA:
14877 case R_PPC64_PLTGOT16_HI:
14878 case R_PPC64_PLTGOT16_LO:
14879 case R_PPC64_PLTGOT16_LO_DS:
14880 case R_PPC64_PLTREL32:
14881 case R_PPC64_PLTREL64:
14882 /* These ones haven't been implemented yet. */
14884 info->callbacks->einfo
14885 (_("%P: %B: %s is not supported for `%T'\n"),
14887 ppc64_elf_howto_table[r_type]->name, sym_name);
14889 bfd_set_error (bfd_error_invalid_operation);
14894 /* Multi-instruction sequences that access the TOC can be
14895 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14896 to nop; addi rb,r2,x; */
14902 case R_PPC64_GOT_TLSLD16_HI:
14903 case R_PPC64_GOT_TLSGD16_HI:
14904 case R_PPC64_GOT_TPREL16_HI:
14905 case R_PPC64_GOT_DTPREL16_HI:
14906 case R_PPC64_GOT16_HI:
14907 case R_PPC64_TOC16_HI:
14908 /* These relocs would only be useful if building up an
14909 offset to later add to r2, perhaps in an indexed
14910 addressing mode instruction. Don't try to optimize.
14911 Unfortunately, the possibility of someone building up an
14912 offset like this or even with the HA relocs, means that
14913 we need to check the high insn when optimizing the low
14917 case R_PPC64_GOT_TLSLD16_HA:
14918 case R_PPC64_GOT_TLSGD16_HA:
14919 case R_PPC64_GOT_TPREL16_HA:
14920 case R_PPC64_GOT_DTPREL16_HA:
14921 case R_PPC64_GOT16_HA:
14922 case R_PPC64_TOC16_HA:
14923 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14924 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14926 bfd_byte *p = contents + (rel->r_offset & ~3);
14927 bfd_put_32 (input_bfd, NOP, p);
14931 case R_PPC64_GOT_TLSLD16_LO:
14932 case R_PPC64_GOT_TLSGD16_LO:
14933 case R_PPC64_GOT_TPREL16_LO_DS:
14934 case R_PPC64_GOT_DTPREL16_LO_DS:
14935 case R_PPC64_GOT16_LO:
14936 case R_PPC64_GOT16_LO_DS:
14937 case R_PPC64_TOC16_LO:
14938 case R_PPC64_TOC16_LO_DS:
14939 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14940 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14942 bfd_byte *p = contents + (rel->r_offset & ~3);
14943 insn = bfd_get_32 (input_bfd, p);
14944 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14946 /* Transform addic to addi when we change reg. */
14947 insn &= ~((0x3f << 26) | (0x1f << 16));
14948 insn |= (14u << 26) | (2 << 16);
14952 insn &= ~(0x1f << 16);
14955 bfd_put_32 (input_bfd, insn, p);
14960 /* Do any further special processing. */
14961 howto = ppc64_elf_howto_table[(int) r_type];
14967 case R_PPC64_REL16_HA:
14968 case R_PPC64_REL16DX_HA:
14969 case R_PPC64_ADDR16_HA:
14970 case R_PPC64_ADDR16_HIGHA:
14971 case R_PPC64_ADDR16_HIGHERA:
14972 case R_PPC64_ADDR16_HIGHESTA:
14973 case R_PPC64_TOC16_HA:
14974 case R_PPC64_SECTOFF_HA:
14975 case R_PPC64_TPREL16_HA:
14976 case R_PPC64_TPREL16_HIGHA:
14977 case R_PPC64_TPREL16_HIGHERA:
14978 case R_PPC64_TPREL16_HIGHESTA:
14979 case R_PPC64_DTPREL16_HA:
14980 case R_PPC64_DTPREL16_HIGHA:
14981 case R_PPC64_DTPREL16_HIGHERA:
14982 case R_PPC64_DTPREL16_HIGHESTA:
14983 /* It's just possible that this symbol is a weak symbol
14984 that's not actually defined anywhere. In that case,
14985 'sec' would be NULL, and we should leave the symbol
14986 alone (it will be set to zero elsewhere in the link). */
14991 case R_PPC64_GOT16_HA:
14992 case R_PPC64_PLTGOT16_HA:
14993 case R_PPC64_PLT16_HA:
14994 case R_PPC64_GOT_TLSGD16_HA:
14995 case R_PPC64_GOT_TLSLD16_HA:
14996 case R_PPC64_GOT_TPREL16_HA:
14997 case R_PPC64_GOT_DTPREL16_HA:
14998 /* Add 0x10000 if sign bit in 0:15 is set.
14999 Bits 0:15 are not used. */
15003 case R_PPC64_ADDR16_DS:
15004 case R_PPC64_ADDR16_LO_DS:
15005 case R_PPC64_GOT16_DS:
15006 case R_PPC64_GOT16_LO_DS:
15007 case R_PPC64_PLT16_LO_DS:
15008 case R_PPC64_SECTOFF_DS:
15009 case R_PPC64_SECTOFF_LO_DS:
15010 case R_PPC64_TOC16_DS:
15011 case R_PPC64_TOC16_LO_DS:
15012 case R_PPC64_PLTGOT16_DS:
15013 case R_PPC64_PLTGOT16_LO_DS:
15014 case R_PPC64_GOT_TPREL16_DS:
15015 case R_PPC64_GOT_TPREL16_LO_DS:
15016 case R_PPC64_GOT_DTPREL16_DS:
15017 case R_PPC64_GOT_DTPREL16_LO_DS:
15018 case R_PPC64_TPREL16_DS:
15019 case R_PPC64_TPREL16_LO_DS:
15020 case R_PPC64_DTPREL16_DS:
15021 case R_PPC64_DTPREL16_LO_DS:
15022 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15024 /* If this reloc is against an lq, lxv, or stxv insn, then
15025 the value must be a multiple of 16. This is somewhat of
15026 a hack, but the "correct" way to do this by defining _DQ
15027 forms of all the _DS relocs bloats all reloc switches in
15028 this file. It doesn't make much sense to use these
15029 relocs in data, so testing the insn should be safe. */
15030 if ((insn & (0x3f << 26)) == (56u << 26)
15031 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15033 relocation += addend;
15034 addend = insn & (mask ^ 3);
15035 if ((relocation & mask) != 0)
15037 relocation ^= relocation & mask;
15038 info->callbacks->einfo
15039 (_("%P: %H: error: %s not a multiple of %u\n"),
15040 input_bfd, input_section, rel->r_offset,
15043 bfd_set_error (bfd_error_bad_value);
15050 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15051 because such sections are not SEC_ALLOC and thus ld.so will
15052 not process them. */
15053 if (unresolved_reloc
15054 && !((input_section->flags & SEC_DEBUGGING) != 0
15055 && h->elf.def_dynamic)
15056 && _bfd_elf_section_offset (output_bfd, info, input_section,
15057 rel->r_offset) != (bfd_vma) -1)
15059 info->callbacks->einfo
15060 (_("%P: %H: unresolvable %s against `%T'\n"),
15061 input_bfd, input_section, rel->r_offset,
15063 h->elf.root.root.string);
15067 /* 16-bit fields in insns mostly have signed values, but a
15068 few insns have 16-bit unsigned values. Really, we should
15069 have different reloc types. */
15070 if (howto->complain_on_overflow != complain_overflow_dont
15071 && howto->dst_mask == 0xffff
15072 && (input_section->flags & SEC_CODE) != 0)
15074 enum complain_overflow complain = complain_overflow_signed;
15076 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15077 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15078 complain = complain_overflow_bitfield;
15079 else if (howto->rightshift == 0
15080 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15081 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15082 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15083 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15084 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15085 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15086 complain = complain_overflow_unsigned;
15087 if (howto->complain_on_overflow != complain)
15089 alt_howto = *howto;
15090 alt_howto.complain_on_overflow = complain;
15091 howto = &alt_howto;
15095 if (r_type == R_PPC64_REL16DX_HA)
15097 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15098 if (rel->r_offset + 4 > input_section->size)
15099 r = bfd_reloc_outofrange;
15102 relocation += addend;
15103 relocation -= (rel->r_offset
15104 + input_section->output_offset
15105 + input_section->output_section->vma);
15106 relocation = (bfd_signed_vma) relocation >> 16;
15107 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15109 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15110 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15112 if (relocation + 0x8000 > 0xffff)
15113 r = bfd_reloc_overflow;
15117 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15118 rel->r_offset, relocation, addend);
15120 if (r != bfd_reloc_ok)
15122 char *more_info = NULL;
15123 const char *reloc_name = howto->name;
15125 if (reloc_dest != DEST_NORMAL)
15127 more_info = bfd_malloc (strlen (reloc_name) + 8);
15128 if (more_info != NULL)
15130 strcpy (more_info, reloc_name);
15131 strcat (more_info, (reloc_dest == DEST_OPD
15132 ? " (OPD)" : " (stub)"));
15133 reloc_name = more_info;
15137 if (r == bfd_reloc_overflow)
15139 /* On code like "if (foo) foo();" don't report overflow
15140 on a branch to zero when foo is undefined. */
15142 && (reloc_dest == DEST_STUB
15144 && (h->elf.root.type == bfd_link_hash_undefweak
15145 || h->elf.root.type == bfd_link_hash_undefined)
15146 && is_branch_reloc (r_type))))
15147 info->callbacks->reloc_overflow (info, &h->elf.root,
15148 sym_name, reloc_name,
15150 input_bfd, input_section,
15155 info->callbacks->einfo
15156 (_("%P: %H: %s against `%T': error %d\n"),
15157 input_bfd, input_section, rel->r_offset,
15158 reloc_name, sym_name, (int) r);
15161 if (more_info != NULL)
15171 Elf_Internal_Shdr *rel_hdr;
15172 size_t deleted = rel - wrel;
15174 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15175 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15176 if (rel_hdr->sh_size == 0)
15178 /* It is too late to remove an empty reloc section. Leave
15180 ??? What is wrong with an empty section??? */
15181 rel_hdr->sh_size = rel_hdr->sh_entsize;
15184 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15185 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15186 input_section->reloc_count -= deleted;
15189 /* If we're emitting relocations, then shortly after this function
15190 returns, reloc offsets and addends for this section will be
15191 adjusted. Worse, reloc symbol indices will be for the output
15192 file rather than the input. Save a copy of the relocs for
15193 opd_entry_value. */
15194 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15197 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15198 rel = bfd_alloc (input_bfd, amt);
15199 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15200 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15203 memcpy (rel, relocs, amt);
15208 /* Adjust the value of any local symbols in opd sections. */
15211 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15212 const char *name ATTRIBUTE_UNUSED,
15213 Elf_Internal_Sym *elfsym,
15214 asection *input_sec,
15215 struct elf_link_hash_entry *h)
15217 struct _opd_sec_data *opd;
15224 opd = get_opd_info (input_sec);
15225 if (opd == NULL || opd->adjust == NULL)
15228 value = elfsym->st_value - input_sec->output_offset;
15229 if (!bfd_link_relocatable (info))
15230 value -= input_sec->output_section->vma;
15232 adjust = opd->adjust[OPD_NDX (value)];
15236 elfsym->st_value += adjust;
15240 /* Finish up dynamic symbol handling. We set the contents of various
15241 dynamic sections here. */
15244 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15245 struct bfd_link_info *info,
15246 struct elf_link_hash_entry *h,
15247 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15249 struct ppc_link_hash_table *htab;
15250 struct plt_entry *ent;
15251 Elf_Internal_Rela rela;
15254 htab = ppc_hash_table (info);
15258 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15259 if (ent->plt.offset != (bfd_vma) -1)
15261 /* This symbol has an entry in the procedure linkage
15262 table. Set it up. */
15263 if (!htab->elf.dynamic_sections_created
15264 || h->dynindx == -1)
15266 BFD_ASSERT (h->type == STT_GNU_IFUNC
15268 && (h->root.type == bfd_link_hash_defined
15269 || h->root.type == bfd_link_hash_defweak));
15270 rela.r_offset = (htab->elf.iplt->output_section->vma
15271 + htab->elf.iplt->output_offset
15272 + ent->plt.offset);
15274 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15276 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15277 rela.r_addend = (h->root.u.def.value
15278 + h->root.u.def.section->output_offset
15279 + h->root.u.def.section->output_section->vma
15281 loc = (htab->elf.irelplt->contents
15282 + (htab->elf.irelplt->reloc_count++
15283 * sizeof (Elf64_External_Rela)));
15287 rela.r_offset = (htab->elf.splt->output_section->vma
15288 + htab->elf.splt->output_offset
15289 + ent->plt.offset);
15290 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15291 rela.r_addend = ent->addend;
15292 loc = (htab->elf.srelplt->contents
15293 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15294 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15296 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15298 if (!htab->opd_abi)
15300 if (!h->def_regular)
15302 /* Mark the symbol as undefined, rather than as
15303 defined in glink. Leave the value if there were
15304 any relocations where pointer equality matters
15305 (this is a clue for the dynamic linker, to make
15306 function pointer comparisons work between an
15307 application and shared library), otherwise set it
15309 sym->st_shndx = SHN_UNDEF;
15310 if (!h->pointer_equality_needed)
15312 else if (!h->ref_regular_nonweak)
15314 /* This breaks function pointer comparisons, but
15315 that is better than breaking tests for a NULL
15316 function pointer. */
15325 /* This symbol needs a copy reloc. Set it up. */
15327 if (h->dynindx == -1
15328 || (h->root.type != bfd_link_hash_defined
15329 && h->root.type != bfd_link_hash_defweak)
15330 || htab->relbss == NULL)
15333 rela.r_offset = (h->root.u.def.value
15334 + h->root.u.def.section->output_section->vma
15335 + h->root.u.def.section->output_offset);
15336 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15338 loc = htab->relbss->contents;
15339 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15340 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15346 /* Used to decide how to sort relocs in an optimal manner for the
15347 dynamic linker, before writing them out. */
15349 static enum elf_reloc_type_class
15350 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15351 const asection *rel_sec,
15352 const Elf_Internal_Rela *rela)
15354 enum elf_ppc64_reloc_type r_type;
15355 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15357 if (rel_sec == htab->elf.irelplt)
15358 return reloc_class_ifunc;
15360 r_type = ELF64_R_TYPE (rela->r_info);
15363 case R_PPC64_RELATIVE:
15364 return reloc_class_relative;
15365 case R_PPC64_JMP_SLOT:
15366 return reloc_class_plt;
15368 return reloc_class_copy;
15370 return reloc_class_normal;
15374 /* Finish up the dynamic sections. */
15377 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15378 struct bfd_link_info *info)
15380 struct ppc_link_hash_table *htab;
15384 htab = ppc_hash_table (info);
15388 dynobj = htab->elf.dynobj;
15389 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15391 if (htab->elf.dynamic_sections_created)
15393 Elf64_External_Dyn *dyncon, *dynconend;
15395 if (sdyn == NULL || htab->elf.sgot == NULL)
15398 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15399 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15400 for (; dyncon < dynconend; dyncon++)
15402 Elf_Internal_Dyn dyn;
15405 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15412 case DT_PPC64_GLINK:
15414 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15415 /* We stupidly defined DT_PPC64_GLINK to be the start
15416 of glink rather than the first entry point, which is
15417 what ld.so needs, and now have a bigger stub to
15418 support automatic multiple TOCs. */
15419 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15423 s = bfd_get_section_by_name (output_bfd, ".opd");
15426 dyn.d_un.d_ptr = s->vma;
15430 if (htab->do_multi_toc && htab->multi_toc_needed)
15431 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15434 case DT_PPC64_OPDSZ:
15435 s = bfd_get_section_by_name (output_bfd, ".opd");
15438 dyn.d_un.d_val = s->size;
15442 s = htab->elf.splt;
15443 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15447 s = htab->elf.srelplt;
15448 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15452 dyn.d_un.d_val = htab->elf.srelplt->size;
15456 /* Don't count procedure linkage table relocs in the
15457 overall reloc count. */
15458 s = htab->elf.srelplt;
15461 dyn.d_un.d_val -= s->size;
15465 /* We may not be using the standard ELF linker script.
15466 If .rela.plt is the first .rela section, we adjust
15467 DT_RELA to not include it. */
15468 s = htab->elf.srelplt;
15471 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15473 dyn.d_un.d_ptr += s->size;
15477 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15481 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15483 /* Fill in the first entry in the global offset table.
15484 We use it to hold the link-time TOCbase. */
15485 bfd_put_64 (output_bfd,
15486 elf_gp (output_bfd) + TOC_BASE_OFF,
15487 htab->elf.sgot->contents);
15489 /* Set .got entry size. */
15490 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15493 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15495 /* Set .plt entry size. */
15496 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15497 = PLT_ENTRY_SIZE (htab);
15500 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15501 brlt ourselves if emitrelocations. */
15502 if (htab->brlt != NULL
15503 && htab->brlt->reloc_count != 0
15504 && !_bfd_elf_link_output_relocs (output_bfd,
15506 elf_section_data (htab->brlt)->rela.hdr,
15507 elf_section_data (htab->brlt)->relocs,
15511 if (htab->glink != NULL
15512 && htab->glink->reloc_count != 0
15513 && !_bfd_elf_link_output_relocs (output_bfd,
15515 elf_section_data (htab->glink)->rela.hdr,
15516 elf_section_data (htab->glink)->relocs,
15520 if (htab->glink_eh_frame != NULL
15521 && htab->glink_eh_frame->size != 0)
15525 asection *stub_sec;
15527 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15528 for (stub_sec = htab->params->stub_bfd->sections;
15530 stub_sec = stub_sec->next)
15531 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15537 /* Offset to stub section. */
15538 val = (stub_sec->output_section->vma
15539 + stub_sec->output_offset);
15540 val -= (htab->glink_eh_frame->output_section->vma
15541 + htab->glink_eh_frame->output_offset
15542 + (p - htab->glink_eh_frame->contents));
15543 if (val + 0x80000000 > 0xffffffff)
15545 info->callbacks->einfo
15546 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15550 bfd_put_32 (dynobj, val, p);
15552 /* stub section size. */
15554 /* Augmentation. */
15559 if (htab->glink != NULL && htab->glink->size != 0)
15565 /* Offset to .glink. */
15566 val = (htab->glink->output_section->vma
15567 + htab->glink->output_offset
15569 val -= (htab->glink_eh_frame->output_section->vma
15570 + htab->glink_eh_frame->output_offset
15571 + (p - htab->glink_eh_frame->contents));
15572 if (val + 0x80000000 > 0xffffffff)
15574 info->callbacks->einfo
15575 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15576 htab->glink->name);
15579 bfd_put_32 (dynobj, val, p);
15583 /* Augmentation. */
15589 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15590 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15591 htab->glink_eh_frame,
15592 htab->glink_eh_frame->contents))
15596 /* We need to handle writing out multiple GOT sections ourselves,
15597 since we didn't add them to DYNOBJ. We know dynobj is the first
15599 while ((dynobj = dynobj->link.next) != NULL)
15603 if (!is_ppc64_elf (dynobj))
15606 s = ppc64_elf_tdata (dynobj)->got;
15609 && s->output_section != bfd_abs_section_ptr
15610 && !bfd_set_section_contents (output_bfd, s->output_section,
15611 s->contents, s->output_offset,
15614 s = ppc64_elf_tdata (dynobj)->relgot;
15617 && s->output_section != bfd_abs_section_ptr
15618 && !bfd_set_section_contents (output_bfd, s->output_section,
15619 s->contents, s->output_offset,
15627 #include "elf64-target.h"
15629 /* FreeBSD support */
15631 #undef TARGET_LITTLE_SYM
15632 #undef TARGET_LITTLE_NAME
15634 #undef TARGET_BIG_SYM
15635 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15636 #undef TARGET_BIG_NAME
15637 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15640 #define ELF_OSABI ELFOSABI_FREEBSD
15643 #define elf64_bed elf64_powerpc_fbsd_bed
15645 #include "elf64-target.h"