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 && abiversion (symbol->section->owner) >= 2)
2577 for (i = 0; i < symbol->section->owner->symcount; ++i)
2579 asymbol *symdef = symbol->section->owner->outsymbols[i];
2581 if (strcmp (symdef->name, symbol->name) == 0)
2583 elfsym = (elf_symbol_type *) symdef;
2589 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591 return bfd_reloc_continue;
2594 static bfd_reloc_status_type
2595 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596 void *data, asection *input_section,
2597 bfd *output_bfd, char **error_message)
2600 enum elf_ppc64_reloc_type r_type;
2601 bfd_size_type octets;
2602 /* Assume 'at' branch hints. */
2603 bfd_boolean is_isa_v2 = TRUE;
2605 /* If this is a relocatable link (output_bfd test tells us), just
2606 call the generic function. Any adjustment will be done at final
2608 if (output_bfd != NULL)
2609 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2610 input_section, output_bfd, error_message);
2612 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2613 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2614 insn &= ~(0x01 << 21);
2615 r_type = reloc_entry->howto->type;
2616 if (r_type == R_PPC64_ADDR14_BRTAKEN
2617 || r_type == R_PPC64_REL14_BRTAKEN)
2618 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2622 /* Set 'a' bit. This is 0b00010 in BO field for branch
2623 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2624 for branch on CTR insns (BO == 1a00t or 1a01t). */
2625 if ((insn & (0x14 << 21)) == (0x04 << 21))
2627 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2637 if (!bfd_is_com_section (symbol->section))
2638 target = symbol->value;
2639 target += symbol->section->output_section->vma;
2640 target += symbol->section->output_offset;
2641 target += reloc_entry->addend;
2643 from = (reloc_entry->address
2644 + input_section->output_offset
2645 + input_section->output_section->vma);
2647 /* Invert 'y' bit if not the default. */
2648 if ((bfd_signed_vma) (target - from) < 0)
2651 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2654 input_section, output_bfd, error_message);
2657 static bfd_reloc_status_type
2658 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2659 void *data, asection *input_section,
2660 bfd *output_bfd, char **error_message)
2662 /* If this is a relocatable link (output_bfd test tells us), just
2663 call the generic function. Any adjustment will be done at final
2665 if (output_bfd != NULL)
2666 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2667 input_section, output_bfd, error_message);
2669 /* Subtract the symbol section base address. */
2670 reloc_entry->addend -= symbol->section->output_section->vma;
2671 return bfd_reloc_continue;
2674 static bfd_reloc_status_type
2675 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2676 void *data, asection *input_section,
2677 bfd *output_bfd, char **error_message)
2679 /* If this is a relocatable link (output_bfd test tells us), just
2680 call the generic function. Any adjustment will be done at final
2682 if (output_bfd != NULL)
2683 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684 input_section, output_bfd, error_message);
2686 /* Subtract the symbol section base address. */
2687 reloc_entry->addend -= symbol->section->output_section->vma;
2689 /* Adjust the addend for sign extension of the low 16 bits. */
2690 reloc_entry->addend += 0x8000;
2691 return bfd_reloc_continue;
2694 static bfd_reloc_status_type
2695 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696 void *data, asection *input_section,
2697 bfd *output_bfd, char **error_message)
2701 /* If this is a relocatable link (output_bfd test tells us), just
2702 call the generic function. Any adjustment will be done at final
2704 if (output_bfd != NULL)
2705 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2706 input_section, output_bfd, error_message);
2708 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712 /* Subtract the TOC base address. */
2713 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2714 return bfd_reloc_continue;
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719 void *data, asection *input_section,
2720 bfd *output_bfd, char **error_message)
2724 /* If this is a relocatable link (output_bfd test tells us), just
2725 call the generic function. Any adjustment will be done at final
2727 if (output_bfd != NULL)
2728 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729 input_section, output_bfd, error_message);
2731 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735 /* Subtract the TOC base address. */
2736 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738 /* Adjust the addend for sign extension of the low 16 bits. */
2739 reloc_entry->addend += 0x8000;
2740 return bfd_reloc_continue;
2743 static bfd_reloc_status_type
2744 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2745 void *data, asection *input_section,
2746 bfd *output_bfd, char **error_message)
2749 bfd_size_type octets;
2751 /* If this is a relocatable link (output_bfd test tells us), just
2752 call the generic function. Any adjustment will be done at final
2754 if (output_bfd != NULL)
2755 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756 input_section, output_bfd, error_message);
2758 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2763 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2764 return bfd_reloc_ok;
2767 static bfd_reloc_status_type
2768 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769 void *data, asection *input_section,
2770 bfd *output_bfd, char **error_message)
2772 /* If this is a relocatable link (output_bfd test tells us), just
2773 call the generic function. Any adjustment will be done at final
2775 if (output_bfd != NULL)
2776 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2777 input_section, output_bfd, error_message);
2779 if (error_message != NULL)
2781 static char buf[60];
2782 sprintf (buf, "generic linker can't handle %s",
2783 reloc_entry->howto->name);
2784 *error_message = buf;
2786 return bfd_reloc_dangerous;
2789 /* Track GOT entries needed for a given symbol. We might need more
2790 than one got entry per symbol. */
2793 struct got_entry *next;
2795 /* The symbol addend that we'll be placing in the GOT. */
2798 /* Unlike other ELF targets, we use separate GOT entries for the same
2799 symbol referenced from different input files. This is to support
2800 automatic multiple TOC/GOT sections, where the TOC base can vary
2801 from one input file to another. After partitioning into TOC groups
2802 we merge entries within the group.
2804 Point to the BFD owning this GOT entry. */
2807 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2808 TLS_TPREL or TLS_DTPREL for tls entries. */
2809 unsigned char tls_type;
2811 /* Non-zero if got.ent points to real entry. */
2812 unsigned char is_indirect;
2814 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2817 bfd_signed_vma refcount;
2819 struct got_entry *ent;
2823 /* The same for PLT. */
2826 struct plt_entry *next;
2832 bfd_signed_vma refcount;
2837 struct ppc64_elf_obj_tdata
2839 struct elf_obj_tdata elf;
2841 /* Shortcuts to dynamic linker sections. */
2845 /* Used during garbage collection. We attach global symbols defined
2846 on removed .opd entries to this section so that the sym is removed. */
2847 asection *deleted_section;
2849 /* TLS local dynamic got entry handling. Support for multiple GOT
2850 sections means we potentially need one of these for each input bfd. */
2851 struct got_entry tlsld_got;
2854 /* A copy of relocs before they are modified for --emit-relocs. */
2855 Elf_Internal_Rela *relocs;
2857 /* Section contents. */
2861 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2862 the reloc to be in the range -32768 to 32767. */
2863 unsigned int has_small_toc_reloc : 1;
2865 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2866 instruction not one we handle. */
2867 unsigned int unexpected_toc_insn : 1;
2870 #define ppc64_elf_tdata(bfd) \
2871 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873 #define ppc64_tlsld_got(bfd) \
2874 (&ppc64_elf_tdata (bfd)->tlsld_got)
2876 #define is_ppc64_elf(bfd) \
2877 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2878 && elf_object_id (bfd) == PPC64_ELF_DATA)
2880 /* Override the generic function because we store some extras. */
2883 ppc64_elf_mkobject (bfd *abfd)
2885 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2889 /* Fix bad default arch selected for a 64 bit input bfd when the
2890 default is 32 bit. */
2893 ppc64_elf_object_p (bfd *abfd)
2895 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2897 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2899 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2901 /* Relies on arch after 32 bit default being 64 bit default. */
2902 abfd->arch_info = abfd->arch_info->next;
2903 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2909 /* Support for core dump NOTE sections. */
2912 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2914 size_t offset, size;
2916 if (note->descsz != 504)
2920 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2923 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2929 /* Make a ".reg/999" section. */
2930 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2931 size, note->descpos + offset);
2935 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2937 if (note->descsz != 136)
2940 elf_tdata (abfd)->core->pid
2941 = bfd_get_32 (abfd, note->descdata + 24);
2942 elf_tdata (abfd)->core->program
2943 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2944 elf_tdata (abfd)->core->command
2945 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2951 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2964 va_start (ap, note_type);
2965 memset (data, 0, sizeof (data));
2966 strncpy (data + 40, va_arg (ap, const char *), 16);
2967 strncpy (data + 56, va_arg (ap, const char *), 80);
2969 return elfcore_write_note (abfd, buf, bufsiz,
2970 "CORE", note_type, data, sizeof (data));
2981 va_start (ap, note_type);
2982 memset (data, 0, 112);
2983 pid = va_arg (ap, long);
2984 bfd_put_32 (abfd, pid, data + 32);
2985 cursig = va_arg (ap, int);
2986 bfd_put_16 (abfd, cursig, data + 12);
2987 greg = va_arg (ap, const void *);
2988 memcpy (data + 112, greg, 384);
2989 memset (data + 496, 0, 8);
2991 return elfcore_write_note (abfd, buf, bufsiz,
2992 "CORE", note_type, data, sizeof (data));
2997 /* Add extra PPC sections. */
2999 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3001 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3002 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3003 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3004 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3007 { NULL, 0, 0, 0, 0 }
3010 enum _ppc64_sec_type {
3016 struct _ppc64_elf_section_data
3018 struct bfd_elf_section_data elf;
3022 /* An array with one entry for each opd function descriptor,
3023 and some spares since opd entries may be either 16 or 24 bytes. */
3024 #define OPD_NDX(OFF) ((OFF) >> 4)
3025 struct _opd_sec_data
3027 /* Points to the function code section for local opd entries. */
3028 asection **func_sec;
3030 /* After editing .opd, adjust references to opd local syms. */
3034 /* An array for toc sections, indexed by offset/8. */
3035 struct _toc_sec_data
3037 /* Specifies the relocation symbol index used at a given toc offset. */
3040 /* And the relocation addend. */
3045 enum _ppc64_sec_type sec_type:2;
3047 /* Flag set when small branches are detected. Used to
3048 select suitable defaults for the stub group size. */
3049 unsigned int has_14bit_branch:1;
3052 #define ppc64_elf_section_data(sec) \
3053 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3056 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3058 if (!sec->used_by_bfd)
3060 struct _ppc64_elf_section_data *sdata;
3061 bfd_size_type amt = sizeof (*sdata);
3063 sdata = bfd_zalloc (abfd, amt);
3066 sec->used_by_bfd = sdata;
3069 return _bfd_elf_new_section_hook (abfd, sec);
3072 static struct _opd_sec_data *
3073 get_opd_info (asection * sec)
3076 && ppc64_elf_section_data (sec) != NULL
3077 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3078 return &ppc64_elf_section_data (sec)->u.opd;
3082 /* Parameters for the qsort hook. */
3083 static bfd_boolean synthetic_relocatable;
3085 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3088 compare_symbols (const void *ap, const void *bp)
3090 const asymbol *a = * (const asymbol **) ap;
3091 const asymbol *b = * (const asymbol **) bp;
3093 /* Section symbols first. */
3094 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3096 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3099 /* then .opd symbols. */
3100 if (strcmp (a->section->name, ".opd") == 0
3101 && strcmp (b->section->name, ".opd") != 0)
3103 if (strcmp (a->section->name, ".opd") != 0
3104 && strcmp (b->section->name, ".opd") == 0)
3107 /* then other code symbols. */
3108 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3109 == (SEC_CODE | SEC_ALLOC)
3110 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3111 != (SEC_CODE | SEC_ALLOC))
3114 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115 != (SEC_CODE | SEC_ALLOC)
3116 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117 == (SEC_CODE | SEC_ALLOC))
3120 if (synthetic_relocatable)
3122 if (a->section->id < b->section->id)
3125 if (a->section->id > b->section->id)
3129 if (a->value + a->section->vma < b->value + b->section->vma)
3132 if (a->value + a->section->vma > b->value + b->section->vma)
3135 /* For syms with the same value, prefer strong dynamic global function
3136 syms over other syms. */
3137 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3140 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3143 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3146 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3149 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3152 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3155 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3158 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3164 /* Search SYMS for a symbol of the given VALUE. */
3167 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3171 if (id == (unsigned) -1)
3175 mid = (lo + hi) >> 1;
3176 if (syms[mid]->value + syms[mid]->section->vma < value)
3178 else if (syms[mid]->value + syms[mid]->section->vma > value)
3188 mid = (lo + hi) >> 1;
3189 if (syms[mid]->section->id < id)
3191 else if (syms[mid]->section->id > id)
3193 else if (syms[mid]->value < value)
3195 else if (syms[mid]->value > value)
3205 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3207 bfd_vma vma = *(bfd_vma *) ptr;
3208 return ((section->flags & SEC_ALLOC) != 0
3209 && section->vma <= vma
3210 && vma < section->vma + section->size);
3213 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3214 entry syms. Also generate @plt symbols for the glink branch table.
3215 Returns count of synthetic symbols in RET or -1 on error. */
3218 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3219 long static_count, asymbol **static_syms,
3220 long dyn_count, asymbol **dyn_syms,
3227 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3228 asection *opd = NULL;
3229 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3231 int abi = abiversion (abfd);
3237 opd = bfd_get_section_by_name (abfd, ".opd");
3238 if (opd == NULL && abi == 1)
3242 symcount = static_count;
3244 symcount += dyn_count;
3248 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3252 if (!relocatable && static_count != 0 && dyn_count != 0)
3254 /* Use both symbol tables. */
3255 memcpy (syms, static_syms, static_count * sizeof (*syms));
3256 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3258 else if (!relocatable && static_count == 0)
3259 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3261 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3263 synthetic_relocatable = relocatable;
3264 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3266 if (!relocatable && symcount > 1)
3269 /* Trim duplicate syms, since we may have merged the normal and
3270 dynamic symbols. Actually, we only care about syms that have
3271 different values, so trim any with the same value. */
3272 for (i = 1, j = 1; i < symcount; ++i)
3273 if (syms[i - 1]->value + syms[i - 1]->section->vma
3274 != syms[i]->value + syms[i]->section->vma)
3275 syms[j++] = syms[i];
3280 if (strcmp (syms[i]->section->name, ".opd") == 0)
3284 for (; i < symcount; ++i)
3285 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3286 != (SEC_CODE | SEC_ALLOC))
3287 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3291 for (; i < symcount; ++i)
3292 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3296 for (; i < symcount; ++i)
3297 if (strcmp (syms[i]->section->name, ".opd") != 0)
3301 for (; i < symcount; ++i)
3302 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303 != (SEC_CODE | SEC_ALLOC))
3311 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3316 if (opdsymend == secsymend)
3319 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3320 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3324 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3331 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3335 while (r < opd->relocation + relcount
3336 && r->address < syms[i]->value + opd->vma)
3339 if (r == opd->relocation + relcount)
3342 if (r->address != syms[i]->value + opd->vma)
3345 if (r->howto->type != R_PPC64_ADDR64)
3348 sym = *r->sym_ptr_ptr;
3349 if (!sym_exists_at (syms, opdsymend, symcount,
3350 sym->section->id, sym->value + r->addend))
3353 size += sizeof (asymbol);
3354 size += strlen (syms[i]->name) + 2;
3360 s = *ret = bfd_malloc (size);
3367 names = (char *) (s + count);
3369 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3373 while (r < opd->relocation + relcount
3374 && r->address < syms[i]->value + opd->vma)
3377 if (r == opd->relocation + relcount)
3380 if (r->address != syms[i]->value + opd->vma)
3383 if (r->howto->type != R_PPC64_ADDR64)
3386 sym = *r->sym_ptr_ptr;
3387 if (!sym_exists_at (syms, opdsymend, symcount,
3388 sym->section->id, sym->value + r->addend))
3393 s->flags |= BSF_SYNTHETIC;
3394 s->section = sym->section;
3395 s->value = sym->value + r->addend;
3398 len = strlen (syms[i]->name);
3399 memcpy (names, syms[i]->name, len + 1);
3401 /* Have udata.p point back to the original symbol this
3402 synthetic symbol was derived from. */
3403 s->udata.p = syms[i];
3410 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3411 bfd_byte *contents = NULL;
3414 bfd_vma glink_vma = 0, resolv_vma = 0;
3415 asection *dynamic, *glink = NULL, *relplt = NULL;
3418 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3420 free_contents_and_exit_err:
3422 free_contents_and_exit:
3429 for (i = secsymend; i < opdsymend; ++i)
3433 /* Ignore bogus symbols. */
3434 if (syms[i]->value > opd->size - 8)
3437 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3441 size += sizeof (asymbol);
3442 size += strlen (syms[i]->name) + 2;
3446 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3448 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3450 bfd_byte *dynbuf, *extdyn, *extdynend;
3452 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3454 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3455 goto free_contents_and_exit_err;
3457 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3458 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3461 extdynend = extdyn + dynamic->size;
3462 for (; extdyn < extdynend; extdyn += extdynsize)
3464 Elf_Internal_Dyn dyn;
3465 (*swap_dyn_in) (abfd, extdyn, &dyn);
3467 if (dyn.d_tag == DT_NULL)
3470 if (dyn.d_tag == DT_PPC64_GLINK)
3472 /* The first glink stub starts at offset 32; see
3473 comment in ppc64_elf_finish_dynamic_sections. */
3474 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3475 /* The .glink section usually does not survive the final
3476 link; search for the section (usually .text) where the
3477 glink stubs now reside. */
3478 glink = bfd_sections_find_if (abfd, section_covers_vma,
3489 /* Determine __glink trampoline by reading the relative branch
3490 from the first glink stub. */
3492 unsigned int off = 0;
3494 while (bfd_get_section_contents (abfd, glink, buf,
3495 glink_vma + off - glink->vma, 4))
3497 unsigned int insn = bfd_get_32 (abfd, buf);
3499 if ((insn & ~0x3fffffc) == 0)
3501 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3510 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3512 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3515 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3516 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3517 goto free_contents_and_exit_err;
3519 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3520 size += plt_count * sizeof (asymbol);
3522 p = relplt->relocation;
3523 for (i = 0; i < plt_count; i++, p++)
3525 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3527 size += sizeof ("+0x") - 1 + 16;
3533 goto free_contents_and_exit;
3534 s = *ret = bfd_malloc (size);
3536 goto free_contents_and_exit_err;
3538 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3540 for (i = secsymend; i < opdsymend; ++i)
3544 if (syms[i]->value > opd->size - 8)
3547 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3548 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3552 asection *sec = abfd->sections;
3559 long mid = (lo + hi) >> 1;
3560 if (syms[mid]->section->vma < ent)
3562 else if (syms[mid]->section->vma > ent)
3566 sec = syms[mid]->section;
3571 if (lo >= hi && lo > codesecsym)
3572 sec = syms[lo - 1]->section;
3574 for (; sec != NULL; sec = sec->next)
3578 /* SEC_LOAD may not be set if SEC is from a separate debug
3580 if ((sec->flags & SEC_ALLOC) == 0)
3582 if ((sec->flags & SEC_CODE) != 0)
3585 s->flags |= BSF_SYNTHETIC;
3586 s->value = ent - s->section->vma;
3589 len = strlen (syms[i]->name);
3590 memcpy (names, syms[i]->name, len + 1);
3592 /* Have udata.p point back to the original symbol this
3593 synthetic symbol was derived from. */
3594 s->udata.p = syms[i];
3600 if (glink != NULL && relplt != NULL)
3604 /* Add a symbol for the main glink trampoline. */
3605 memset (s, 0, sizeof *s);
3607 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3609 s->value = resolv_vma - glink->vma;
3611 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3612 names += sizeof ("__glink_PLTresolve");
3617 /* FIXME: It would be very much nicer to put sym@plt on the
3618 stub rather than on the glink branch table entry. The
3619 objdump disassembler would then use a sensible symbol
3620 name on plt calls. The difficulty in doing so is
3621 a) finding the stubs, and,
3622 b) matching stubs against plt entries, and,
3623 c) there can be multiple stubs for a given plt entry.
3625 Solving (a) could be done by code scanning, but older
3626 ppc64 binaries used different stubs to current code.
3627 (b) is the tricky one since you need to known the toc
3628 pointer for at least one function that uses a pic stub to
3629 be able to calculate the plt address referenced.
3630 (c) means gdb would need to set multiple breakpoints (or
3631 find the glink branch itself) when setting breakpoints
3632 for pending shared library loads. */
3633 p = relplt->relocation;
3634 for (i = 0; i < plt_count; i++, p++)
3638 *s = **p->sym_ptr_ptr;
3639 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3640 we are defining a symbol, ensure one of them is set. */
3641 if ((s->flags & BSF_LOCAL) == 0)
3642 s->flags |= BSF_GLOBAL;
3643 s->flags |= BSF_SYNTHETIC;
3645 s->value = glink_vma - glink->vma;
3648 len = strlen ((*p->sym_ptr_ptr)->name);
3649 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3653 memcpy (names, "+0x", sizeof ("+0x") - 1);
3654 names += sizeof ("+0x") - 1;
3655 bfd_sprintf_vma (abfd, names, p->addend);
3656 names += strlen (names);
3658 memcpy (names, "@plt", sizeof ("@plt"));
3659 names += sizeof ("@plt");
3679 /* The following functions are specific to the ELF linker, while
3680 functions above are used generally. Those named ppc64_elf_* are
3681 called by the main ELF linker code. They appear in this file more
3682 or less in the order in which they are called. eg.
3683 ppc64_elf_check_relocs is called early in the link process,
3684 ppc64_elf_finish_dynamic_sections is one of the last functions
3687 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3688 functions have both a function code symbol and a function descriptor
3689 symbol. A call to foo in a relocatable object file looks like:
3696 The function definition in another object file might be:
3700 . .quad .TOC.@tocbase
3706 When the linker resolves the call during a static link, the branch
3707 unsurprisingly just goes to .foo and the .opd information is unused.
3708 If the function definition is in a shared library, things are a little
3709 different: The call goes via a plt call stub, the opd information gets
3710 copied to the plt, and the linker patches the nop.
3718 . std 2,40(1) # in practice, the call stub
3719 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3720 . addi 11,11,Lfoo@toc@l # this is the general idea
3728 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3730 The "reloc ()" notation is supposed to indicate that the linker emits
3731 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3734 What are the difficulties here? Well, firstly, the relocations
3735 examined by the linker in check_relocs are against the function code
3736 sym .foo, while the dynamic relocation in the plt is emitted against
3737 the function descriptor symbol, foo. Somewhere along the line, we need
3738 to carefully copy dynamic link information from one symbol to the other.
3739 Secondly, the generic part of the elf linker will make .foo a dynamic
3740 symbol as is normal for most other backends. We need foo dynamic
3741 instead, at least for an application final link. However, when
3742 creating a shared library containing foo, we need to have both symbols
3743 dynamic so that references to .foo are satisfied during the early
3744 stages of linking. Otherwise the linker might decide to pull in a
3745 definition from some other object, eg. a static library.
3747 Update: As of August 2004, we support a new convention. Function
3748 calls may use the function descriptor symbol, ie. "bl foo". This
3749 behaves exactly as "bl .foo". */
3751 /* Of those relocs that might be copied as dynamic relocs, this function
3752 selects those that must be copied when linking a shared library,
3753 even when the symbol is local. */
3756 must_be_dyn_reloc (struct bfd_link_info *info,
3757 enum elf_ppc64_reloc_type r_type)
3769 case R_PPC64_TPREL16:
3770 case R_PPC64_TPREL16_LO:
3771 case R_PPC64_TPREL16_HI:
3772 case R_PPC64_TPREL16_HA:
3773 case R_PPC64_TPREL16_DS:
3774 case R_PPC64_TPREL16_LO_DS:
3775 case R_PPC64_TPREL16_HIGH:
3776 case R_PPC64_TPREL16_HIGHA:
3777 case R_PPC64_TPREL16_HIGHER:
3778 case R_PPC64_TPREL16_HIGHERA:
3779 case R_PPC64_TPREL16_HIGHEST:
3780 case R_PPC64_TPREL16_HIGHESTA:
3781 case R_PPC64_TPREL64:
3782 return !bfd_link_executable (info);
3786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3787 copying dynamic variables from a shared lib into an app's dynbss
3788 section, and instead use a dynamic relocation to point into the
3789 shared lib. With code that gcc generates, it's vital that this be
3790 enabled; In the PowerPC64 ABI, the address of a function is actually
3791 the address of a function descriptor, which resides in the .opd
3792 section. gcc uses the descriptor directly rather than going via the
3793 GOT as some other ABI's do, which means that initialized function
3794 pointers must reference the descriptor. Thus, a function pointer
3795 initialized to the address of a function in a shared library will
3796 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3797 redefines the function descriptor symbol to point to the copy. This
3798 presents a problem as a plt entry for that function is also
3799 initialized from the function descriptor symbol and the copy reloc
3800 may not be initialized first. */
3801 #define ELIMINATE_COPY_RELOCS 1
3803 /* Section name for stubs is the associated section name plus this
3805 #define STUB_SUFFIX ".stub"
3808 ppc_stub_long_branch:
3809 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3810 destination, but a 24 bit branch in a stub section will reach.
3813 ppc_stub_plt_branch:
3814 Similar to the above, but a 24 bit branch in the stub section won't
3815 reach its destination.
3816 . addis %r11,%r2,xxx@toc@ha
3817 . ld %r12,xxx@toc@l(%r11)
3822 Used to call a function in a shared library. If it so happens that
3823 the plt entry referenced crosses a 64k boundary, then an extra
3824 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3826 . addis %r11,%r2,xxx@toc@ha
3827 . ld %r12,xxx+0@toc@l(%r11)
3829 . ld %r2,xxx+8@toc@l(%r11)
3830 . ld %r11,xxx+16@toc@l(%r11)
3833 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3834 code to adjust the value and save r2 to support multiple toc sections.
3835 A ppc_stub_long_branch with an r2 offset looks like:
3837 . addis %r2,%r2,off@ha
3838 . addi %r2,%r2,off@l
3841 A ppc_stub_plt_branch with an r2 offset looks like:
3843 . addis %r11,%r2,xxx@toc@ha
3844 . ld %r12,xxx@toc@l(%r11)
3845 . addis %r2,%r2,off@ha
3846 . addi %r2,%r2,off@l
3850 In cases where the "addis" instruction would add zero, the "addis" is
3851 omitted and following instructions modified slightly in some cases.
3854 enum ppc_stub_type {
3856 ppc_stub_long_branch,
3857 ppc_stub_long_branch_r2off,
3858 ppc_stub_plt_branch,
3859 ppc_stub_plt_branch_r2off,
3861 ppc_stub_plt_call_r2save,
3862 ppc_stub_global_entry,
3866 /* Information on stub grouping. */
3869 /* The stub section. */
3871 /* This is the section to which stubs in the group will be attached. */
3874 struct map_stub *next;
3875 /* Whether to emit a copy of register save/restore functions in this
3880 struct ppc_stub_hash_entry {
3882 /* Base hash table entry structure. */
3883 struct bfd_hash_entry root;
3885 enum ppc_stub_type stub_type;
3887 /* Group information. */
3888 struct map_stub *group;
3890 /* Offset within stub_sec of the beginning of this stub. */
3891 bfd_vma stub_offset;
3893 /* Given the symbol's value and its section we can determine its final
3894 value when building the stubs (so the stub knows where to jump. */
3895 bfd_vma target_value;
3896 asection *target_section;
3898 /* The symbol table entry, if any, that this was derived from. */
3899 struct ppc_link_hash_entry *h;
3900 struct plt_entry *plt_ent;
3902 /* Symbol st_other. */
3903 unsigned char other;
3906 struct ppc_branch_hash_entry {
3908 /* Base hash table entry structure. */
3909 struct bfd_hash_entry root;
3911 /* Offset within branch lookup table. */
3912 unsigned int offset;
3914 /* Generation marker. */
3918 /* Used to track dynamic relocations for local symbols. */
3919 struct ppc_dyn_relocs
3921 struct ppc_dyn_relocs *next;
3923 /* The input section of the reloc. */
3926 /* Total number of relocs copied for the input section. */
3927 unsigned int count : 31;
3929 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3930 unsigned int ifunc : 1;
3933 struct ppc_link_hash_entry
3935 struct elf_link_hash_entry elf;
3938 /* A pointer to the most recently used stub hash entry against this
3940 struct ppc_stub_hash_entry *stub_cache;
3942 /* A pointer to the next symbol starting with a '.' */
3943 struct ppc_link_hash_entry *next_dot_sym;
3946 /* Track dynamic relocs copied for this symbol. */
3947 struct elf_dyn_relocs *dyn_relocs;
3949 /* Link between function code and descriptor symbols. */
3950 struct ppc_link_hash_entry *oh;
3952 /* Flag function code and descriptor symbols. */
3953 unsigned int is_func:1;
3954 unsigned int is_func_descriptor:1;
3955 unsigned int fake:1;
3957 /* Whether global opd/toc sym has been adjusted or not.
3958 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3959 should be set for all globals defined in any opd/toc section. */
3960 unsigned int adjust_done:1;
3962 /* Set if we twiddled this symbol to weak at some stage. */
3963 unsigned int was_undefined:1;
3965 /* Set if this is an out-of-line register save/restore function,
3966 with non-standard calling convention. */
3967 unsigned int save_res:1;
3969 /* Contexts in which symbol is used in the GOT (or TOC).
3970 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3971 corresponding relocs are encountered during check_relocs.
3972 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3973 indicate the corresponding GOT entry type is not needed.
3974 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3975 a TPREL one. We use a separate flag rather than setting TPREL
3976 just for convenience in distinguishing the two cases. */
3977 #define TLS_GD 1 /* GD reloc. */
3978 #define TLS_LD 2 /* LD reloc. */
3979 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3980 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3981 #define TLS_TLS 16 /* Any TLS reloc. */
3982 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3983 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3984 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3985 unsigned char tls_mask;
3988 /* ppc64 ELF linker hash table. */
3990 struct ppc_link_hash_table
3992 struct elf_link_hash_table elf;
3994 /* The stub hash table. */
3995 struct bfd_hash_table stub_hash_table;
3997 /* Another hash table for plt_branch stubs. */
3998 struct bfd_hash_table branch_hash_table;
4000 /* Hash table for function prologue tocsave. */
4001 htab_t tocsave_htab;
4003 /* Various options and other info passed from the linker. */
4004 struct ppc64_elf_params *params;
4006 /* The size of sec_info below. */
4007 unsigned int sec_info_arr_size;
4009 /* Per-section array of extra section info. Done this way rather
4010 than as part of ppc64_elf_section_data so we have the info for
4011 non-ppc64 sections. */
4014 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4019 /* The section group that this section belongs to. */
4020 struct map_stub *group;
4021 /* A temp section list pointer. */
4026 /* Linked list of groups. */
4027 struct map_stub *group;
4029 /* Temp used when calculating TOC pointers. */
4032 asection *toc_first_sec;
4034 /* Used when adding symbols. */
4035 struct ppc_link_hash_entry *dot_syms;
4037 /* Shortcuts to get to dynamic linker sections. */
4044 asection *glink_eh_frame;
4046 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4047 struct ppc_link_hash_entry *tls_get_addr;
4048 struct ppc_link_hash_entry *tls_get_addr_fd;
4050 /* The size of reliplt used by got entry relocs. */
4051 bfd_size_type got_reli_size;
4054 unsigned long stub_count[ppc_stub_global_entry];
4056 /* Number of stubs against global syms. */
4057 unsigned long stub_globals;
4059 /* Set if we're linking code with function descriptors. */
4060 unsigned int opd_abi:1;
4062 /* Support for multiple toc sections. */
4063 unsigned int do_multi_toc:1;
4064 unsigned int multi_toc_needed:1;
4065 unsigned int second_toc_pass:1;
4066 unsigned int do_toc_opt:1;
4069 unsigned int stub_error:1;
4071 /* Temp used by ppc64_elf_before_check_relocs. */
4072 unsigned int twiddled_syms:1;
4074 /* Incremented every time we size stubs. */
4075 unsigned int stub_iteration;
4077 /* Small local sym cache. */
4078 struct sym_cache sym_cache;
4081 /* Rename some of the generic section flags to better document how they
4084 /* Nonzero if this section has TLS related relocations. */
4085 #define has_tls_reloc sec_flg0
4087 /* Nonzero if this section has a call to __tls_get_addr. */
4088 #define has_tls_get_addr_call sec_flg1
4090 /* Nonzero if this section has any toc or got relocs. */
4091 #define has_toc_reloc sec_flg2
4093 /* Nonzero if this section has a call to another section that uses
4095 #define makes_toc_func_call sec_flg3
4097 /* Recursion protection when determining above flag. */
4098 #define call_check_in_progress sec_flg4
4099 #define call_check_done sec_flg5
4101 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4103 #define ppc_hash_table(p) \
4104 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4105 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4107 #define ppc_stub_hash_lookup(table, string, create, copy) \
4108 ((struct ppc_stub_hash_entry *) \
4109 bfd_hash_lookup ((table), (string), (create), (copy)))
4111 #define ppc_branch_hash_lookup(table, string, create, copy) \
4112 ((struct ppc_branch_hash_entry *) \
4113 bfd_hash_lookup ((table), (string), (create), (copy)))
4115 /* Create an entry in the stub hash table. */
4117 static struct bfd_hash_entry *
4118 stub_hash_newfunc (struct bfd_hash_entry *entry,
4119 struct bfd_hash_table *table,
4122 /* Allocate the structure if it has not already been allocated by a
4126 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4131 /* Call the allocation method of the superclass. */
4132 entry = bfd_hash_newfunc (entry, table, string);
4135 struct ppc_stub_hash_entry *eh;
4137 /* Initialize the local fields. */
4138 eh = (struct ppc_stub_hash_entry *) entry;
4139 eh->stub_type = ppc_stub_none;
4141 eh->stub_offset = 0;
4142 eh->target_value = 0;
4143 eh->target_section = NULL;
4152 /* Create an entry in the branch hash table. */
4154 static struct bfd_hash_entry *
4155 branch_hash_newfunc (struct bfd_hash_entry *entry,
4156 struct bfd_hash_table *table,
4159 /* Allocate the structure if it has not already been allocated by a
4163 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4168 /* Call the allocation method of the superclass. */
4169 entry = bfd_hash_newfunc (entry, table, string);
4172 struct ppc_branch_hash_entry *eh;
4174 /* Initialize the local fields. */
4175 eh = (struct ppc_branch_hash_entry *) entry;
4183 /* Create an entry in a ppc64 ELF linker hash table. */
4185 static struct bfd_hash_entry *
4186 link_hash_newfunc (struct bfd_hash_entry *entry,
4187 struct bfd_hash_table *table,
4190 /* Allocate the structure if it has not already been allocated by a
4194 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4199 /* Call the allocation method of the superclass. */
4200 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4203 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4205 memset (&eh->u.stub_cache, 0,
4206 (sizeof (struct ppc_link_hash_entry)
4207 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4209 /* When making function calls, old ABI code references function entry
4210 points (dot symbols), while new ABI code references the function
4211 descriptor symbol. We need to make any combination of reference and
4212 definition work together, without breaking archive linking.
4214 For a defined function "foo" and an undefined call to "bar":
4215 An old object defines "foo" and ".foo", references ".bar" (possibly
4217 A new object defines "foo" and references "bar".
4219 A new object thus has no problem with its undefined symbols being
4220 satisfied by definitions in an old object. On the other hand, the
4221 old object won't have ".bar" satisfied by a new object.
4223 Keep a list of newly added dot-symbols. */
4225 if (string[0] == '.')
4227 struct ppc_link_hash_table *htab;
4229 htab = (struct ppc_link_hash_table *) table;
4230 eh->u.next_dot_sym = htab->dot_syms;
4231 htab->dot_syms = eh;
4238 struct tocsave_entry {
4244 tocsave_htab_hash (const void *p)
4246 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4247 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4251 tocsave_htab_eq (const void *p1, const void *p2)
4253 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4254 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4255 return e1->sec == e2->sec && e1->offset == e2->offset;
4258 /* Destroy a ppc64 ELF linker hash table. */
4261 ppc64_elf_link_hash_table_free (bfd *obfd)
4263 struct ppc_link_hash_table *htab;
4265 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4266 if (htab->tocsave_htab)
4267 htab_delete (htab->tocsave_htab);
4268 bfd_hash_table_free (&htab->branch_hash_table);
4269 bfd_hash_table_free (&htab->stub_hash_table);
4270 _bfd_elf_link_hash_table_free (obfd);
4273 /* Create a ppc64 ELF linker hash table. */
4275 static struct bfd_link_hash_table *
4276 ppc64_elf_link_hash_table_create (bfd *abfd)
4278 struct ppc_link_hash_table *htab;
4279 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4281 htab = bfd_zmalloc (amt);
4285 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4286 sizeof (struct ppc_link_hash_entry),
4293 /* Init the stub hash table too. */
4294 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4295 sizeof (struct ppc_stub_hash_entry)))
4297 _bfd_elf_link_hash_table_free (abfd);
4301 /* And the branch hash table. */
4302 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4303 sizeof (struct ppc_branch_hash_entry)))
4305 bfd_hash_table_free (&htab->stub_hash_table);
4306 _bfd_elf_link_hash_table_free (abfd);
4310 htab->tocsave_htab = htab_try_create (1024,
4314 if (htab->tocsave_htab == NULL)
4316 ppc64_elf_link_hash_table_free (abfd);
4319 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4321 /* Initializing two fields of the union is just cosmetic. We really
4322 only care about glist, but when compiled on a 32-bit host the
4323 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4324 debugger inspection of these fields look nicer. */
4325 htab->elf.init_got_refcount.refcount = 0;
4326 htab->elf.init_got_refcount.glist = NULL;
4327 htab->elf.init_plt_refcount.refcount = 0;
4328 htab->elf.init_plt_refcount.glist = NULL;
4329 htab->elf.init_got_offset.offset = 0;
4330 htab->elf.init_got_offset.glist = NULL;
4331 htab->elf.init_plt_offset.offset = 0;
4332 htab->elf.init_plt_offset.glist = NULL;
4334 return &htab->elf.root;
4337 /* Create sections for linker generated code. */
4340 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4342 struct ppc_link_hash_table *htab;
4345 htab = ppc_hash_table (info);
4347 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4348 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4349 if (htab->params->save_restore_funcs)
4351 /* Create .sfpr for code to save and restore fp regs. */
4352 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4354 if (htab->sfpr == NULL
4355 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4359 if (bfd_link_relocatable (info))
4362 /* Create .glink for lazy dynamic linking support. */
4363 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4365 if (htab->glink == NULL
4366 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4369 if (!info->no_ld_generated_unwind_info)
4371 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4372 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4373 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4376 if (htab->glink_eh_frame == NULL
4377 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4381 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4382 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4383 if (htab->elf.iplt == NULL
4384 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4387 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4388 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4391 if (htab->elf.irelplt == NULL
4392 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4395 /* Create branch lookup table for plt_branch stubs. */
4396 flags = (SEC_ALLOC | SEC_LOAD
4397 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4398 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4400 if (htab->brlt == NULL
4401 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4404 if (!bfd_link_pic (info))
4407 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4408 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4409 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4412 if (htab->relbrlt == NULL
4413 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4419 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4422 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4423 struct ppc64_elf_params *params)
4425 struct ppc_link_hash_table *htab;
4427 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4429 /* Always hook our dynamic sections into the first bfd, which is the
4430 linker created stub bfd. This ensures that the GOT header is at
4431 the start of the output TOC section. */
4432 htab = ppc_hash_table (info);
4433 htab->elf.dynobj = params->stub_bfd;
4434 htab->params = params;
4436 return create_linkage_sections (htab->elf.dynobj, info);
4439 /* Build a name for an entry in the stub hash table. */
4442 ppc_stub_name (const asection *input_section,
4443 const asection *sym_sec,
4444 const struct ppc_link_hash_entry *h,
4445 const Elf_Internal_Rela *rel)
4450 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4451 offsets from a sym as a branch target? In fact, we could
4452 probably assume the addend is always zero. */
4453 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4457 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4458 stub_name = bfd_malloc (len);
4459 if (stub_name == NULL)
4462 len = sprintf (stub_name, "%08x.%s+%x",
4463 input_section->id & 0xffffffff,
4464 h->elf.root.root.string,
4465 (int) rel->r_addend & 0xffffffff);
4469 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4470 stub_name = bfd_malloc (len);
4471 if (stub_name == NULL)
4474 len = sprintf (stub_name, "%08x.%x:%x+%x",
4475 input_section->id & 0xffffffff,
4476 sym_sec->id & 0xffffffff,
4477 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4478 (int) rel->r_addend & 0xffffffff);
4480 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4481 stub_name[len - 2] = 0;
4485 /* Look up an entry in the stub hash. Stub entries are cached because
4486 creating the stub name takes a bit of time. */
4488 static struct ppc_stub_hash_entry *
4489 ppc_get_stub_entry (const asection *input_section,
4490 const asection *sym_sec,
4491 struct ppc_link_hash_entry *h,
4492 const Elf_Internal_Rela *rel,
4493 struct ppc_link_hash_table *htab)
4495 struct ppc_stub_hash_entry *stub_entry;
4496 struct map_stub *group;
4498 /* If this input section is part of a group of sections sharing one
4499 stub section, then use the id of the first section in the group.
4500 Stub names need to include a section id, as there may well be
4501 more than one stub used to reach say, printf, and we need to
4502 distinguish between them. */
4503 group = htab->sec_info[input_section->id].u.group;
4505 if (h != NULL && h->u.stub_cache != NULL
4506 && h->u.stub_cache->h == h
4507 && h->u.stub_cache->group == group)
4509 stub_entry = h->u.stub_cache;
4515 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4516 if (stub_name == NULL)
4519 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4520 stub_name, FALSE, FALSE);
4522 h->u.stub_cache = stub_entry;
4530 /* Add a new stub entry to the stub hash. Not all fields of the new
4531 stub entry are initialised. */
4533 static struct ppc_stub_hash_entry *
4534 ppc_add_stub (const char *stub_name,
4536 struct bfd_link_info *info)
4538 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4539 struct map_stub *group;
4542 struct ppc_stub_hash_entry *stub_entry;
4544 group = htab->sec_info[section->id].u.group;
4545 link_sec = group->link_sec;
4546 stub_sec = group->stub_sec;
4547 if (stub_sec == NULL)
4553 namelen = strlen (link_sec->name);
4554 len = namelen + sizeof (STUB_SUFFIX);
4555 s_name = bfd_alloc (htab->params->stub_bfd, len);
4559 memcpy (s_name, link_sec->name, namelen);
4560 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4561 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4562 if (stub_sec == NULL)
4564 group->stub_sec = stub_sec;
4567 /* Enter this entry into the linker stub hash table. */
4568 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4570 if (stub_entry == NULL)
4572 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4573 section->owner, stub_name);
4577 stub_entry->group = group;
4578 stub_entry->stub_offset = 0;
4582 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4583 not already done. */
4586 create_got_section (bfd *abfd, struct bfd_link_info *info)
4588 asection *got, *relgot;
4590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4592 if (!is_ppc64_elf (abfd))
4598 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4601 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4602 | SEC_LINKER_CREATED);
4604 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4606 || !bfd_set_section_alignment (abfd, got, 3))
4609 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4610 flags | SEC_READONLY);
4612 || ! bfd_set_section_alignment (abfd, relgot, 3))
4615 ppc64_elf_tdata (abfd)->got = got;
4616 ppc64_elf_tdata (abfd)->relgot = relgot;
4620 /* Create the dynamic sections, and set up shortcuts. */
4623 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4625 struct ppc_link_hash_table *htab;
4627 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4630 htab = ppc_hash_table (info);
4634 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4635 if (!bfd_link_pic (info))
4636 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4638 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4639 || (!bfd_link_pic (info) && !htab->relbss))
4645 /* Follow indirect and warning symbol links. */
4647 static inline struct bfd_link_hash_entry *
4648 follow_link (struct bfd_link_hash_entry *h)
4650 while (h->type == bfd_link_hash_indirect
4651 || h->type == bfd_link_hash_warning)
4656 static inline struct elf_link_hash_entry *
4657 elf_follow_link (struct elf_link_hash_entry *h)
4659 return (struct elf_link_hash_entry *) follow_link (&h->root);
4662 static inline struct ppc_link_hash_entry *
4663 ppc_follow_link (struct ppc_link_hash_entry *h)
4665 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4668 /* Merge PLT info on FROM with that on TO. */
4671 move_plt_plist (struct ppc_link_hash_entry *from,
4672 struct ppc_link_hash_entry *to)
4674 if (from->elf.plt.plist != NULL)
4676 if (to->elf.plt.plist != NULL)
4678 struct plt_entry **entp;
4679 struct plt_entry *ent;
4681 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4683 struct plt_entry *dent;
4685 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4686 if (dent->addend == ent->addend)
4688 dent->plt.refcount += ent->plt.refcount;
4695 *entp = to->elf.plt.plist;
4698 to->elf.plt.plist = from->elf.plt.plist;
4699 from->elf.plt.plist = NULL;
4703 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4706 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4707 struct elf_link_hash_entry *dir,
4708 struct elf_link_hash_entry *ind)
4710 struct ppc_link_hash_entry *edir, *eind;
4712 edir = (struct ppc_link_hash_entry *) dir;
4713 eind = (struct ppc_link_hash_entry *) ind;
4715 edir->is_func |= eind->is_func;
4716 edir->is_func_descriptor |= eind->is_func_descriptor;
4717 edir->tls_mask |= eind->tls_mask;
4718 if (eind->oh != NULL)
4719 edir->oh = ppc_follow_link (eind->oh);
4721 /* If called to transfer flags for a weakdef during processing
4722 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4723 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4724 if (!(ELIMINATE_COPY_RELOCS
4725 && eind->elf.root.type != bfd_link_hash_indirect
4726 && edir->elf.dynamic_adjusted))
4727 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4729 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4730 edir->elf.ref_regular |= eind->elf.ref_regular;
4731 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4732 edir->elf.needs_plt |= eind->elf.needs_plt;
4733 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4735 /* Copy over any dynamic relocs we may have on the indirect sym. */
4736 if (eind->dyn_relocs != NULL)
4738 if (edir->dyn_relocs != NULL)
4740 struct elf_dyn_relocs **pp;
4741 struct elf_dyn_relocs *p;
4743 /* Add reloc counts against the indirect sym to the direct sym
4744 list. Merge any entries against the same section. */
4745 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4747 struct elf_dyn_relocs *q;
4749 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4750 if (q->sec == p->sec)
4752 q->pc_count += p->pc_count;
4753 q->count += p->count;
4760 *pp = edir->dyn_relocs;
4763 edir->dyn_relocs = eind->dyn_relocs;
4764 eind->dyn_relocs = NULL;
4767 /* If we were called to copy over info for a weak sym, that's all.
4768 You might think dyn_relocs need not be copied over; After all,
4769 both syms will be dynamic or both non-dynamic so we're just
4770 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4771 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4772 dyn_relocs in read-only sections, and it does so on what is the
4774 if (eind->elf.root.type != bfd_link_hash_indirect)
4777 /* Copy over got entries that we may have already seen to the
4778 symbol which just became indirect. */
4779 if (eind->elf.got.glist != NULL)
4781 if (edir->elf.got.glist != NULL)
4783 struct got_entry **entp;
4784 struct got_entry *ent;
4786 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4788 struct got_entry *dent;
4790 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4791 if (dent->addend == ent->addend
4792 && dent->owner == ent->owner
4793 && dent->tls_type == ent->tls_type)
4795 dent->got.refcount += ent->got.refcount;
4802 *entp = edir->elf.got.glist;
4805 edir->elf.got.glist = eind->elf.got.glist;
4806 eind->elf.got.glist = NULL;
4809 /* And plt entries. */
4810 move_plt_plist (eind, edir);
4812 if (eind->elf.dynindx != -1)
4814 if (edir->elf.dynindx != -1)
4815 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4816 edir->elf.dynstr_index);
4817 edir->elf.dynindx = eind->elf.dynindx;
4818 edir->elf.dynstr_index = eind->elf.dynstr_index;
4819 eind->elf.dynindx = -1;
4820 eind->elf.dynstr_index = 0;
4824 /* Find the function descriptor hash entry from the given function code
4825 hash entry FH. Link the entries via their OH fields. */
4827 static struct ppc_link_hash_entry *
4828 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4830 struct ppc_link_hash_entry *fdh = fh->oh;
4834 const char *fd_name = fh->elf.root.root.string + 1;
4836 fdh = (struct ppc_link_hash_entry *)
4837 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4841 fdh->is_func_descriptor = 1;
4847 return ppc_follow_link (fdh);
4850 /* Make a fake function descriptor sym for the code sym FH. */
4852 static struct ppc_link_hash_entry *
4853 make_fdh (struct bfd_link_info *info,
4854 struct ppc_link_hash_entry *fh)
4858 struct bfd_link_hash_entry *bh;
4859 struct ppc_link_hash_entry *fdh;
4861 abfd = fh->elf.root.u.undef.abfd;
4862 newsym = bfd_make_empty_symbol (abfd);
4863 newsym->name = fh->elf.root.root.string + 1;
4864 newsym->section = bfd_und_section_ptr;
4866 newsym->flags = BSF_WEAK;
4869 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4870 newsym->flags, newsym->section,
4871 newsym->value, NULL, FALSE, FALSE,
4875 fdh = (struct ppc_link_hash_entry *) bh;
4876 fdh->elf.non_elf = 0;
4878 fdh->is_func_descriptor = 1;
4885 /* Fix function descriptor symbols defined in .opd sections to be
4889 ppc64_elf_add_symbol_hook (bfd *ibfd,
4890 struct bfd_link_info *info,
4891 Elf_Internal_Sym *isym,
4893 flagword *flags ATTRIBUTE_UNUSED,
4897 if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4898 || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
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_any;
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 if (opt_fd->dynindx != -1)
8231 /* Use __tls_get_addr_opt in dynamic relocations. */
8232 opt_fd->dynindx = -1;
8233 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8234 opt_fd->dynstr_index);
8235 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8238 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8239 tga = &htab->tls_get_addr->elf;
8240 if (opt != NULL && tga != NULL)
8242 tga->root.type = bfd_link_hash_indirect;
8243 tga->root.u.i.link = &opt->root;
8244 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8245 _bfd_elf_link_hash_hide_symbol (info, opt,
8247 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8249 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8250 htab->tls_get_addr_fd->is_func_descriptor = 1;
8251 if (htab->tls_get_addr != NULL)
8253 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8254 htab->tls_get_addr->is_func = 1;
8259 else if (htab->params->tls_get_addr_opt < 0)
8260 htab->params->tls_get_addr_opt = 0;
8262 return _bfd_elf_tls_setup (info->output_bfd, info);
8265 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8269 branch_reloc_hash_match (const bfd *ibfd,
8270 const Elf_Internal_Rela *rel,
8271 const struct ppc_link_hash_entry *hash1,
8272 const struct ppc_link_hash_entry *hash2)
8274 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8275 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8276 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8278 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8280 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8281 struct elf_link_hash_entry *h;
8283 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8284 h = elf_follow_link (h);
8285 if (h == &hash1->elf || h == &hash2->elf)
8291 /* Run through all the TLS relocs looking for optimization
8292 opportunities. The linker has been hacked (see ppc64elf.em) to do
8293 a preliminary section layout so that we know the TLS segment
8294 offsets. We can't optimize earlier because some optimizations need
8295 to know the tp offset, and we need to optimize before allocating
8296 dynamic relocations. */
8299 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8303 struct ppc_link_hash_table *htab;
8304 unsigned char *toc_ref;
8307 if (!bfd_link_executable (info))
8310 htab = ppc_hash_table (info);
8314 /* Make two passes over the relocs. On the first pass, mark toc
8315 entries involved with tls relocs, and check that tls relocs
8316 involved in setting up a tls_get_addr call are indeed followed by
8317 such a call. If they are not, we can't do any tls optimization.
8318 On the second pass twiddle tls_mask flags to notify
8319 relocate_section that optimization can be done, and adjust got
8320 and plt refcounts. */
8322 for (pass = 0; pass < 2; ++pass)
8323 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8325 Elf_Internal_Sym *locsyms = NULL;
8326 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8328 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8329 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8331 Elf_Internal_Rela *relstart, *rel, *relend;
8332 bfd_boolean found_tls_get_addr_arg = 0;
8334 /* Read the relocations. */
8335 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8337 if (relstart == NULL)
8343 relend = relstart + sec->reloc_count;
8344 for (rel = relstart; rel < relend; rel++)
8346 enum elf_ppc64_reloc_type r_type;
8347 unsigned long r_symndx;
8348 struct elf_link_hash_entry *h;
8349 Elf_Internal_Sym *sym;
8351 unsigned char *tls_mask;
8352 unsigned char tls_set, tls_clear, tls_type = 0;
8354 bfd_boolean ok_tprel, is_local;
8355 long toc_ref_index = 0;
8356 int expecting_tls_get_addr = 0;
8357 bfd_boolean ret = FALSE;
8359 r_symndx = ELF64_R_SYM (rel->r_info);
8360 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8364 if (elf_section_data (sec)->relocs != relstart)
8366 if (toc_ref != NULL)
8369 && (elf_symtab_hdr (ibfd).contents
8370 != (unsigned char *) locsyms))
8377 if (h->root.type == bfd_link_hash_defined
8378 || h->root.type == bfd_link_hash_defweak)
8379 value = h->root.u.def.value;
8380 else if (h->root.type == bfd_link_hash_undefweak)
8384 found_tls_get_addr_arg = 0;
8389 /* Symbols referenced by TLS relocs must be of type
8390 STT_TLS. So no need for .opd local sym adjust. */
8391 value = sym->st_value;
8400 && h->root.type == bfd_link_hash_undefweak)
8402 else if (sym_sec != NULL
8403 && sym_sec->output_section != NULL)
8405 value += sym_sec->output_offset;
8406 value += sym_sec->output_section->vma;
8407 value -= htab->elf.tls_sec->vma;
8408 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8409 < (bfd_vma) 1 << 32);
8413 r_type = ELF64_R_TYPE (rel->r_info);
8414 /* If this section has old-style __tls_get_addr calls
8415 without marker relocs, then check that each
8416 __tls_get_addr call reloc is preceded by a reloc
8417 that conceivably belongs to the __tls_get_addr arg
8418 setup insn. If we don't find matching arg setup
8419 relocs, don't do any tls optimization. */
8421 && sec->has_tls_get_addr_call
8423 && (h == &htab->tls_get_addr->elf
8424 || h == &htab->tls_get_addr_fd->elf)
8425 && !found_tls_get_addr_arg
8426 && is_branch_reloc (r_type))
8428 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8429 "TLS optimization disabled\n"),
8430 ibfd, sec, rel->r_offset);
8435 found_tls_get_addr_arg = 0;
8438 case R_PPC64_GOT_TLSLD16:
8439 case R_PPC64_GOT_TLSLD16_LO:
8440 expecting_tls_get_addr = 1;
8441 found_tls_get_addr_arg = 1;
8444 case R_PPC64_GOT_TLSLD16_HI:
8445 case R_PPC64_GOT_TLSLD16_HA:
8446 /* These relocs should never be against a symbol
8447 defined in a shared lib. Leave them alone if
8448 that turns out to be the case. */
8455 tls_type = TLS_TLS | TLS_LD;
8458 case R_PPC64_GOT_TLSGD16:
8459 case R_PPC64_GOT_TLSGD16_LO:
8460 expecting_tls_get_addr = 1;
8461 found_tls_get_addr_arg = 1;
8464 case R_PPC64_GOT_TLSGD16_HI:
8465 case R_PPC64_GOT_TLSGD16_HA:
8471 tls_set = TLS_TLS | TLS_TPRELGD;
8473 tls_type = TLS_TLS | TLS_GD;
8476 case R_PPC64_GOT_TPREL16_DS:
8477 case R_PPC64_GOT_TPREL16_LO_DS:
8478 case R_PPC64_GOT_TPREL16_HI:
8479 case R_PPC64_GOT_TPREL16_HA:
8484 tls_clear = TLS_TPREL;
8485 tls_type = TLS_TLS | TLS_TPREL;
8492 found_tls_get_addr_arg = 1;
8497 case R_PPC64_TOC16_LO:
8498 if (sym_sec == NULL || sym_sec != toc)
8501 /* Mark this toc entry as referenced by a TLS
8502 code sequence. We can do that now in the
8503 case of R_PPC64_TLS, and after checking for
8504 tls_get_addr for the TOC16 relocs. */
8505 if (toc_ref == NULL)
8506 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8507 if (toc_ref == NULL)
8511 value = h->root.u.def.value;
8513 value = sym->st_value;
8514 value += rel->r_addend;
8517 BFD_ASSERT (value < toc->size
8518 && toc->output_offset % 8 == 0);
8519 toc_ref_index = (value + toc->output_offset) / 8;
8520 if (r_type == R_PPC64_TLS
8521 || r_type == R_PPC64_TLSGD
8522 || r_type == R_PPC64_TLSLD)
8524 toc_ref[toc_ref_index] = 1;
8528 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8533 expecting_tls_get_addr = 2;
8536 case R_PPC64_TPREL64:
8540 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8545 tls_set = TLS_EXPLICIT;
8546 tls_clear = TLS_TPREL;
8551 case R_PPC64_DTPMOD64:
8555 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8557 if (rel + 1 < relend
8559 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8560 && rel[1].r_offset == rel->r_offset + 8)
8564 tls_set = TLS_EXPLICIT | TLS_GD;
8567 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8576 tls_set = TLS_EXPLICIT;
8587 if (!expecting_tls_get_addr
8588 || !sec->has_tls_get_addr_call)
8591 if (rel + 1 < relend
8592 && branch_reloc_hash_match (ibfd, rel + 1,
8594 htab->tls_get_addr_fd))
8596 if (expecting_tls_get_addr == 2)
8598 /* Check for toc tls entries. */
8599 unsigned char *toc_tls;
8602 retval = get_tls_mask (&toc_tls, NULL, NULL,
8607 if (toc_tls != NULL)
8609 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8610 found_tls_get_addr_arg = 1;
8612 toc_ref[toc_ref_index] = 1;
8618 if (expecting_tls_get_addr != 1)
8621 /* Uh oh, we didn't find the expected call. We
8622 could just mark this symbol to exclude it
8623 from tls optimization but it's safer to skip
8624 the entire optimization. */
8625 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8626 "TLS optimization disabled\n"),
8627 ibfd, sec, rel->r_offset);
8632 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8634 struct plt_entry *ent;
8635 for (ent = htab->tls_get_addr->elf.plt.plist;
8638 if (ent->addend == 0)
8640 if (ent->plt.refcount > 0)
8642 ent->plt.refcount -= 1;
8643 expecting_tls_get_addr = 0;
8649 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8651 struct plt_entry *ent;
8652 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8655 if (ent->addend == 0)
8657 if (ent->plt.refcount > 0)
8658 ent->plt.refcount -= 1;
8666 if ((tls_set & TLS_EXPLICIT) == 0)
8668 struct got_entry *ent;
8670 /* Adjust got entry for this reloc. */
8674 ent = elf_local_got_ents (ibfd)[r_symndx];
8676 for (; ent != NULL; ent = ent->next)
8677 if (ent->addend == rel->r_addend
8678 && ent->owner == ibfd
8679 && ent->tls_type == tls_type)
8686 /* We managed to get rid of a got entry. */
8687 if (ent->got.refcount > 0)
8688 ent->got.refcount -= 1;
8693 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8694 we'll lose one or two dyn relocs. */
8695 if (!dec_dynrel_count (rel->r_info, sec, info,
8699 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8701 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8707 *tls_mask |= tls_set;
8708 *tls_mask &= ~tls_clear;
8711 if (elf_section_data (sec)->relocs != relstart)
8716 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8718 if (!info->keep_memory)
8721 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8725 if (toc_ref != NULL)
8730 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8731 the values of any global symbols in a toc section that has been
8732 edited. Globals in toc sections should be a rarity, so this function
8733 sets a flag if any are found in toc sections other than the one just
8734 edited, so that futher hash table traversals can be avoided. */
8736 struct adjust_toc_info
8739 unsigned long *skip;
8740 bfd_boolean global_toc_syms;
8743 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8746 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8748 struct ppc_link_hash_entry *eh;
8749 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8752 if (h->root.type != bfd_link_hash_defined
8753 && h->root.type != bfd_link_hash_defweak)
8756 eh = (struct ppc_link_hash_entry *) h;
8757 if (eh->adjust_done)
8760 if (eh->elf.root.u.def.section == toc_inf->toc)
8762 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8763 i = toc_inf->toc->rawsize >> 3;
8765 i = eh->elf.root.u.def.value >> 3;
8767 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8769 (*_bfd_error_handler)
8770 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8773 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8774 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8777 eh->elf.root.u.def.value -= toc_inf->skip[i];
8778 eh->adjust_done = 1;
8780 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8781 toc_inf->global_toc_syms = TRUE;
8786 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8789 ok_lo_toc_insn (unsigned int insn)
8791 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8792 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8793 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8794 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8795 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8796 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8797 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8798 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8799 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8800 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8801 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8802 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8803 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8804 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8805 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8807 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8808 && ((insn & 3) == 0 || (insn & 3) == 3))
8809 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8812 /* Examine all relocs referencing .toc sections in order to remove
8813 unused .toc entries. */
8816 ppc64_elf_edit_toc (struct bfd_link_info *info)
8819 struct adjust_toc_info toc_inf;
8820 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8822 htab->do_toc_opt = 1;
8823 toc_inf.global_toc_syms = TRUE;
8824 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8826 asection *toc, *sec;
8827 Elf_Internal_Shdr *symtab_hdr;
8828 Elf_Internal_Sym *local_syms;
8829 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8830 unsigned long *skip, *drop;
8831 unsigned char *used;
8832 unsigned char *keep, last, some_unused;
8834 if (!is_ppc64_elf (ibfd))
8837 toc = bfd_get_section_by_name (ibfd, ".toc");
8840 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8841 || discarded_section (toc))
8846 symtab_hdr = &elf_symtab_hdr (ibfd);
8848 /* Look at sections dropped from the final link. */
8851 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8853 if (sec->reloc_count == 0
8854 || !discarded_section (sec)
8855 || get_opd_info (sec)
8856 || (sec->flags & SEC_ALLOC) == 0
8857 || (sec->flags & SEC_DEBUGGING) != 0)
8860 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8861 if (relstart == NULL)
8864 /* Run through the relocs to see which toc entries might be
8866 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8868 enum elf_ppc64_reloc_type r_type;
8869 unsigned long r_symndx;
8871 struct elf_link_hash_entry *h;
8872 Elf_Internal_Sym *sym;
8875 r_type = ELF64_R_TYPE (rel->r_info);
8882 case R_PPC64_TOC16_LO:
8883 case R_PPC64_TOC16_HI:
8884 case R_PPC64_TOC16_HA:
8885 case R_PPC64_TOC16_DS:
8886 case R_PPC64_TOC16_LO_DS:
8890 r_symndx = ELF64_R_SYM (rel->r_info);
8891 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8899 val = h->root.u.def.value;
8901 val = sym->st_value;
8902 val += rel->r_addend;
8904 if (val >= toc->size)
8907 /* Anything in the toc ought to be aligned to 8 bytes.
8908 If not, don't mark as unused. */
8914 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8919 skip[val >> 3] = ref_from_discarded;
8922 if (elf_section_data (sec)->relocs != relstart)
8926 /* For largetoc loads of address constants, we can convert
8927 . addis rx,2,addr@got@ha
8928 . ld ry,addr@got@l(rx)
8930 . addis rx,2,addr@toc@ha
8931 . addi ry,rx,addr@toc@l
8932 when addr is within 2G of the toc pointer. This then means
8933 that the word storing "addr" in the toc is no longer needed. */
8935 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8936 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8937 && toc->reloc_count != 0)
8939 /* Read toc relocs. */
8940 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8942 if (toc_relocs == NULL)
8945 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8947 enum elf_ppc64_reloc_type r_type;
8948 unsigned long r_symndx;
8950 struct elf_link_hash_entry *h;
8951 Elf_Internal_Sym *sym;
8954 r_type = ELF64_R_TYPE (rel->r_info);
8955 if (r_type != R_PPC64_ADDR64)
8958 r_symndx = ELF64_R_SYM (rel->r_info);
8959 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8964 || sym_sec->output_section == NULL
8965 || discarded_section (sym_sec))
8968 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8973 if (h->type == STT_GNU_IFUNC)
8975 val = h->root.u.def.value;
8979 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8981 val = sym->st_value;
8983 val += rel->r_addend;
8984 val += sym_sec->output_section->vma + sym_sec->output_offset;
8986 /* We don't yet know the exact toc pointer value, but we
8987 know it will be somewhere in the toc section. Don't
8988 optimize if the difference from any possible toc
8989 pointer is outside [ff..f80008000, 7fff7fff]. */
8990 addr = toc->output_section->vma + TOC_BASE_OFF;
8991 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8994 addr = toc->output_section->vma + toc->output_section->rawsize;
8995 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9000 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9005 skip[rel->r_offset >> 3]
9006 |= can_optimize | ((rel - toc_relocs) << 2);
9013 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9017 if (local_syms != NULL
9018 && symtab_hdr->contents != (unsigned char *) local_syms)
9022 && elf_section_data (sec)->relocs != relstart)
9024 if (toc_relocs != NULL
9025 && elf_section_data (toc)->relocs != toc_relocs)
9032 /* Now check all kept sections that might reference the toc.
9033 Check the toc itself last. */
9034 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9037 sec = (sec == toc ? NULL
9038 : sec->next == NULL ? toc
9039 : sec->next == toc && toc->next ? toc->next
9044 if (sec->reloc_count == 0
9045 || discarded_section (sec)
9046 || get_opd_info (sec)
9047 || (sec->flags & SEC_ALLOC) == 0
9048 || (sec->flags & SEC_DEBUGGING) != 0)
9051 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9053 if (relstart == NULL)
9059 /* Mark toc entries referenced as used. */
9063 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9065 enum elf_ppc64_reloc_type r_type;
9066 unsigned long r_symndx;
9068 struct elf_link_hash_entry *h;
9069 Elf_Internal_Sym *sym;
9071 enum {no_check, check_lo, check_ha} insn_check;
9073 r_type = ELF64_R_TYPE (rel->r_info);
9077 insn_check = no_check;
9080 case R_PPC64_GOT_TLSLD16_HA:
9081 case R_PPC64_GOT_TLSGD16_HA:
9082 case R_PPC64_GOT_TPREL16_HA:
9083 case R_PPC64_GOT_DTPREL16_HA:
9084 case R_PPC64_GOT16_HA:
9085 case R_PPC64_TOC16_HA:
9086 insn_check = check_ha;
9089 case R_PPC64_GOT_TLSLD16_LO:
9090 case R_PPC64_GOT_TLSGD16_LO:
9091 case R_PPC64_GOT_TPREL16_LO_DS:
9092 case R_PPC64_GOT_DTPREL16_LO_DS:
9093 case R_PPC64_GOT16_LO:
9094 case R_PPC64_GOT16_LO_DS:
9095 case R_PPC64_TOC16_LO:
9096 case R_PPC64_TOC16_LO_DS:
9097 insn_check = check_lo;
9101 if (insn_check != no_check)
9103 bfd_vma off = rel->r_offset & ~3;
9104 unsigned char buf[4];
9107 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9112 insn = bfd_get_32 (ibfd, buf);
9113 if (insn_check == check_lo
9114 ? !ok_lo_toc_insn (insn)
9115 : ((insn & ((0x3f << 26) | 0x1f << 16))
9116 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9120 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9121 sprintf (str, "%#08x", insn);
9122 info->callbacks->einfo
9123 (_("%P: %H: toc optimization is not supported for"
9124 " %s instruction.\n"),
9125 ibfd, sec, rel->r_offset & ~3, str);
9132 case R_PPC64_TOC16_LO:
9133 case R_PPC64_TOC16_HI:
9134 case R_PPC64_TOC16_HA:
9135 case R_PPC64_TOC16_DS:
9136 case R_PPC64_TOC16_LO_DS:
9137 /* In case we're taking addresses of toc entries. */
9138 case R_PPC64_ADDR64:
9145 r_symndx = ELF64_R_SYM (rel->r_info);
9146 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9157 val = h->root.u.def.value;
9159 val = sym->st_value;
9160 val += rel->r_addend;
9162 if (val >= toc->size)
9165 if ((skip[val >> 3] & can_optimize) != 0)
9172 case R_PPC64_TOC16_HA:
9175 case R_PPC64_TOC16_LO_DS:
9176 off = rel->r_offset;
9177 off += (bfd_big_endian (ibfd) ? -2 : 3);
9178 if (!bfd_get_section_contents (ibfd, sec, &opc,
9184 if ((opc & (0x3f << 2)) == (58u << 2))
9189 /* Wrong sort of reloc, or not a ld. We may
9190 as well clear ref_from_discarded too. */
9197 /* For the toc section, we only mark as used if this
9198 entry itself isn't unused. */
9199 else if ((used[rel->r_offset >> 3]
9200 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9203 /* Do all the relocs again, to catch reference
9212 if (elf_section_data (sec)->relocs != relstart)
9216 /* Merge the used and skip arrays. Assume that TOC
9217 doublewords not appearing as either used or unused belong
9218 to to an entry more than one doubleword in size. */
9219 for (drop = skip, keep = used, last = 0, some_unused = 0;
9220 drop < skip + (toc->size + 7) / 8;
9225 *drop &= ~ref_from_discarded;
9226 if ((*drop & can_optimize) != 0)
9230 else if ((*drop & ref_from_discarded) != 0)
9233 last = ref_from_discarded;
9243 bfd_byte *contents, *src;
9245 Elf_Internal_Sym *sym;
9246 bfd_boolean local_toc_syms = FALSE;
9248 /* Shuffle the toc contents, and at the same time convert the
9249 skip array from booleans into offsets. */
9250 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9253 elf_section_data (toc)->this_hdr.contents = contents;
9255 for (src = contents, off = 0, drop = skip;
9256 src < contents + toc->size;
9259 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9264 memcpy (src - off, src, 8);
9268 toc->rawsize = toc->size;
9269 toc->size = src - contents - off;
9271 /* Adjust addends for relocs against the toc section sym,
9272 and optimize any accesses we can. */
9273 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9275 if (sec->reloc_count == 0
9276 || discarded_section (sec))
9279 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9281 if (relstart == NULL)
9284 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9286 enum elf_ppc64_reloc_type r_type;
9287 unsigned long r_symndx;
9289 struct elf_link_hash_entry *h;
9292 r_type = ELF64_R_TYPE (rel->r_info);
9299 case R_PPC64_TOC16_LO:
9300 case R_PPC64_TOC16_HI:
9301 case R_PPC64_TOC16_HA:
9302 case R_PPC64_TOC16_DS:
9303 case R_PPC64_TOC16_LO_DS:
9304 case R_PPC64_ADDR64:
9308 r_symndx = ELF64_R_SYM (rel->r_info);
9309 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9317 val = h->root.u.def.value;
9320 val = sym->st_value;
9322 local_toc_syms = TRUE;
9325 val += rel->r_addend;
9327 if (val > toc->rawsize)
9329 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9331 else if ((skip[val >> 3] & can_optimize) != 0)
9333 Elf_Internal_Rela *tocrel
9334 = toc_relocs + (skip[val >> 3] >> 2);
9335 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9339 case R_PPC64_TOC16_HA:
9340 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9343 case R_PPC64_TOC16_LO_DS:
9344 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9348 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9350 info->callbacks->einfo
9351 (_("%P: %H: %s references "
9352 "optimized away TOC entry\n"),
9353 ibfd, sec, rel->r_offset,
9354 ppc64_elf_howto_table[r_type]->name);
9355 bfd_set_error (bfd_error_bad_value);
9358 rel->r_addend = tocrel->r_addend;
9359 elf_section_data (sec)->relocs = relstart;
9363 if (h != NULL || sym->st_value != 0)
9366 rel->r_addend -= skip[val >> 3];
9367 elf_section_data (sec)->relocs = relstart;
9370 if (elf_section_data (sec)->relocs != relstart)
9374 /* We shouldn't have local or global symbols defined in the TOC,
9375 but handle them anyway. */
9376 if (local_syms != NULL)
9377 for (sym = local_syms;
9378 sym < local_syms + symtab_hdr->sh_info;
9380 if (sym->st_value != 0
9381 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9385 if (sym->st_value > toc->rawsize)
9386 i = toc->rawsize >> 3;
9388 i = sym->st_value >> 3;
9390 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9393 (*_bfd_error_handler)
9394 (_("%s defined on removed toc entry"),
9395 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9398 while ((skip[i] & (ref_from_discarded | can_optimize)));
9399 sym->st_value = (bfd_vma) i << 3;
9402 sym->st_value -= skip[i];
9403 symtab_hdr->contents = (unsigned char *) local_syms;
9406 /* Adjust any global syms defined in this toc input section. */
9407 if (toc_inf.global_toc_syms)
9410 toc_inf.skip = skip;
9411 toc_inf.global_toc_syms = FALSE;
9412 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9416 if (toc->reloc_count != 0)
9418 Elf_Internal_Shdr *rel_hdr;
9419 Elf_Internal_Rela *wrel;
9422 /* Remove unused toc relocs, and adjust those we keep. */
9423 if (toc_relocs == NULL)
9424 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9426 if (toc_relocs == NULL)
9430 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9431 if ((skip[rel->r_offset >> 3]
9432 & (ref_from_discarded | can_optimize)) == 0)
9434 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9435 wrel->r_info = rel->r_info;
9436 wrel->r_addend = rel->r_addend;
9439 else if (!dec_dynrel_count (rel->r_info, toc, info,
9440 &local_syms, NULL, NULL))
9443 elf_section_data (toc)->relocs = toc_relocs;
9444 toc->reloc_count = wrel - toc_relocs;
9445 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9446 sz = rel_hdr->sh_entsize;
9447 rel_hdr->sh_size = toc->reloc_count * sz;
9450 else if (toc_relocs != NULL
9451 && elf_section_data (toc)->relocs != toc_relocs)
9454 if (local_syms != NULL
9455 && symtab_hdr->contents != (unsigned char *) local_syms)
9457 if (!info->keep_memory)
9460 symtab_hdr->contents = (unsigned char *) local_syms;
9468 /* Return true iff input section I references the TOC using
9469 instructions limited to +/-32k offsets. */
9472 ppc64_elf_has_small_toc_reloc (asection *i)
9474 return (is_ppc64_elf (i->owner)
9475 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9478 /* Allocate space for one GOT entry. */
9481 allocate_got (struct elf_link_hash_entry *h,
9482 struct bfd_link_info *info,
9483 struct got_entry *gent)
9485 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9487 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9488 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9490 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9491 ? 2 : 1) * sizeof (Elf64_External_Rela);
9492 asection *got = ppc64_elf_tdata (gent->owner)->got;
9494 gent->got.offset = got->size;
9495 got->size += entsize;
9497 dyn = htab->elf.dynamic_sections_created;
9498 if (h->type == STT_GNU_IFUNC)
9500 htab->elf.irelplt->size += rentsize;
9501 htab->got_reli_size += rentsize;
9503 else if ((bfd_link_pic (info)
9504 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9505 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9506 || h->root.type != bfd_link_hash_undefweak))
9508 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9509 relgot->size += rentsize;
9513 /* This function merges got entries in the same toc group. */
9516 merge_got_entries (struct got_entry **pent)
9518 struct got_entry *ent, *ent2;
9520 for (ent = *pent; ent != NULL; ent = ent->next)
9521 if (!ent->is_indirect)
9522 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9523 if (!ent2->is_indirect
9524 && ent2->addend == ent->addend
9525 && ent2->tls_type == ent->tls_type
9526 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9528 ent2->is_indirect = TRUE;
9529 ent2->got.ent = ent;
9533 /* Allocate space in .plt, .got and associated reloc sections for
9537 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9539 struct bfd_link_info *info;
9540 struct ppc_link_hash_table *htab;
9542 struct ppc_link_hash_entry *eh;
9543 struct elf_dyn_relocs *p;
9544 struct got_entry **pgent, *gent;
9546 if (h->root.type == bfd_link_hash_indirect)
9549 info = (struct bfd_link_info *) inf;
9550 htab = ppc_hash_table (info);
9554 if ((htab->elf.dynamic_sections_created
9556 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9557 || h->type == STT_GNU_IFUNC)
9559 struct plt_entry *pent;
9560 bfd_boolean doneone = FALSE;
9561 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9562 if (pent->plt.refcount > 0)
9564 if (!htab->elf.dynamic_sections_created
9565 || h->dynindx == -1)
9568 pent->plt.offset = s->size;
9569 s->size += PLT_ENTRY_SIZE (htab);
9570 s = htab->elf.irelplt;
9574 /* If this is the first .plt entry, make room for the special
9578 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9580 pent->plt.offset = s->size;
9582 /* Make room for this entry. */
9583 s->size += PLT_ENTRY_SIZE (htab);
9585 /* Make room for the .glink code. */
9588 s->size += GLINK_CALL_STUB_SIZE;
9591 /* We need bigger stubs past index 32767. */
9592 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9599 /* We also need to make an entry in the .rela.plt section. */
9600 s = htab->elf.srelplt;
9602 s->size += sizeof (Elf64_External_Rela);
9606 pent->plt.offset = (bfd_vma) -1;
9609 h->plt.plist = NULL;
9615 h->plt.plist = NULL;
9619 eh = (struct ppc_link_hash_entry *) h;
9620 /* Run through the TLS GD got entries first if we're changing them
9622 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9623 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9624 if (gent->got.refcount > 0
9625 && (gent->tls_type & TLS_GD) != 0)
9627 /* This was a GD entry that has been converted to TPREL. If
9628 there happens to be a TPREL entry we can use that one. */
9629 struct got_entry *ent;
9630 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9631 if (ent->got.refcount > 0
9632 && (ent->tls_type & TLS_TPREL) != 0
9633 && ent->addend == gent->addend
9634 && ent->owner == gent->owner)
9636 gent->got.refcount = 0;
9640 /* If not, then we'll be using our own TPREL entry. */
9641 if (gent->got.refcount != 0)
9642 gent->tls_type = TLS_TLS | TLS_TPREL;
9645 /* Remove any list entry that won't generate a word in the GOT before
9646 we call merge_got_entries. Otherwise we risk merging to empty
9648 pgent = &h->got.glist;
9649 while ((gent = *pgent) != NULL)
9650 if (gent->got.refcount > 0)
9652 if ((gent->tls_type & TLS_LD) != 0
9655 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9656 *pgent = gent->next;
9659 pgent = &gent->next;
9662 *pgent = gent->next;
9664 if (!htab->do_multi_toc)
9665 merge_got_entries (&h->got.glist);
9667 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9668 if (!gent->is_indirect)
9670 /* Make sure this symbol is output as a dynamic symbol.
9671 Undefined weak syms won't yet be marked as dynamic,
9672 nor will all TLS symbols. */
9673 if (h->dynindx == -1
9675 && h->type != STT_GNU_IFUNC
9676 && htab->elf.dynamic_sections_created)
9678 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9682 if (!is_ppc64_elf (gent->owner))
9685 allocate_got (h, info, gent);
9688 if (eh->dyn_relocs == NULL
9689 || (!htab->elf.dynamic_sections_created
9690 && h->type != STT_GNU_IFUNC))
9693 /* In the shared -Bsymbolic case, discard space allocated for
9694 dynamic pc-relative relocs against symbols which turn out to be
9695 defined in regular objects. For the normal shared case, discard
9696 space for relocs that have become local due to symbol visibility
9699 if (bfd_link_pic (info))
9701 /* Relocs that use pc_count are those that appear on a call insn,
9702 or certain REL relocs (see must_be_dyn_reloc) that can be
9703 generated via assembly. We want calls to protected symbols to
9704 resolve directly to the function rather than going via the plt.
9705 If people want function pointer comparisons to work as expected
9706 then they should avoid writing weird assembly. */
9707 if (SYMBOL_CALLS_LOCAL (info, h))
9709 struct elf_dyn_relocs **pp;
9711 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9713 p->count -= p->pc_count;
9722 /* Also discard relocs on undefined weak syms with non-default
9724 if (eh->dyn_relocs != NULL
9725 && h->root.type == bfd_link_hash_undefweak)
9727 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9728 eh->dyn_relocs = NULL;
9730 /* Make sure this symbol is output as a dynamic symbol.
9731 Undefined weak syms won't yet be marked as dynamic. */
9732 else if (h->dynindx == -1
9733 && !h->forced_local)
9735 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9740 else if (h->type == STT_GNU_IFUNC)
9742 if (!h->non_got_ref)
9743 eh->dyn_relocs = NULL;
9745 else if (ELIMINATE_COPY_RELOCS)
9747 /* For the non-shared case, discard space for relocs against
9748 symbols which turn out to need copy relocs or are not
9754 /* Make sure this symbol is output as a dynamic symbol.
9755 Undefined weak syms won't yet be marked as dynamic. */
9756 if (h->dynindx == -1
9757 && !h->forced_local)
9759 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9763 /* If that succeeded, we know we'll be keeping all the
9765 if (h->dynindx != -1)
9769 eh->dyn_relocs = NULL;
9774 /* Finally, allocate space. */
9775 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9777 asection *sreloc = elf_section_data (p->sec)->sreloc;
9778 if (eh->elf.type == STT_GNU_IFUNC)
9779 sreloc = htab->elf.irelplt;
9780 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9786 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9787 to set up space for global entry stubs. These are put in glink,
9788 after the branch table. */
9791 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9793 struct bfd_link_info *info;
9794 struct ppc_link_hash_table *htab;
9795 struct plt_entry *pent;
9798 if (h->root.type == bfd_link_hash_indirect)
9801 if (!h->pointer_equality_needed)
9808 htab = ppc_hash_table (info);
9813 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9814 if (pent->plt.offset != (bfd_vma) -1
9815 && pent->addend == 0)
9817 /* For ELFv2, if this symbol is not defined in a regular file
9818 and we are not generating a shared library or pie, then we
9819 need to define the symbol in the executable on a call stub.
9820 This is to avoid text relocations. */
9821 s->size = (s->size + 15) & -16;
9822 h->root.u.def.section = s;
9823 h->root.u.def.value = s->size;
9830 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9831 read-only sections. */
9834 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9836 if (h->root.type == bfd_link_hash_indirect)
9839 if (readonly_dynrelocs (h))
9841 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9843 /* Not an error, just cut short the traversal. */
9849 /* Set the sizes of the dynamic sections. */
9852 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9853 struct bfd_link_info *info)
9855 struct ppc_link_hash_table *htab;
9860 struct got_entry *first_tlsld;
9862 htab = ppc_hash_table (info);
9866 dynobj = htab->elf.dynobj;
9870 if (htab->elf.dynamic_sections_created)
9872 /* Set the contents of the .interp section to the interpreter. */
9873 if (bfd_link_executable (info) && !info->nointerp)
9875 s = bfd_get_linker_section (dynobj, ".interp");
9878 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9879 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9883 /* Set up .got offsets for local syms, and space for local dynamic
9885 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9887 struct got_entry **lgot_ents;
9888 struct got_entry **end_lgot_ents;
9889 struct plt_entry **local_plt;
9890 struct plt_entry **end_local_plt;
9891 unsigned char *lgot_masks;
9892 bfd_size_type locsymcount;
9893 Elf_Internal_Shdr *symtab_hdr;
9895 if (!is_ppc64_elf (ibfd))
9898 for (s = ibfd->sections; s != NULL; s = s->next)
9900 struct ppc_dyn_relocs *p;
9902 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9904 if (!bfd_is_abs_section (p->sec)
9905 && bfd_is_abs_section (p->sec->output_section))
9907 /* Input section has been discarded, either because
9908 it is a copy of a linkonce section or due to
9909 linker script /DISCARD/, so we'll be discarding
9912 else if (p->count != 0)
9914 asection *srel = elf_section_data (p->sec)->sreloc;
9916 srel = htab->elf.irelplt;
9917 srel->size += p->count * sizeof (Elf64_External_Rela);
9918 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9919 info->flags |= DF_TEXTREL;
9924 lgot_ents = elf_local_got_ents (ibfd);
9928 symtab_hdr = &elf_symtab_hdr (ibfd);
9929 locsymcount = symtab_hdr->sh_info;
9930 end_lgot_ents = lgot_ents + locsymcount;
9931 local_plt = (struct plt_entry **) end_lgot_ents;
9932 end_local_plt = local_plt + locsymcount;
9933 lgot_masks = (unsigned char *) end_local_plt;
9934 s = ppc64_elf_tdata (ibfd)->got;
9935 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9937 struct got_entry **pent, *ent;
9940 while ((ent = *pent) != NULL)
9941 if (ent->got.refcount > 0)
9943 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9945 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9950 unsigned int ent_size = 8;
9951 unsigned int rel_size = sizeof (Elf64_External_Rela);
9953 ent->got.offset = s->size;
9954 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9959 s->size += ent_size;
9960 if ((*lgot_masks & PLT_IFUNC) != 0)
9962 htab->elf.irelplt->size += rel_size;
9963 htab->got_reli_size += rel_size;
9965 else if (bfd_link_pic (info))
9967 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9968 srel->size += rel_size;
9977 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9978 for (; local_plt < end_local_plt; ++local_plt)
9980 struct plt_entry *ent;
9982 for (ent = *local_plt; ent != NULL; ent = ent->next)
9983 if (ent->plt.refcount > 0)
9986 ent->plt.offset = s->size;
9987 s->size += PLT_ENTRY_SIZE (htab);
9989 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9992 ent->plt.offset = (bfd_vma) -1;
9996 /* Allocate global sym .plt and .got entries, and space for global
9997 sym dynamic relocs. */
9998 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9999 /* Stash the end of glink branch table. */
10000 if (htab->glink != NULL)
10001 htab->glink->rawsize = htab->glink->size;
10003 if (!htab->opd_abi && !bfd_link_pic (info))
10004 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10006 first_tlsld = NULL;
10007 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10009 struct got_entry *ent;
10011 if (!is_ppc64_elf (ibfd))
10014 ent = ppc64_tlsld_got (ibfd);
10015 if (ent->got.refcount > 0)
10017 if (!htab->do_multi_toc && first_tlsld != NULL)
10019 ent->is_indirect = TRUE;
10020 ent->got.ent = first_tlsld;
10024 if (first_tlsld == NULL)
10026 s = ppc64_elf_tdata (ibfd)->got;
10027 ent->got.offset = s->size;
10030 if (bfd_link_pic (info))
10032 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10033 srel->size += sizeof (Elf64_External_Rela);
10038 ent->got.offset = (bfd_vma) -1;
10041 /* We now have determined the sizes of the various dynamic sections.
10042 Allocate memory for them. */
10044 for (s = dynobj->sections; s != NULL; s = s->next)
10046 if ((s->flags & SEC_LINKER_CREATED) == 0)
10049 if (s == htab->brlt || s == htab->relbrlt)
10050 /* These haven't been allocated yet; don't strip. */
10052 else if (s == htab->elf.sgot
10053 || s == htab->elf.splt
10054 || s == htab->elf.iplt
10055 || s == htab->glink
10056 || s == htab->dynbss)
10058 /* Strip this section if we don't need it; see the
10061 else if (s == htab->glink_eh_frame)
10063 if (!bfd_is_abs_section (s->output_section))
10064 /* Not sized yet. */
10067 else if (CONST_STRNEQ (s->name, ".rela"))
10071 if (s != htab->elf.srelplt)
10074 /* We use the reloc_count field as a counter if we need
10075 to copy relocs into the output file. */
10076 s->reloc_count = 0;
10081 /* It's not one of our sections, so don't allocate space. */
10087 /* If we don't need this section, strip it from the
10088 output file. This is mostly to handle .rela.bss and
10089 .rela.plt. We must create both sections in
10090 create_dynamic_sections, because they must be created
10091 before the linker maps input sections to output
10092 sections. The linker does that before
10093 adjust_dynamic_symbol is called, and it is that
10094 function which decides whether anything needs to go
10095 into these sections. */
10096 s->flags |= SEC_EXCLUDE;
10100 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10103 /* Allocate memory for the section contents. We use bfd_zalloc
10104 here in case unused entries are not reclaimed before the
10105 section's contents are written out. This should not happen,
10106 but this way if it does we get a R_PPC64_NONE reloc in .rela
10107 sections instead of garbage.
10108 We also rely on the section contents being zero when writing
10110 s->contents = bfd_zalloc (dynobj, s->size);
10111 if (s->contents == NULL)
10115 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10117 if (!is_ppc64_elf (ibfd))
10120 s = ppc64_elf_tdata (ibfd)->got;
10121 if (s != NULL && s != htab->elf.sgot)
10124 s->flags |= SEC_EXCLUDE;
10127 s->contents = bfd_zalloc (ibfd, s->size);
10128 if (s->contents == NULL)
10132 s = ppc64_elf_tdata (ibfd)->relgot;
10136 s->flags |= SEC_EXCLUDE;
10139 s->contents = bfd_zalloc (ibfd, s->size);
10140 if (s->contents == NULL)
10143 s->reloc_count = 0;
10148 if (htab->elf.dynamic_sections_created)
10150 bfd_boolean tls_opt;
10152 /* Add some entries to the .dynamic section. We fill in the
10153 values later, in ppc64_elf_finish_dynamic_sections, but we
10154 must add the entries now so that we get the correct size for
10155 the .dynamic section. The DT_DEBUG entry is filled in by the
10156 dynamic linker and used by the debugger. */
10157 #define add_dynamic_entry(TAG, VAL) \
10158 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10160 if (bfd_link_executable (info))
10162 if (!add_dynamic_entry (DT_DEBUG, 0))
10166 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10168 if (!add_dynamic_entry (DT_PLTGOT, 0)
10169 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10170 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10171 || !add_dynamic_entry (DT_JMPREL, 0)
10172 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10176 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10178 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10179 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10183 tls_opt = (htab->params->tls_get_addr_opt
10184 && htab->tls_get_addr_fd != NULL
10185 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10186 if (tls_opt || !htab->opd_abi)
10188 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10194 if (!add_dynamic_entry (DT_RELA, 0)
10195 || !add_dynamic_entry (DT_RELASZ, 0)
10196 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10199 /* If any dynamic relocs apply to a read-only section,
10200 then we need a DT_TEXTREL entry. */
10201 if ((info->flags & DF_TEXTREL) == 0)
10202 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10204 if ((info->flags & DF_TEXTREL) != 0)
10206 if (!add_dynamic_entry (DT_TEXTREL, 0))
10211 #undef add_dynamic_entry
10216 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10219 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10221 if (h->plt.plist != NULL
10223 && !h->pointer_equality_needed)
10226 return _bfd_elf_hash_symbol (h);
10229 /* Determine the type of stub needed, if any, for a call. */
10231 static inline enum ppc_stub_type
10232 ppc_type_of_stub (asection *input_sec,
10233 const Elf_Internal_Rela *rel,
10234 struct ppc_link_hash_entry **hash,
10235 struct plt_entry **plt_ent,
10236 bfd_vma destination,
10237 unsigned long local_off)
10239 struct ppc_link_hash_entry *h = *hash;
10241 bfd_vma branch_offset;
10242 bfd_vma max_branch_offset;
10243 enum elf_ppc64_reloc_type r_type;
10247 struct plt_entry *ent;
10248 struct ppc_link_hash_entry *fdh = h;
10250 && h->oh->is_func_descriptor)
10252 fdh = ppc_follow_link (h->oh);
10256 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10257 if (ent->addend == rel->r_addend
10258 && ent->plt.offset != (bfd_vma) -1)
10261 return ppc_stub_plt_call;
10264 /* Here, we know we don't have a plt entry. If we don't have a
10265 either a defined function descriptor or a defined entry symbol
10266 in a regular object file, then it is pointless trying to make
10267 any other type of stub. */
10268 if (!is_static_defined (&fdh->elf)
10269 && !is_static_defined (&h->elf))
10270 return ppc_stub_none;
10272 else if (elf_local_got_ents (input_sec->owner) != NULL)
10274 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10275 struct plt_entry **local_plt = (struct plt_entry **)
10276 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10277 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10279 if (local_plt[r_symndx] != NULL)
10281 struct plt_entry *ent;
10283 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10284 if (ent->addend == rel->r_addend
10285 && ent->plt.offset != (bfd_vma) -1)
10288 return ppc_stub_plt_call;
10293 /* Determine where the call point is. */
10294 location = (input_sec->output_offset
10295 + input_sec->output_section->vma
10298 branch_offset = destination - location;
10299 r_type = ELF64_R_TYPE (rel->r_info);
10301 /* Determine if a long branch stub is needed. */
10302 max_branch_offset = 1 << 25;
10303 if (r_type != R_PPC64_REL24)
10304 max_branch_offset = 1 << 15;
10306 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10307 /* We need a stub. Figure out whether a long_branch or plt_branch
10308 is needed later. */
10309 return ppc_stub_long_branch;
10311 return ppc_stub_none;
10314 /* With power7 weakly ordered memory model, it is possible for ld.so
10315 to update a plt entry in one thread and have another thread see a
10316 stale zero toc entry. To avoid this we need some sort of acquire
10317 barrier in the call stub. One solution is to make the load of the
10318 toc word seem to appear to depend on the load of the function entry
10319 word. Another solution is to test for r2 being zero, and branch to
10320 the appropriate glink entry if so.
10322 . fake dep barrier compare
10323 . ld 12,xxx(2) ld 12,xxx(2)
10324 . mtctr 12 mtctr 12
10325 . xor 11,12,12 ld 2,xxx+8(2)
10326 . add 2,2,11 cmpldi 2,0
10327 . ld 2,xxx+8(2) bnectr+
10328 . bctr b <glink_entry>
10330 The solution involving the compare turns out to be faster, so
10331 that's what we use unless the branch won't reach. */
10333 #define ALWAYS_USE_FAKE_DEP 0
10334 #define ALWAYS_EMIT_R2SAVE 0
10336 #define PPC_LO(v) ((v) & 0xffff)
10337 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10338 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10340 static inline unsigned int
10341 plt_stub_size (struct ppc_link_hash_table *htab,
10342 struct ppc_stub_hash_entry *stub_entry,
10345 unsigned size = 12;
10347 if (ALWAYS_EMIT_R2SAVE
10348 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10350 if (PPC_HA (off) != 0)
10355 if (htab->params->plt_static_chain)
10357 if (htab->params->plt_thread_safe
10358 && htab->elf.dynamic_sections_created
10359 && stub_entry->h != NULL
10360 && stub_entry->h->elf.dynindx != -1)
10362 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10365 if (stub_entry->h != NULL
10366 && (stub_entry->h == htab->tls_get_addr_fd
10367 || stub_entry->h == htab->tls_get_addr)
10368 && htab->params->tls_get_addr_opt)
10373 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10374 then return the padding needed to do so. */
10375 static inline unsigned int
10376 plt_stub_pad (struct ppc_link_hash_table *htab,
10377 struct ppc_stub_hash_entry *stub_entry,
10380 int stub_align = 1 << htab->params->plt_stub_align;
10381 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10382 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10384 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10385 > ((stub_size - 1) & -stub_align))
10386 return stub_align - (stub_off & (stub_align - 1));
10390 /* Build a .plt call stub. */
10392 static inline bfd_byte *
10393 build_plt_stub (struct ppc_link_hash_table *htab,
10394 struct ppc_stub_hash_entry *stub_entry,
10395 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10397 bfd *obfd = htab->params->stub_bfd;
10398 bfd_boolean plt_load_toc = htab->opd_abi;
10399 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10400 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10401 && htab->elf.dynamic_sections_created
10402 && stub_entry->h != NULL
10403 && stub_entry->h->elf.dynindx != -1);
10404 bfd_boolean use_fake_dep = plt_thread_safe;
10405 bfd_vma cmp_branch_off = 0;
10407 if (!ALWAYS_USE_FAKE_DEP
10410 && !((stub_entry->h == htab->tls_get_addr_fd
10411 || stub_entry->h == htab->tls_get_addr)
10412 && htab->params->tls_get_addr_opt))
10414 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10415 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10416 / PLT_ENTRY_SIZE (htab));
10417 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10420 if (pltindex > 32768)
10421 glinkoff += (pltindex - 32768) * 4;
10423 + htab->glink->output_offset
10424 + htab->glink->output_section->vma);
10425 from = (p - stub_entry->group->stub_sec->contents
10426 + 4 * (ALWAYS_EMIT_R2SAVE
10427 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10428 + 4 * (PPC_HA (offset) != 0)
10429 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10430 != PPC_HA (offset))
10431 + 4 * (plt_static_chain != 0)
10433 + stub_entry->group->stub_sec->output_offset
10434 + stub_entry->group->stub_sec->output_section->vma);
10435 cmp_branch_off = to - from;
10436 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10439 if (PPC_HA (offset) != 0)
10443 if (ALWAYS_EMIT_R2SAVE
10444 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10445 r[0].r_offset += 4;
10446 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10447 r[1].r_offset = r[0].r_offset + 4;
10448 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10449 r[1].r_addend = r[0].r_addend;
10452 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10454 r[2].r_offset = r[1].r_offset + 4;
10455 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10456 r[2].r_addend = r[0].r_addend;
10460 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10461 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10462 r[2].r_addend = r[0].r_addend + 8;
10463 if (plt_static_chain)
10465 r[3].r_offset = r[2].r_offset + 4;
10466 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10467 r[3].r_addend = r[0].r_addend + 16;
10472 if (ALWAYS_EMIT_R2SAVE
10473 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10474 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10477 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10478 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10482 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10483 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10486 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10488 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10491 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10496 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10497 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10499 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10500 if (plt_static_chain)
10501 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10508 if (ALWAYS_EMIT_R2SAVE
10509 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10510 r[0].r_offset += 4;
10511 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10514 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10516 r[1].r_offset = r[0].r_offset + 4;
10517 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10518 r[1].r_addend = r[0].r_addend;
10522 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10523 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10524 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10525 if (plt_static_chain)
10527 r[2].r_offset = r[1].r_offset + 4;
10528 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10529 r[2].r_addend = r[0].r_addend + 8;
10534 if (ALWAYS_EMIT_R2SAVE
10535 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10536 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10537 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10539 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10541 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10544 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10549 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10550 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10552 if (plt_static_chain)
10553 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10554 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10557 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10559 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10560 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10561 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10564 bfd_put_32 (obfd, BCTR, p), p += 4;
10568 /* Build a special .plt call stub for __tls_get_addr. */
10570 #define LD_R11_0R3 0xe9630000
10571 #define LD_R12_0R3 0xe9830000
10572 #define MR_R0_R3 0x7c601b78
10573 #define CMPDI_R11_0 0x2c2b0000
10574 #define ADD_R3_R12_R13 0x7c6c6a14
10575 #define BEQLR 0x4d820020
10576 #define MR_R3_R0 0x7c030378
10577 #define STD_R11_0R1 0xf9610000
10578 #define BCTRL 0x4e800421
10579 #define LD_R11_0R1 0xe9610000
10580 #define MTLR_R11 0x7d6803a6
10582 static inline bfd_byte *
10583 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10584 struct ppc_stub_hash_entry *stub_entry,
10585 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10587 bfd *obfd = htab->params->stub_bfd;
10589 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10590 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10591 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10592 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10593 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10594 bfd_put_32 (obfd, BEQLR, p), p += 4;
10595 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10596 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10597 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10600 r[0].r_offset += 9 * 4;
10601 p = build_plt_stub (htab, stub_entry, p, offset, r);
10602 bfd_put_32 (obfd, BCTRL, p - 4);
10604 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10605 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10606 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10607 bfd_put_32 (obfd, BLR, p), p += 4;
10612 static Elf_Internal_Rela *
10613 get_relocs (asection *sec, int count)
10615 Elf_Internal_Rela *relocs;
10616 struct bfd_elf_section_data *elfsec_data;
10618 elfsec_data = elf_section_data (sec);
10619 relocs = elfsec_data->relocs;
10620 if (relocs == NULL)
10622 bfd_size_type relsize;
10623 relsize = sec->reloc_count * sizeof (*relocs);
10624 relocs = bfd_alloc (sec->owner, relsize);
10625 if (relocs == NULL)
10627 elfsec_data->relocs = relocs;
10628 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10629 sizeof (Elf_Internal_Shdr));
10630 if (elfsec_data->rela.hdr == NULL)
10632 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10633 * sizeof (Elf64_External_Rela));
10634 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10635 sec->reloc_count = 0;
10637 relocs += sec->reloc_count;
10638 sec->reloc_count += count;
10643 get_r2off (struct bfd_link_info *info,
10644 struct ppc_stub_hash_entry *stub_entry)
10646 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10647 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10651 /* Support linking -R objects. Get the toc pointer from the
10654 if (!htab->opd_abi)
10656 asection *opd = stub_entry->h->elf.root.u.def.section;
10657 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10659 if (strcmp (opd->name, ".opd") != 0
10660 || opd->reloc_count != 0)
10662 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10663 stub_entry->h->elf.root.root.string);
10664 bfd_set_error (bfd_error_bad_value);
10665 return (bfd_vma) -1;
10667 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10668 return (bfd_vma) -1;
10669 r2off = bfd_get_64 (opd->owner, buf);
10670 r2off -= elf_gp (info->output_bfd);
10672 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10677 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10679 struct ppc_stub_hash_entry *stub_entry;
10680 struct ppc_branch_hash_entry *br_entry;
10681 struct bfd_link_info *info;
10682 struct ppc_link_hash_table *htab;
10687 Elf_Internal_Rela *r;
10690 /* Massage our args to the form they really have. */
10691 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10694 htab = ppc_hash_table (info);
10698 /* Make a note of the offset within the stubs for this entry. */
10699 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10700 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10702 htab->stub_count[stub_entry->stub_type - 1] += 1;
10703 switch (stub_entry->stub_type)
10705 case ppc_stub_long_branch:
10706 case ppc_stub_long_branch_r2off:
10707 /* Branches are relative. This is where we are going to. */
10708 dest = (stub_entry->target_value
10709 + stub_entry->target_section->output_offset
10710 + stub_entry->target_section->output_section->vma);
10711 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10714 /* And this is where we are coming from. */
10715 off -= (stub_entry->stub_offset
10716 + stub_entry->group->stub_sec->output_offset
10717 + stub_entry->group->stub_sec->output_section->vma);
10720 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10722 bfd_vma r2off = get_r2off (info, stub_entry);
10724 if (r2off == (bfd_vma) -1)
10726 htab->stub_error = TRUE;
10729 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10732 if (PPC_HA (r2off) != 0)
10734 bfd_put_32 (htab->params->stub_bfd,
10735 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10739 if (PPC_LO (r2off) != 0)
10741 bfd_put_32 (htab->params->stub_bfd,
10742 ADDI_R2_R2 | PPC_LO (r2off), loc);
10748 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10750 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10752 info->callbacks->einfo
10753 (_("%P: long branch stub `%s' offset overflow\n"),
10754 stub_entry->root.string);
10755 htab->stub_error = TRUE;
10759 if (info->emitrelocations)
10761 r = get_relocs (stub_entry->group->stub_sec, 1);
10764 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10765 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10766 r->r_addend = dest;
10767 if (stub_entry->h != NULL)
10769 struct elf_link_hash_entry **hashes;
10770 unsigned long symndx;
10771 struct ppc_link_hash_entry *h;
10773 hashes = elf_sym_hashes (htab->params->stub_bfd);
10774 if (hashes == NULL)
10776 bfd_size_type hsize;
10778 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10779 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10780 if (hashes == NULL)
10782 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10783 htab->stub_globals = 1;
10785 symndx = htab->stub_globals++;
10787 hashes[symndx] = &h->elf;
10788 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10789 if (h->oh != NULL && h->oh->is_func)
10790 h = ppc_follow_link (h->oh);
10791 if (h->elf.root.u.def.section != stub_entry->target_section)
10792 /* H is an opd symbol. The addend must be zero. */
10796 off = (h->elf.root.u.def.value
10797 + h->elf.root.u.def.section->output_offset
10798 + h->elf.root.u.def.section->output_section->vma);
10799 r->r_addend -= off;
10805 case ppc_stub_plt_branch:
10806 case ppc_stub_plt_branch_r2off:
10807 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10808 stub_entry->root.string + 9,
10810 if (br_entry == NULL)
10812 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10813 stub_entry->root.string);
10814 htab->stub_error = TRUE;
10818 dest = (stub_entry->target_value
10819 + stub_entry->target_section->output_offset
10820 + stub_entry->target_section->output_section->vma);
10821 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10822 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10824 bfd_put_64 (htab->brlt->owner, dest,
10825 htab->brlt->contents + br_entry->offset);
10827 if (br_entry->iter == htab->stub_iteration)
10829 br_entry->iter = 0;
10831 if (htab->relbrlt != NULL)
10833 /* Create a reloc for the branch lookup table entry. */
10834 Elf_Internal_Rela rela;
10837 rela.r_offset = (br_entry->offset
10838 + htab->brlt->output_offset
10839 + htab->brlt->output_section->vma);
10840 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10841 rela.r_addend = dest;
10843 rl = htab->relbrlt->contents;
10844 rl += (htab->relbrlt->reloc_count++
10845 * sizeof (Elf64_External_Rela));
10846 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10848 else if (info->emitrelocations)
10850 r = get_relocs (htab->brlt, 1);
10853 /* brlt, being SEC_LINKER_CREATED does not go through the
10854 normal reloc processing. Symbols and offsets are not
10855 translated from input file to output file form, so
10856 set up the offset per the output file. */
10857 r->r_offset = (br_entry->offset
10858 + htab->brlt->output_offset
10859 + htab->brlt->output_section->vma);
10860 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10861 r->r_addend = dest;
10865 dest = (br_entry->offset
10866 + htab->brlt->output_offset
10867 + htab->brlt->output_section->vma);
10870 - elf_gp (htab->brlt->output_section->owner)
10871 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10873 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10875 info->callbacks->einfo
10876 (_("%P: linkage table error against `%T'\n"),
10877 stub_entry->root.string);
10878 bfd_set_error (bfd_error_bad_value);
10879 htab->stub_error = TRUE;
10883 if (info->emitrelocations)
10885 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10888 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10889 if (bfd_big_endian (info->output_bfd))
10890 r[0].r_offset += 2;
10891 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10892 r[0].r_offset += 4;
10893 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10894 r[0].r_addend = dest;
10895 if (PPC_HA (off) != 0)
10897 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10898 r[1].r_offset = r[0].r_offset + 4;
10899 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10900 r[1].r_addend = r[0].r_addend;
10904 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10906 if (PPC_HA (off) != 0)
10909 bfd_put_32 (htab->params->stub_bfd,
10910 ADDIS_R12_R2 | PPC_HA (off), loc);
10912 bfd_put_32 (htab->params->stub_bfd,
10913 LD_R12_0R12 | PPC_LO (off), loc);
10918 bfd_put_32 (htab->params->stub_bfd,
10919 LD_R12_0R2 | PPC_LO (off), loc);
10924 bfd_vma r2off = get_r2off (info, stub_entry);
10926 if (r2off == (bfd_vma) -1)
10928 htab->stub_error = TRUE;
10932 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10935 if (PPC_HA (off) != 0)
10938 bfd_put_32 (htab->params->stub_bfd,
10939 ADDIS_R12_R2 | PPC_HA (off), loc);
10941 bfd_put_32 (htab->params->stub_bfd,
10942 LD_R12_0R12 | PPC_LO (off), loc);
10945 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10947 if (PPC_HA (r2off) != 0)
10951 bfd_put_32 (htab->params->stub_bfd,
10952 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10954 if (PPC_LO (r2off) != 0)
10958 bfd_put_32 (htab->params->stub_bfd,
10959 ADDI_R2_R2 | PPC_LO (r2off), loc);
10963 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10965 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10968 case ppc_stub_plt_call:
10969 case ppc_stub_plt_call_r2save:
10970 if (stub_entry->h != NULL
10971 && stub_entry->h->is_func_descriptor
10972 && stub_entry->h->oh != NULL)
10974 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10976 /* If the old-ABI "dot-symbol" is undefined make it weak so
10977 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
10978 if (fh->elf.root.type == bfd_link_hash_undefined)
10979 fh->elf.root.type = bfd_link_hash_undefweak;
10980 /* Stop undo_symbol_twiddle changing it back to undefined. */
10981 fh->was_undefined = 0;
10984 /* Now build the stub. */
10985 dest = stub_entry->plt_ent->plt.offset & ~1;
10986 if (dest >= (bfd_vma) -2)
10989 plt = htab->elf.splt;
10990 if (!htab->elf.dynamic_sections_created
10991 || stub_entry->h == NULL
10992 || stub_entry->h->elf.dynindx == -1)
10993 plt = htab->elf.iplt;
10995 dest += plt->output_offset + plt->output_section->vma;
10997 if (stub_entry->h == NULL
10998 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11000 Elf_Internal_Rela rela;
11003 rela.r_offset = dest;
11005 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11007 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11008 rela.r_addend = (stub_entry->target_value
11009 + stub_entry->target_section->output_offset
11010 + stub_entry->target_section->output_section->vma);
11012 rl = (htab->elf.irelplt->contents
11013 + (htab->elf.irelplt->reloc_count++
11014 * sizeof (Elf64_External_Rela)));
11015 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11016 stub_entry->plt_ent->plt.offset |= 1;
11020 - elf_gp (plt->output_section->owner)
11021 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11023 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11025 info->callbacks->einfo
11026 (_("%P: linkage table error against `%T'\n"),
11027 stub_entry->h != NULL
11028 ? stub_entry->h->elf.root.root.string
11030 bfd_set_error (bfd_error_bad_value);
11031 htab->stub_error = TRUE;
11035 if (htab->params->plt_stub_align != 0)
11037 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11039 stub_entry->group->stub_sec->size += pad;
11040 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11045 if (info->emitrelocations)
11047 r = get_relocs (stub_entry->group->stub_sec,
11048 ((PPC_HA (off) != 0)
11050 ? 2 + (htab->params->plt_static_chain
11051 && PPC_HA (off + 16) == PPC_HA (off))
11055 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11056 if (bfd_big_endian (info->output_bfd))
11057 r[0].r_offset += 2;
11058 r[0].r_addend = dest;
11060 if (stub_entry->h != NULL
11061 && (stub_entry->h == htab->tls_get_addr_fd
11062 || stub_entry->h == htab->tls_get_addr)
11063 && htab->params->tls_get_addr_opt)
11064 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11066 p = build_plt_stub (htab, stub_entry, loc, off, r);
11070 case ppc_stub_save_res:
11078 stub_entry->group->stub_sec->size += size;
11080 if (htab->params->emit_stub_syms)
11082 struct elf_link_hash_entry *h;
11085 const char *const stub_str[] = { "long_branch",
11086 "long_branch_r2off",
11088 "plt_branch_r2off",
11092 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11093 len2 = strlen (stub_entry->root.string);
11094 name = bfd_malloc (len1 + len2 + 2);
11097 memcpy (name, stub_entry->root.string, 9);
11098 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11099 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11100 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11103 if (h->root.type == bfd_link_hash_new)
11105 h->root.type = bfd_link_hash_defined;
11106 h->root.u.def.section = stub_entry->group->stub_sec;
11107 h->root.u.def.value = stub_entry->stub_offset;
11108 h->ref_regular = 1;
11109 h->def_regular = 1;
11110 h->ref_regular_nonweak = 1;
11111 h->forced_local = 1;
11113 h->root.linker_def = 1;
11120 /* As above, but don't actually build the stub. Just bump offset so
11121 we know stub section sizes, and select plt_branch stubs where
11122 long_branch stubs won't do. */
11125 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11127 struct ppc_stub_hash_entry *stub_entry;
11128 struct bfd_link_info *info;
11129 struct ppc_link_hash_table *htab;
11133 /* Massage our args to the form they really have. */
11134 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11137 htab = ppc_hash_table (info);
11141 if (stub_entry->h != NULL
11142 && stub_entry->h->save_res
11143 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11144 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11146 /* Don't make stubs to out-of-line register save/restore
11147 functions. Instead, emit copies of the functions. */
11148 stub_entry->group->needs_save_res = 1;
11149 stub_entry->stub_type = ppc_stub_save_res;
11153 if (stub_entry->stub_type == ppc_stub_plt_call
11154 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11157 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11158 if (off >= (bfd_vma) -2)
11160 plt = htab->elf.splt;
11161 if (!htab->elf.dynamic_sections_created
11162 || stub_entry->h == NULL
11163 || stub_entry->h->elf.dynindx == -1)
11164 plt = htab->elf.iplt;
11165 off += (plt->output_offset
11166 + plt->output_section->vma
11167 - elf_gp (plt->output_section->owner)
11168 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11170 size = plt_stub_size (htab, stub_entry, off);
11171 if (htab->params->plt_stub_align)
11172 size += plt_stub_pad (htab, stub_entry, off);
11173 if (info->emitrelocations)
11175 stub_entry->group->stub_sec->reloc_count
11176 += ((PPC_HA (off) != 0)
11178 ? 2 + (htab->params->plt_static_chain
11179 && PPC_HA (off + 16) == PPC_HA (off))
11181 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11186 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11189 bfd_vma local_off = 0;
11191 off = (stub_entry->target_value
11192 + stub_entry->target_section->output_offset
11193 + stub_entry->target_section->output_section->vma);
11194 off -= (stub_entry->group->stub_sec->size
11195 + stub_entry->group->stub_sec->output_offset
11196 + stub_entry->group->stub_sec->output_section->vma);
11198 /* Reset the stub type from the plt variant in case we now
11199 can reach with a shorter stub. */
11200 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11201 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11204 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11206 r2off = get_r2off (info, stub_entry);
11207 if (r2off == (bfd_vma) -1)
11209 htab->stub_error = TRUE;
11213 if (PPC_HA (r2off) != 0)
11215 if (PPC_LO (r2off) != 0)
11220 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11222 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11223 Do the same for -R objects without function descriptors. */
11224 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11225 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11227 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11229 struct ppc_branch_hash_entry *br_entry;
11231 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11232 stub_entry->root.string + 9,
11234 if (br_entry == NULL)
11236 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11237 stub_entry->root.string);
11238 htab->stub_error = TRUE;
11242 if (br_entry->iter != htab->stub_iteration)
11244 br_entry->iter = htab->stub_iteration;
11245 br_entry->offset = htab->brlt->size;
11246 htab->brlt->size += 8;
11248 if (htab->relbrlt != NULL)
11249 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11250 else if (info->emitrelocations)
11252 htab->brlt->reloc_count += 1;
11253 htab->brlt->flags |= SEC_RELOC;
11257 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11258 off = (br_entry->offset
11259 + htab->brlt->output_offset
11260 + htab->brlt->output_section->vma
11261 - elf_gp (htab->brlt->output_section->owner)
11262 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11264 if (info->emitrelocations)
11266 stub_entry->group->stub_sec->reloc_count
11267 += 1 + (PPC_HA (off) != 0);
11268 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11271 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11274 if (PPC_HA (off) != 0)
11280 if (PPC_HA (off) != 0)
11283 if (PPC_HA (r2off) != 0)
11285 if (PPC_LO (r2off) != 0)
11289 else if (info->emitrelocations)
11291 stub_entry->group->stub_sec->reloc_count += 1;
11292 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11296 stub_entry->group->stub_sec->size += size;
11300 /* Set up various things so that we can make a list of input sections
11301 for each output section included in the link. Returns -1 on error,
11302 0 when no stubs will be needed, and 1 on success. */
11305 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11309 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11314 htab->sec_info_arr_size = bfd_get_next_section_id ();
11315 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11316 htab->sec_info = bfd_zmalloc (amt);
11317 if (htab->sec_info == NULL)
11320 /* Set toc_off for com, und, abs and ind sections. */
11321 for (id = 0; id < 3; id++)
11322 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11327 /* Set up for first pass at multitoc partitioning. */
11330 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11332 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11334 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11335 htab->toc_bfd = NULL;
11336 htab->toc_first_sec = NULL;
11339 /* The linker repeatedly calls this function for each TOC input section
11340 and linker generated GOT section. Group input bfds such that the toc
11341 within a group is less than 64k in size. */
11344 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11346 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11347 bfd_vma addr, off, limit;
11352 if (!htab->second_toc_pass)
11354 /* Keep track of the first .toc or .got section for this input bfd. */
11355 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11359 htab->toc_bfd = isec->owner;
11360 htab->toc_first_sec = isec;
11363 addr = isec->output_offset + isec->output_section->vma;
11364 off = addr - htab->toc_curr;
11365 limit = 0x80008000;
11366 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11368 if (off + isec->size > limit)
11370 addr = (htab->toc_first_sec->output_offset
11371 + htab->toc_first_sec->output_section->vma);
11372 htab->toc_curr = addr;
11373 htab->toc_curr &= -TOC_BASE_ALIGN;
11376 /* toc_curr is the base address of this toc group. Set elf_gp
11377 for the input section to be the offset relative to the
11378 output toc base plus 0x8000. Making the input elf_gp an
11379 offset allows us to move the toc as a whole without
11380 recalculating input elf_gp. */
11381 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11382 off += TOC_BASE_OFF;
11384 /* Die if someone uses a linker script that doesn't keep input
11385 file .toc and .got together. */
11387 && elf_gp (isec->owner) != 0
11388 && elf_gp (isec->owner) != off)
11391 elf_gp (isec->owner) = off;
11395 /* During the second pass toc_first_sec points to the start of
11396 a toc group, and toc_curr is used to track the old elf_gp.
11397 We use toc_bfd to ensure we only look at each bfd once. */
11398 if (htab->toc_bfd == isec->owner)
11400 htab->toc_bfd = isec->owner;
11402 if (htab->toc_first_sec == NULL
11403 || htab->toc_curr != elf_gp (isec->owner))
11405 htab->toc_curr = elf_gp (isec->owner);
11406 htab->toc_first_sec = isec;
11408 addr = (htab->toc_first_sec->output_offset
11409 + htab->toc_first_sec->output_section->vma);
11410 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11411 elf_gp (isec->owner) = off;
11416 /* Called via elf_link_hash_traverse to merge GOT entries for global
11420 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11422 if (h->root.type == bfd_link_hash_indirect)
11425 merge_got_entries (&h->got.glist);
11430 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11434 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11436 struct got_entry *gent;
11438 if (h->root.type == bfd_link_hash_indirect)
11441 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11442 if (!gent->is_indirect)
11443 allocate_got (h, (struct bfd_link_info *) inf, gent);
11447 /* Called on the first multitoc pass after the last call to
11448 ppc64_elf_next_toc_section. This function removes duplicate GOT
11452 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11454 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11455 struct bfd *ibfd, *ibfd2;
11456 bfd_boolean done_something;
11458 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11460 if (!htab->do_multi_toc)
11463 /* Merge global sym got entries within a toc group. */
11464 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11466 /* And tlsld_got. */
11467 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11469 struct got_entry *ent, *ent2;
11471 if (!is_ppc64_elf (ibfd))
11474 ent = ppc64_tlsld_got (ibfd);
11475 if (!ent->is_indirect
11476 && ent->got.offset != (bfd_vma) -1)
11478 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11480 if (!is_ppc64_elf (ibfd2))
11483 ent2 = ppc64_tlsld_got (ibfd2);
11484 if (!ent2->is_indirect
11485 && ent2->got.offset != (bfd_vma) -1
11486 && elf_gp (ibfd2) == elf_gp (ibfd))
11488 ent2->is_indirect = TRUE;
11489 ent2->got.ent = ent;
11495 /* Zap sizes of got sections. */
11496 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11497 htab->elf.irelplt->size -= htab->got_reli_size;
11498 htab->got_reli_size = 0;
11500 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11502 asection *got, *relgot;
11504 if (!is_ppc64_elf (ibfd))
11507 got = ppc64_elf_tdata (ibfd)->got;
11510 got->rawsize = got->size;
11512 relgot = ppc64_elf_tdata (ibfd)->relgot;
11513 relgot->rawsize = relgot->size;
11518 /* Now reallocate the got, local syms first. We don't need to
11519 allocate section contents again since we never increase size. */
11520 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11522 struct got_entry **lgot_ents;
11523 struct got_entry **end_lgot_ents;
11524 struct plt_entry **local_plt;
11525 struct plt_entry **end_local_plt;
11526 unsigned char *lgot_masks;
11527 bfd_size_type locsymcount;
11528 Elf_Internal_Shdr *symtab_hdr;
11531 if (!is_ppc64_elf (ibfd))
11534 lgot_ents = elf_local_got_ents (ibfd);
11538 symtab_hdr = &elf_symtab_hdr (ibfd);
11539 locsymcount = symtab_hdr->sh_info;
11540 end_lgot_ents = lgot_ents + locsymcount;
11541 local_plt = (struct plt_entry **) end_lgot_ents;
11542 end_local_plt = local_plt + locsymcount;
11543 lgot_masks = (unsigned char *) end_local_plt;
11544 s = ppc64_elf_tdata (ibfd)->got;
11545 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11547 struct got_entry *ent;
11549 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11551 unsigned int ent_size = 8;
11552 unsigned int rel_size = sizeof (Elf64_External_Rela);
11554 ent->got.offset = s->size;
11555 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11560 s->size += ent_size;
11561 if ((*lgot_masks & PLT_IFUNC) != 0)
11563 htab->elf.irelplt->size += rel_size;
11564 htab->got_reli_size += rel_size;
11566 else if (bfd_link_pic (info))
11568 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11569 srel->size += rel_size;
11575 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11577 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11579 struct got_entry *ent;
11581 if (!is_ppc64_elf (ibfd))
11584 ent = ppc64_tlsld_got (ibfd);
11585 if (!ent->is_indirect
11586 && ent->got.offset != (bfd_vma) -1)
11588 asection *s = ppc64_elf_tdata (ibfd)->got;
11589 ent->got.offset = s->size;
11591 if (bfd_link_pic (info))
11593 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11594 srel->size += sizeof (Elf64_External_Rela);
11599 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11600 if (!done_something)
11601 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11605 if (!is_ppc64_elf (ibfd))
11608 got = ppc64_elf_tdata (ibfd)->got;
11611 done_something = got->rawsize != got->size;
11612 if (done_something)
11617 if (done_something)
11618 (*htab->params->layout_sections_again) ();
11620 /* Set up for second pass over toc sections to recalculate elf_gp
11621 on input sections. */
11622 htab->toc_bfd = NULL;
11623 htab->toc_first_sec = NULL;
11624 htab->second_toc_pass = TRUE;
11625 return done_something;
11628 /* Called after second pass of multitoc partitioning. */
11631 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11633 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11635 /* After the second pass, toc_curr tracks the TOC offset used
11636 for code sections below in ppc64_elf_next_input_section. */
11637 htab->toc_curr = TOC_BASE_OFF;
11640 /* No toc references were found in ISEC. If the code in ISEC makes no
11641 calls, then there's no need to use toc adjusting stubs when branching
11642 into ISEC. Actually, indirect calls from ISEC are OK as they will
11643 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11644 needed, and 2 if a cyclical call-graph was found but no other reason
11645 for a stub was detected. If called from the top level, a return of
11646 2 means the same as a return of 0. */
11649 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11653 /* Mark this section as checked. */
11654 isec->call_check_done = 1;
11656 /* We know none of our code bearing sections will need toc stubs. */
11657 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11660 if (isec->size == 0)
11663 if (isec->output_section == NULL)
11667 if (isec->reloc_count != 0)
11669 Elf_Internal_Rela *relstart, *rel;
11670 Elf_Internal_Sym *local_syms;
11671 struct ppc_link_hash_table *htab;
11673 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11674 info->keep_memory);
11675 if (relstart == NULL)
11678 /* Look for branches to outside of this section. */
11680 htab = ppc_hash_table (info);
11684 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11686 enum elf_ppc64_reloc_type r_type;
11687 unsigned long r_symndx;
11688 struct elf_link_hash_entry *h;
11689 struct ppc_link_hash_entry *eh;
11690 Elf_Internal_Sym *sym;
11692 struct _opd_sec_data *opd;
11696 r_type = ELF64_R_TYPE (rel->r_info);
11697 if (r_type != R_PPC64_REL24
11698 && r_type != R_PPC64_REL14
11699 && r_type != R_PPC64_REL14_BRTAKEN
11700 && r_type != R_PPC64_REL14_BRNTAKEN)
11703 r_symndx = ELF64_R_SYM (rel->r_info);
11704 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11711 /* Calls to dynamic lib functions go through a plt call stub
11713 eh = (struct ppc_link_hash_entry *) h;
11715 && (eh->elf.plt.plist != NULL
11717 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11723 if (sym_sec == NULL)
11724 /* Ignore other undefined symbols. */
11727 /* Assume branches to other sections not included in the
11728 link need stubs too, to cover -R and absolute syms. */
11729 if (sym_sec->output_section == NULL)
11736 sym_value = sym->st_value;
11739 if (h->root.type != bfd_link_hash_defined
11740 && h->root.type != bfd_link_hash_defweak)
11742 sym_value = h->root.u.def.value;
11744 sym_value += rel->r_addend;
11746 /* If this branch reloc uses an opd sym, find the code section. */
11747 opd = get_opd_info (sym_sec);
11750 if (h == NULL && opd->adjust != NULL)
11754 adjust = opd->adjust[OPD_NDX (sym_value)];
11756 /* Assume deleted functions won't ever be called. */
11758 sym_value += adjust;
11761 dest = opd_entry_value (sym_sec, sym_value,
11762 &sym_sec, NULL, FALSE);
11763 if (dest == (bfd_vma) -1)
11768 + sym_sec->output_offset
11769 + sym_sec->output_section->vma);
11771 /* Ignore branch to self. */
11772 if (sym_sec == isec)
11775 /* If the called function uses the toc, we need a stub. */
11776 if (sym_sec->has_toc_reloc
11777 || sym_sec->makes_toc_func_call)
11783 /* Assume any branch that needs a long branch stub might in fact
11784 need a plt_branch stub. A plt_branch stub uses r2. */
11785 else if (dest - (isec->output_offset
11786 + isec->output_section->vma
11787 + rel->r_offset) + (1 << 25)
11788 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11796 /* If calling back to a section in the process of being
11797 tested, we can't say for sure that no toc adjusting stubs
11798 are needed, so don't return zero. */
11799 else if (sym_sec->call_check_in_progress)
11802 /* Branches to another section that itself doesn't have any TOC
11803 references are OK. Recursively call ourselves to check. */
11804 else if (!sym_sec->call_check_done)
11808 /* Mark current section as indeterminate, so that other
11809 sections that call back to current won't be marked as
11811 isec->call_check_in_progress = 1;
11812 recur = toc_adjusting_stub_needed (info, sym_sec);
11813 isec->call_check_in_progress = 0;
11824 if (local_syms != NULL
11825 && (elf_symtab_hdr (isec->owner).contents
11826 != (unsigned char *) local_syms))
11828 if (elf_section_data (isec)->relocs != relstart)
11833 && isec->map_head.s != NULL
11834 && (strcmp (isec->output_section->name, ".init") == 0
11835 || strcmp (isec->output_section->name, ".fini") == 0))
11837 if (isec->map_head.s->has_toc_reloc
11838 || isec->map_head.s->makes_toc_func_call)
11840 else if (!isec->map_head.s->call_check_done)
11843 isec->call_check_in_progress = 1;
11844 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11845 isec->call_check_in_progress = 0;
11852 isec->makes_toc_func_call = 1;
11857 /* The linker repeatedly calls this function for each input section,
11858 in the order that input sections are linked into output sections.
11859 Build lists of input sections to determine groupings between which
11860 we may insert linker stubs. */
11863 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11865 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11870 if ((isec->output_section->flags & SEC_CODE) != 0
11871 && isec->output_section->id < htab->sec_info_arr_size)
11873 /* This happens to make the list in reverse order,
11874 which is what we want. */
11875 htab->sec_info[isec->id].u.list
11876 = htab->sec_info[isec->output_section->id].u.list;
11877 htab->sec_info[isec->output_section->id].u.list = isec;
11880 if (htab->multi_toc_needed)
11882 /* Analyse sections that aren't already flagged as needing a
11883 valid toc pointer. Exclude .fixup for the linux kernel.
11884 .fixup contains branches, but only back to the function that
11885 hit an exception. */
11886 if (!(isec->has_toc_reloc
11887 || (isec->flags & SEC_CODE) == 0
11888 || strcmp (isec->name, ".fixup") == 0
11889 || isec->call_check_done))
11891 if (toc_adjusting_stub_needed (info, isec) < 0)
11894 /* Make all sections use the TOC assigned for this object file.
11895 This will be wrong for pasted sections; We fix that in
11896 check_pasted_section(). */
11897 if (elf_gp (isec->owner) != 0)
11898 htab->toc_curr = elf_gp (isec->owner);
11901 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11905 /* Check that all .init and .fini sections use the same toc, if they
11906 have toc relocs. */
11909 check_pasted_section (struct bfd_link_info *info, const char *name)
11911 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11915 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11916 bfd_vma toc_off = 0;
11919 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11920 if (i->has_toc_reloc)
11923 toc_off = htab->sec_info[i->id].toc_off;
11924 else if (toc_off != htab->sec_info[i->id].toc_off)
11929 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11930 if (i->makes_toc_func_call)
11932 toc_off = htab->sec_info[i->id].toc_off;
11936 /* Make sure the whole pasted function uses the same toc offset. */
11938 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11939 htab->sec_info[i->id].toc_off = toc_off;
11945 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11947 return (check_pasted_section (info, ".init")
11948 & check_pasted_section (info, ".fini"));
11951 /* See whether we can group stub sections together. Grouping stub
11952 sections may result in fewer stubs. More importantly, we need to
11953 put all .init* and .fini* stubs at the beginning of the .init or
11954 .fini output sections respectively, because glibc splits the
11955 _init and _fini functions into multiple parts. Putting a stub in
11956 the middle of a function is not a good idea. */
11959 group_sections (struct bfd_link_info *info,
11960 bfd_size_type stub_group_size,
11961 bfd_boolean stubs_always_before_branch)
11963 struct ppc_link_hash_table *htab;
11965 bfd_size_type stub14_group_size;
11966 bfd_boolean suppress_size_errors;
11968 htab = ppc_hash_table (info);
11972 suppress_size_errors = FALSE;
11973 stub14_group_size = stub_group_size >> 10;
11974 if (stub_group_size == 1)
11976 /* Default values. */
11977 if (stubs_always_before_branch)
11979 stub_group_size = 0x1e00000;
11980 stub14_group_size = 0x7800;
11984 stub_group_size = 0x1c00000;
11985 stub14_group_size = 0x7000;
11987 suppress_size_errors = TRUE;
11990 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11994 if (osec->id >= htab->sec_info_arr_size)
11997 tail = htab->sec_info[osec->id].u.list;
11998 while (tail != NULL)
12002 bfd_size_type total;
12003 bfd_boolean big_sec;
12005 struct map_stub *group;
12008 total = tail->size;
12009 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12010 && ppc64_elf_section_data (tail)->has_14bit_branch
12011 ? stub14_group_size : stub_group_size);
12012 if (big_sec && !suppress_size_errors)
12013 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12014 tail->owner, tail);
12015 curr_toc = htab->sec_info[tail->id].toc_off;
12017 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12018 && ((total += curr->output_offset - prev->output_offset)
12019 < (ppc64_elf_section_data (prev) != NULL
12020 && ppc64_elf_section_data (prev)->has_14bit_branch
12021 ? stub14_group_size : stub_group_size))
12022 && htab->sec_info[prev->id].toc_off == curr_toc)
12025 /* OK, the size from the start of CURR to the end is less
12026 than stub_group_size and thus can be handled by one stub
12027 section. (or the tail section is itself larger than
12028 stub_group_size, in which case we may be toast.) We
12029 should really be keeping track of the total size of stubs
12030 added here, as stubs contribute to the final output
12031 section size. That's a little tricky, and this way will
12032 only break if stubs added make the total size more than
12033 2^25, ie. for the default stub_group_size, if stubs total
12034 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12035 group = bfd_alloc (curr->owner, sizeof (*group));
12038 group->link_sec = curr;
12039 group->stub_sec = NULL;
12040 group->needs_save_res = 0;
12041 group->next = htab->group;
12042 htab->group = group;
12045 prev = htab->sec_info[tail->id].u.list;
12046 /* Set up this stub group. */
12047 htab->sec_info[tail->id].u.group = group;
12049 while (tail != curr && (tail = prev) != NULL);
12051 /* But wait, there's more! Input sections up to stub_group_size
12052 bytes before the stub section can be handled by it too.
12053 Don't do this if we have a really large section after the
12054 stubs, as adding more stubs increases the chance that
12055 branches may not reach into the stub section. */
12056 if (!stubs_always_before_branch && !big_sec)
12059 while (prev != NULL
12060 && ((total += tail->output_offset - prev->output_offset)
12061 < (ppc64_elf_section_data (prev) != NULL
12062 && ppc64_elf_section_data (prev)->has_14bit_branch
12063 ? stub14_group_size : stub_group_size))
12064 && htab->sec_info[prev->id].toc_off == curr_toc)
12067 prev = htab->sec_info[tail->id].u.list;
12068 htab->sec_info[tail->id].u.group = group;
12077 static const unsigned char glink_eh_frame_cie[] =
12079 0, 0, 0, 16, /* length. */
12080 0, 0, 0, 0, /* id. */
12081 1, /* CIE version. */
12082 'z', 'R', 0, /* Augmentation string. */
12083 4, /* Code alignment. */
12084 0x78, /* Data alignment. */
12086 1, /* Augmentation size. */
12087 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12088 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12092 /* Stripping output sections is normally done before dynamic section
12093 symbols have been allocated. This function is called later, and
12094 handles cases like htab->brlt which is mapped to its own output
12098 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12100 if (isec->size == 0
12101 && isec->output_section->size == 0
12102 && !(isec->output_section->flags & SEC_KEEP)
12103 && !bfd_section_removed_from_list (info->output_bfd,
12104 isec->output_section)
12105 && elf_section_data (isec->output_section)->dynindx == 0)
12107 isec->output_section->flags |= SEC_EXCLUDE;
12108 bfd_section_list_remove (info->output_bfd, isec->output_section);
12109 info->output_bfd->section_count--;
12113 /* Determine and set the size of the stub section for a final link.
12115 The basic idea here is to examine all the relocations looking for
12116 PC-relative calls to a target that is unreachable with a "bl"
12120 ppc64_elf_size_stubs (struct bfd_link_info *info)
12122 bfd_size_type stub_group_size;
12123 bfd_boolean stubs_always_before_branch;
12124 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12129 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12130 htab->params->plt_thread_safe = 1;
12131 if (!htab->opd_abi)
12132 htab->params->plt_thread_safe = 0;
12133 else if (htab->params->plt_thread_safe == -1)
12135 static const char *const thread_starter[] =
12139 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12141 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12142 "mq_notify", "create_timer",
12147 "GOMP_parallel_start",
12148 "GOMP_parallel_loop_static",
12149 "GOMP_parallel_loop_static_start",
12150 "GOMP_parallel_loop_dynamic",
12151 "GOMP_parallel_loop_dynamic_start",
12152 "GOMP_parallel_loop_guided",
12153 "GOMP_parallel_loop_guided_start",
12154 "GOMP_parallel_loop_runtime",
12155 "GOMP_parallel_loop_runtime_start",
12156 "GOMP_parallel_sections",
12157 "GOMP_parallel_sections_start",
12163 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12165 struct elf_link_hash_entry *h;
12166 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12167 FALSE, FALSE, TRUE);
12168 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12169 if (htab->params->plt_thread_safe)
12173 stubs_always_before_branch = htab->params->group_size < 0;
12174 if (htab->params->group_size < 0)
12175 stub_group_size = -htab->params->group_size;
12177 stub_group_size = htab->params->group_size;
12179 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12185 unsigned int bfd_indx;
12186 struct map_stub *group;
12187 asection *stub_sec;
12189 htab->stub_iteration += 1;
12191 for (input_bfd = info->input_bfds, bfd_indx = 0;
12193 input_bfd = input_bfd->link.next, bfd_indx++)
12195 Elf_Internal_Shdr *symtab_hdr;
12197 Elf_Internal_Sym *local_syms = NULL;
12199 if (!is_ppc64_elf (input_bfd))
12202 /* We'll need the symbol table in a second. */
12203 symtab_hdr = &elf_symtab_hdr (input_bfd);
12204 if (symtab_hdr->sh_info == 0)
12207 /* Walk over each section attached to the input bfd. */
12208 for (section = input_bfd->sections;
12210 section = section->next)
12212 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12214 /* If there aren't any relocs, then there's nothing more
12216 if ((section->flags & SEC_RELOC) == 0
12217 || (section->flags & SEC_ALLOC) == 0
12218 || (section->flags & SEC_LOAD) == 0
12219 || (section->flags & SEC_CODE) == 0
12220 || section->reloc_count == 0)
12223 /* If this section is a link-once section that will be
12224 discarded, then don't create any stubs. */
12225 if (section->output_section == NULL
12226 || section->output_section->owner != info->output_bfd)
12229 /* Get the relocs. */
12231 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12232 info->keep_memory);
12233 if (internal_relocs == NULL)
12234 goto error_ret_free_local;
12236 /* Now examine each relocation. */
12237 irela = internal_relocs;
12238 irelaend = irela + section->reloc_count;
12239 for (; irela < irelaend; irela++)
12241 enum elf_ppc64_reloc_type r_type;
12242 unsigned int r_indx;
12243 enum ppc_stub_type stub_type;
12244 struct ppc_stub_hash_entry *stub_entry;
12245 asection *sym_sec, *code_sec;
12246 bfd_vma sym_value, code_value;
12247 bfd_vma destination;
12248 unsigned long local_off;
12249 bfd_boolean ok_dest;
12250 struct ppc_link_hash_entry *hash;
12251 struct ppc_link_hash_entry *fdh;
12252 struct elf_link_hash_entry *h;
12253 Elf_Internal_Sym *sym;
12255 const asection *id_sec;
12256 struct _opd_sec_data *opd;
12257 struct plt_entry *plt_ent;
12259 r_type = ELF64_R_TYPE (irela->r_info);
12260 r_indx = ELF64_R_SYM (irela->r_info);
12262 if (r_type >= R_PPC64_max)
12264 bfd_set_error (bfd_error_bad_value);
12265 goto error_ret_free_internal;
12268 /* Only look for stubs on branch instructions. */
12269 if (r_type != R_PPC64_REL24
12270 && r_type != R_PPC64_REL14
12271 && r_type != R_PPC64_REL14_BRTAKEN
12272 && r_type != R_PPC64_REL14_BRNTAKEN)
12275 /* Now determine the call target, its name, value,
12277 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12278 r_indx, input_bfd))
12279 goto error_ret_free_internal;
12280 hash = (struct ppc_link_hash_entry *) h;
12287 sym_value = sym->st_value;
12288 if (sym_sec != NULL
12289 && sym_sec->output_section != NULL)
12292 else if (hash->elf.root.type == bfd_link_hash_defined
12293 || hash->elf.root.type == bfd_link_hash_defweak)
12295 sym_value = hash->elf.root.u.def.value;
12296 if (sym_sec->output_section != NULL)
12299 else if (hash->elf.root.type == bfd_link_hash_undefweak
12300 || hash->elf.root.type == bfd_link_hash_undefined)
12302 /* Recognise an old ABI func code entry sym, and
12303 use the func descriptor sym instead if it is
12305 if (hash->elf.root.root.string[0] == '.'
12306 && (fdh = lookup_fdh (hash, htab)) != NULL)
12308 if (fdh->elf.root.type == bfd_link_hash_defined
12309 || fdh->elf.root.type == bfd_link_hash_defweak)
12311 sym_sec = fdh->elf.root.u.def.section;
12312 sym_value = fdh->elf.root.u.def.value;
12313 if (sym_sec->output_section != NULL)
12322 bfd_set_error (bfd_error_bad_value);
12323 goto error_ret_free_internal;
12330 sym_value += irela->r_addend;
12331 destination = (sym_value
12332 + sym_sec->output_offset
12333 + sym_sec->output_section->vma);
12334 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12339 code_sec = sym_sec;
12340 code_value = sym_value;
12341 opd = get_opd_info (sym_sec);
12346 if (hash == NULL && opd->adjust != NULL)
12348 long adjust = opd->adjust[OPD_NDX (sym_value)];
12351 code_value += adjust;
12352 sym_value += adjust;
12354 dest = opd_entry_value (sym_sec, sym_value,
12355 &code_sec, &code_value, FALSE);
12356 if (dest != (bfd_vma) -1)
12358 destination = dest;
12361 /* Fixup old ABI sym to point at code
12363 hash->elf.root.type = bfd_link_hash_defweak;
12364 hash->elf.root.u.def.section = code_sec;
12365 hash->elf.root.u.def.value = code_value;
12370 /* Determine what (if any) linker stub is needed. */
12372 stub_type = ppc_type_of_stub (section, irela, &hash,
12373 &plt_ent, destination,
12376 if (stub_type != ppc_stub_plt_call)
12378 /* Check whether we need a TOC adjusting stub.
12379 Since the linker pastes together pieces from
12380 different object files when creating the
12381 _init and _fini functions, it may be that a
12382 call to what looks like a local sym is in
12383 fact a call needing a TOC adjustment. */
12384 if (code_sec != NULL
12385 && code_sec->output_section != NULL
12386 && (htab->sec_info[code_sec->id].toc_off
12387 != htab->sec_info[section->id].toc_off)
12388 && (code_sec->has_toc_reloc
12389 || code_sec->makes_toc_func_call))
12390 stub_type = ppc_stub_long_branch_r2off;
12393 if (stub_type == ppc_stub_none)
12396 /* __tls_get_addr calls might be eliminated. */
12397 if (stub_type != ppc_stub_plt_call
12399 && (hash == htab->tls_get_addr
12400 || hash == htab->tls_get_addr_fd)
12401 && section->has_tls_reloc
12402 && irela != internal_relocs)
12404 /* Get tls info. */
12405 unsigned char *tls_mask;
12407 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12408 irela - 1, input_bfd))
12409 goto error_ret_free_internal;
12410 if (*tls_mask != 0)
12414 if (stub_type == ppc_stub_plt_call
12415 && irela + 1 < irelaend
12416 && irela[1].r_offset == irela->r_offset + 4
12417 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12419 if (!tocsave_find (htab, INSERT,
12420 &local_syms, irela + 1, input_bfd))
12421 goto error_ret_free_internal;
12423 else if (stub_type == ppc_stub_plt_call)
12424 stub_type = ppc_stub_plt_call_r2save;
12426 /* Support for grouping stub sections. */
12427 id_sec = htab->sec_info[section->id].u.group->link_sec;
12429 /* Get the name of this stub. */
12430 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12432 goto error_ret_free_internal;
12434 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12435 stub_name, FALSE, FALSE);
12436 if (stub_entry != NULL)
12438 /* The proper stub has already been created. */
12440 if (stub_type == ppc_stub_plt_call_r2save)
12441 stub_entry->stub_type = stub_type;
12445 stub_entry = ppc_add_stub (stub_name, section, info);
12446 if (stub_entry == NULL)
12449 error_ret_free_internal:
12450 if (elf_section_data (section)->relocs == NULL)
12451 free (internal_relocs);
12452 error_ret_free_local:
12453 if (local_syms != NULL
12454 && (symtab_hdr->contents
12455 != (unsigned char *) local_syms))
12460 stub_entry->stub_type = stub_type;
12461 if (stub_type != ppc_stub_plt_call
12462 && stub_type != ppc_stub_plt_call_r2save)
12464 stub_entry->target_value = code_value;
12465 stub_entry->target_section = code_sec;
12469 stub_entry->target_value = sym_value;
12470 stub_entry->target_section = sym_sec;
12472 stub_entry->h = hash;
12473 stub_entry->plt_ent = plt_ent;
12474 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12476 if (stub_entry->h != NULL)
12477 htab->stub_globals += 1;
12480 /* We're done with the internal relocs, free them. */
12481 if (elf_section_data (section)->relocs != internal_relocs)
12482 free (internal_relocs);
12485 if (local_syms != NULL
12486 && symtab_hdr->contents != (unsigned char *) local_syms)
12488 if (!info->keep_memory)
12491 symtab_hdr->contents = (unsigned char *) local_syms;
12495 /* We may have added some stubs. Find out the new size of the
12497 for (stub_sec = htab->params->stub_bfd->sections;
12499 stub_sec = stub_sec->next)
12500 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12502 stub_sec->rawsize = stub_sec->size;
12503 stub_sec->size = 0;
12504 stub_sec->reloc_count = 0;
12505 stub_sec->flags &= ~SEC_RELOC;
12508 htab->brlt->size = 0;
12509 htab->brlt->reloc_count = 0;
12510 htab->brlt->flags &= ~SEC_RELOC;
12511 if (htab->relbrlt != NULL)
12512 htab->relbrlt->size = 0;
12514 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12516 for (group = htab->group; group != NULL; group = group->next)
12517 if (group->needs_save_res)
12518 group->stub_sec->size += htab->sfpr->size;
12520 if (info->emitrelocations
12521 && htab->glink != NULL && htab->glink->size != 0)
12523 htab->glink->reloc_count = 1;
12524 htab->glink->flags |= SEC_RELOC;
12527 if (htab->glink_eh_frame != NULL
12528 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12529 && htab->glink_eh_frame->output_section->size != 0)
12531 size_t size = 0, align;
12533 for (stub_sec = htab->params->stub_bfd->sections;
12535 stub_sec = stub_sec->next)
12536 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12538 if (htab->glink != NULL && htab->glink->size != 0)
12541 size += sizeof (glink_eh_frame_cie);
12543 align <<= htab->glink_eh_frame->output_section->alignment_power;
12545 size = (size + align) & ~align;
12546 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12547 htab->glink_eh_frame->size = size;
12550 if (htab->params->plt_stub_align != 0)
12551 for (stub_sec = htab->params->stub_bfd->sections;
12553 stub_sec = stub_sec->next)
12554 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12555 stub_sec->size = ((stub_sec->size
12556 + (1 << htab->params->plt_stub_align) - 1)
12557 & -(1 << htab->params->plt_stub_align));
12559 for (stub_sec = htab->params->stub_bfd->sections;
12561 stub_sec = stub_sec->next)
12562 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12563 && stub_sec->rawsize != stub_sec->size)
12566 /* Exit from this loop when no stubs have been added, and no stubs
12567 have changed size. */
12568 if (stub_sec == NULL
12569 && (htab->glink_eh_frame == NULL
12570 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12573 /* Ask the linker to do its stuff. */
12574 (*htab->params->layout_sections_again) ();
12577 if (htab->glink_eh_frame != NULL
12578 && htab->glink_eh_frame->size != 0)
12581 bfd_byte *p, *last_fde;
12582 size_t last_fde_len, size, align, pad;
12583 asection *stub_sec;
12585 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12588 htab->glink_eh_frame->contents = p;
12591 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12592 /* CIE length (rewrite in case little-endian). */
12593 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12594 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12595 p += sizeof (glink_eh_frame_cie);
12597 for (stub_sec = htab->params->stub_bfd->sections;
12599 stub_sec = stub_sec->next)
12600 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12605 bfd_put_32 (htab->elf.dynobj, 20, p);
12608 val = p - htab->glink_eh_frame->contents;
12609 bfd_put_32 (htab->elf.dynobj, val, p);
12611 /* Offset to stub section, written later. */
12613 /* stub section size. */
12614 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12616 /* Augmentation. */
12621 if (htab->glink != NULL && htab->glink->size != 0)
12626 bfd_put_32 (htab->elf.dynobj, 20, p);
12629 val = p - htab->glink_eh_frame->contents;
12630 bfd_put_32 (htab->elf.dynobj, val, p);
12632 /* Offset to .glink, written later. */
12635 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12637 /* Augmentation. */
12640 *p++ = DW_CFA_advance_loc + 1;
12641 *p++ = DW_CFA_register;
12643 *p++ = htab->opd_abi ? 12 : 0;
12644 *p++ = DW_CFA_advance_loc + 4;
12645 *p++ = DW_CFA_restore_extended;
12648 /* Subsume any padding into the last FDE if user .eh_frame
12649 sections are aligned more than glink_eh_frame. Otherwise any
12650 zero padding will be seen as a terminator. */
12651 size = p - htab->glink_eh_frame->contents;
12653 align <<= htab->glink_eh_frame->output_section->alignment_power;
12655 pad = ((size + align) & ~align) - size;
12656 htab->glink_eh_frame->size = size + pad;
12657 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12660 maybe_strip_output (info, htab->brlt);
12661 if (htab->glink_eh_frame != NULL)
12662 maybe_strip_output (info, htab->glink_eh_frame);
12667 /* Called after we have determined section placement. If sections
12668 move, we'll be called again. Provide a value for TOCstart. */
12671 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12674 bfd_vma TOCstart, adjust;
12678 struct elf_link_hash_entry *h;
12679 struct elf_link_hash_table *htab = elf_hash_table (info);
12681 if (is_elf_hash_table (htab)
12682 && htab->hgot != NULL)
12686 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12687 if (is_elf_hash_table (htab))
12691 && h->root.type == bfd_link_hash_defined
12692 && !h->root.linker_def
12693 && (!is_elf_hash_table (htab)
12694 || h->def_regular))
12696 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12697 + h->root.u.def.section->output_offset
12698 + h->root.u.def.section->output_section->vma);
12699 _bfd_set_gp_value (obfd, TOCstart);
12704 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12705 order. The TOC starts where the first of these sections starts. */
12706 s = bfd_get_section_by_name (obfd, ".got");
12707 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12708 s = bfd_get_section_by_name (obfd, ".toc");
12709 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12710 s = bfd_get_section_by_name (obfd, ".tocbss");
12711 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12712 s = bfd_get_section_by_name (obfd, ".plt");
12713 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12715 /* This may happen for
12716 o references to TOC base (SYM@toc / TOC[tc0]) without a
12718 o bad linker script
12719 o --gc-sections and empty TOC sections
12721 FIXME: Warn user? */
12723 /* Look for a likely section. We probably won't even be
12725 for (s = obfd->sections; s != NULL; s = s->next)
12726 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12728 == (SEC_ALLOC | SEC_SMALL_DATA))
12731 for (s = obfd->sections; s != NULL; s = s->next)
12732 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12733 == (SEC_ALLOC | SEC_SMALL_DATA))
12736 for (s = obfd->sections; s != NULL; s = s->next)
12737 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12741 for (s = obfd->sections; s != NULL; s = s->next)
12742 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12748 TOCstart = s->output_section->vma + s->output_offset;
12750 /* Force alignment. */
12751 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12752 TOCstart -= adjust;
12753 _bfd_set_gp_value (obfd, TOCstart);
12755 if (info != NULL && s != NULL)
12757 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12761 if (htab->elf.hgot != NULL)
12763 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12764 htab->elf.hgot->root.u.def.section = s;
12769 struct bfd_link_hash_entry *bh = NULL;
12770 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12771 s, TOC_BASE_OFF - adjust,
12772 NULL, FALSE, FALSE, &bh);
12778 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12779 write out any global entry stubs. */
12782 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12784 struct bfd_link_info *info;
12785 struct ppc_link_hash_table *htab;
12786 struct plt_entry *pent;
12789 if (h->root.type == bfd_link_hash_indirect)
12792 if (!h->pointer_equality_needed)
12795 if (h->def_regular)
12799 htab = ppc_hash_table (info);
12804 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12805 if (pent->plt.offset != (bfd_vma) -1
12806 && pent->addend == 0)
12812 p = s->contents + h->root.u.def.value;
12813 plt = htab->elf.splt;
12814 if (!htab->elf.dynamic_sections_created
12815 || h->dynindx == -1)
12816 plt = htab->elf.iplt;
12817 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12818 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12820 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12822 info->callbacks->einfo
12823 (_("%P: linkage table error against `%T'\n"),
12824 h->root.root.string);
12825 bfd_set_error (bfd_error_bad_value);
12826 htab->stub_error = TRUE;
12829 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12830 if (htab->params->emit_stub_syms)
12832 size_t len = strlen (h->root.root.string);
12833 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12838 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12839 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12842 if (h->root.type == bfd_link_hash_new)
12844 h->root.type = bfd_link_hash_defined;
12845 h->root.u.def.section = s;
12846 h->root.u.def.value = p - s->contents;
12847 h->ref_regular = 1;
12848 h->def_regular = 1;
12849 h->ref_regular_nonweak = 1;
12850 h->forced_local = 1;
12852 h->root.linker_def = 1;
12856 if (PPC_HA (off) != 0)
12858 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12861 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12863 bfd_put_32 (s->owner, MTCTR_R12, p);
12865 bfd_put_32 (s->owner, BCTR, p);
12871 /* Build all the stubs associated with the current output file.
12872 The stubs are kept in a hash table attached to the main linker
12873 hash table. This function is called via gldelf64ppc_finish. */
12876 ppc64_elf_build_stubs (struct bfd_link_info *info,
12879 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12880 struct map_stub *group;
12881 asection *stub_sec;
12883 int stub_sec_count = 0;
12888 /* Allocate memory to hold the linker stubs. */
12889 for (stub_sec = htab->params->stub_bfd->sections;
12891 stub_sec = stub_sec->next)
12892 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12893 && stub_sec->size != 0)
12895 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12896 if (stub_sec->contents == NULL)
12898 /* We want to check that built size is the same as calculated
12899 size. rawsize is a convenient location to use. */
12900 stub_sec->rawsize = stub_sec->size;
12901 stub_sec->size = 0;
12904 if (htab->glink != NULL && htab->glink->size != 0)
12909 /* Build the .glink plt call stub. */
12910 if (htab->params->emit_stub_syms)
12912 struct elf_link_hash_entry *h;
12913 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12914 TRUE, FALSE, FALSE);
12917 if (h->root.type == bfd_link_hash_new)
12919 h->root.type = bfd_link_hash_defined;
12920 h->root.u.def.section = htab->glink;
12921 h->root.u.def.value = 8;
12922 h->ref_regular = 1;
12923 h->def_regular = 1;
12924 h->ref_regular_nonweak = 1;
12925 h->forced_local = 1;
12927 h->root.linker_def = 1;
12930 plt0 = (htab->elf.splt->output_section->vma
12931 + htab->elf.splt->output_offset
12933 if (info->emitrelocations)
12935 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12938 r->r_offset = (htab->glink->output_offset
12939 + htab->glink->output_section->vma);
12940 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12941 r->r_addend = plt0;
12943 p = htab->glink->contents;
12944 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12945 bfd_put_64 (htab->glink->owner, plt0, p);
12949 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12951 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12953 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12955 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12957 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12959 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12961 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12963 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12965 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12967 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12972 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12974 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12976 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12978 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12980 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12982 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12984 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12986 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12988 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12990 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12992 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12994 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12997 bfd_put_32 (htab->glink->owner, BCTR, p);
12999 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13001 bfd_put_32 (htab->glink->owner, NOP, p);
13005 /* Build the .glink lazy link call stubs. */
13007 while (p < htab->glink->contents + htab->glink->rawsize)
13013 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13018 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13020 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13025 bfd_put_32 (htab->glink->owner,
13026 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13031 /* Build .glink global entry stubs. */
13032 if (htab->glink->size > htab->glink->rawsize)
13033 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13036 if (htab->brlt != NULL && htab->brlt->size != 0)
13038 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13040 if (htab->brlt->contents == NULL)
13043 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13045 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13046 htab->relbrlt->size);
13047 if (htab->relbrlt->contents == NULL)
13051 /* Build the stubs as directed by the stub hash table. */
13052 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13054 for (group = htab->group; group != NULL; group = group->next)
13055 if (group->needs_save_res)
13057 stub_sec = group->stub_sec;
13058 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13060 if (htab->params->emit_stub_syms)
13064 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13065 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13068 stub_sec->size += htab->sfpr->size;
13071 if (htab->relbrlt != NULL)
13072 htab->relbrlt->reloc_count = 0;
13074 if (htab->params->plt_stub_align != 0)
13075 for (stub_sec = htab->params->stub_bfd->sections;
13077 stub_sec = stub_sec->next)
13078 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13079 stub_sec->size = ((stub_sec->size
13080 + (1 << htab->params->plt_stub_align) - 1)
13081 & -(1 << htab->params->plt_stub_align));
13083 for (stub_sec = htab->params->stub_bfd->sections;
13085 stub_sec = stub_sec->next)
13086 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13088 stub_sec_count += 1;
13089 if (stub_sec->rawsize != stub_sec->size)
13093 /* Note that the glink_eh_frame check here is not only testing that
13094 the generated size matched the calculated size but also that
13095 bfd_elf_discard_info didn't make any changes to the section. */
13096 if (stub_sec != NULL
13097 || (htab->glink_eh_frame != NULL
13098 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13100 htab->stub_error = TRUE;
13101 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13104 if (htab->stub_error)
13109 *stats = bfd_malloc (500);
13110 if (*stats == NULL)
13113 sprintf (*stats, _("linker stubs in %u group%s\n"
13115 " toc adjust %lu\n"
13116 " long branch %lu\n"
13117 " long toc adj %lu\n"
13119 " plt call toc %lu\n"
13120 " global entry %lu"),
13122 stub_sec_count == 1 ? "" : "s",
13123 htab->stub_count[ppc_stub_long_branch - 1],
13124 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13125 htab->stub_count[ppc_stub_plt_branch - 1],
13126 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13127 htab->stub_count[ppc_stub_plt_call - 1],
13128 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13129 htab->stub_count[ppc_stub_global_entry - 1]);
13134 /* This function undoes the changes made by add_symbol_adjust. */
13137 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13139 struct ppc_link_hash_entry *eh;
13141 if (h->root.type == bfd_link_hash_indirect)
13144 eh = (struct ppc_link_hash_entry *) h;
13145 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13148 eh->elf.root.type = bfd_link_hash_undefined;
13153 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13155 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13158 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13161 /* What to do when ld finds relocations against symbols defined in
13162 discarded sections. */
13164 static unsigned int
13165 ppc64_elf_action_discarded (asection *sec)
13167 if (strcmp (".opd", sec->name) == 0)
13170 if (strcmp (".toc", sec->name) == 0)
13173 if (strcmp (".toc1", sec->name) == 0)
13176 return _bfd_elf_default_action_discarded (sec);
13179 /* The RELOCATE_SECTION function is called by the ELF backend linker
13180 to handle the relocations for a section.
13182 The relocs are always passed as Rela structures; if the section
13183 actually uses Rel structures, the r_addend field will always be
13186 This function is responsible for adjust the section contents as
13187 necessary, and (if using Rela relocs and generating a
13188 relocatable output file) adjusting the reloc addend as
13191 This function does not have to worry about setting the reloc
13192 address or the reloc symbol index.
13194 LOCAL_SYMS is a pointer to the swapped in local symbols.
13196 LOCAL_SECTIONS is an array giving the section in the input file
13197 corresponding to the st_shndx field of each local symbol.
13199 The global hash table entry for the global symbols can be found
13200 via elf_sym_hashes (input_bfd).
13202 When generating relocatable output, this function must handle
13203 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13204 going to be the section symbol corresponding to the output
13205 section, which means that the addend must be adjusted
13209 ppc64_elf_relocate_section (bfd *output_bfd,
13210 struct bfd_link_info *info,
13212 asection *input_section,
13213 bfd_byte *contents,
13214 Elf_Internal_Rela *relocs,
13215 Elf_Internal_Sym *local_syms,
13216 asection **local_sections)
13218 struct ppc_link_hash_table *htab;
13219 Elf_Internal_Shdr *symtab_hdr;
13220 struct elf_link_hash_entry **sym_hashes;
13221 Elf_Internal_Rela *rel;
13222 Elf_Internal_Rela *wrel;
13223 Elf_Internal_Rela *relend;
13224 Elf_Internal_Rela outrel;
13226 struct got_entry **local_got_ents;
13228 bfd_boolean ret = TRUE;
13229 bfd_boolean is_opd;
13230 /* Assume 'at' branch hints. */
13231 bfd_boolean is_isa_v2 = TRUE;
13232 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13234 /* Initialize howto table if needed. */
13235 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13238 htab = ppc_hash_table (info);
13242 /* Don't relocate stub sections. */
13243 if (input_section->owner == htab->params->stub_bfd)
13246 BFD_ASSERT (is_ppc64_elf (input_bfd));
13248 local_got_ents = elf_local_got_ents (input_bfd);
13249 TOCstart = elf_gp (output_bfd);
13250 symtab_hdr = &elf_symtab_hdr (input_bfd);
13251 sym_hashes = elf_sym_hashes (input_bfd);
13252 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13254 rel = wrel = relocs;
13255 relend = relocs + input_section->reloc_count;
13256 for (; rel < relend; wrel++, rel++)
13258 enum elf_ppc64_reloc_type r_type;
13260 bfd_reloc_status_type r;
13261 Elf_Internal_Sym *sym;
13263 struct elf_link_hash_entry *h_elf;
13264 struct ppc_link_hash_entry *h;
13265 struct ppc_link_hash_entry *fdh;
13266 const char *sym_name;
13267 unsigned long r_symndx, toc_symndx;
13268 bfd_vma toc_addend;
13269 unsigned char tls_mask, tls_gd, tls_type;
13270 unsigned char sym_type;
13271 bfd_vma relocation;
13272 bfd_boolean unresolved_reloc;
13273 bfd_boolean warned;
13274 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13277 struct ppc_stub_hash_entry *stub_entry;
13278 bfd_vma max_br_offset;
13280 Elf_Internal_Rela orig_rel;
13281 reloc_howto_type *howto;
13282 struct reloc_howto_struct alt_howto;
13287 r_type = ELF64_R_TYPE (rel->r_info);
13288 r_symndx = ELF64_R_SYM (rel->r_info);
13290 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13291 symbol of the previous ADDR64 reloc. The symbol gives us the
13292 proper TOC base to use. */
13293 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13295 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13297 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13303 unresolved_reloc = FALSE;
13306 if (r_symndx < symtab_hdr->sh_info)
13308 /* It's a local symbol. */
13309 struct _opd_sec_data *opd;
13311 sym = local_syms + r_symndx;
13312 sec = local_sections[r_symndx];
13313 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13314 sym_type = ELF64_ST_TYPE (sym->st_info);
13315 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13316 opd = get_opd_info (sec);
13317 if (opd != NULL && opd->adjust != NULL)
13319 long adjust = opd->adjust[OPD_NDX (sym->st_value
13325 /* If this is a relocation against the opd section sym
13326 and we have edited .opd, adjust the reloc addend so
13327 that ld -r and ld --emit-relocs output is correct.
13328 If it is a reloc against some other .opd symbol,
13329 then the symbol value will be adjusted later. */
13330 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13331 rel->r_addend += adjust;
13333 relocation += adjust;
13339 bfd_boolean ignored;
13341 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13342 r_symndx, symtab_hdr, sym_hashes,
13343 h_elf, sec, relocation,
13344 unresolved_reloc, warned, ignored);
13345 sym_name = h_elf->root.root.string;
13346 sym_type = h_elf->type;
13348 && sec->owner == output_bfd
13349 && strcmp (sec->name, ".opd") == 0)
13351 /* This is a symbol defined in a linker script. All
13352 such are defined in output sections, even those
13353 defined by simple assignment from a symbol defined in
13354 an input section. Transfer the symbol to an
13355 appropriate input .opd section, so that a branch to
13356 this symbol will be mapped to the location specified
13357 by the opd entry. */
13358 struct bfd_link_order *lo;
13359 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13360 if (lo->type == bfd_indirect_link_order)
13362 asection *isec = lo->u.indirect.section;
13363 if (h_elf->root.u.def.value >= isec->output_offset
13364 && h_elf->root.u.def.value < (isec->output_offset
13367 h_elf->root.u.def.value -= isec->output_offset;
13368 h_elf->root.u.def.section = isec;
13375 h = (struct ppc_link_hash_entry *) h_elf;
13377 if (sec != NULL && discarded_section (sec))
13379 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13380 input_bfd, input_section,
13381 contents + rel->r_offset);
13382 wrel->r_offset = rel->r_offset;
13384 wrel->r_addend = 0;
13386 /* For ld -r, remove relocations in debug sections against
13387 sections defined in discarded sections. Not done for
13388 non-debug to preserve relocs in .eh_frame which the
13389 eh_frame editing code expects to be present. */
13390 if (bfd_link_relocatable (info)
13391 && (input_section->flags & SEC_DEBUGGING))
13397 if (bfd_link_relocatable (info))
13400 if (h != NULL && &h->elf == htab->elf.hgot)
13402 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13403 sec = bfd_abs_section_ptr;
13404 unresolved_reloc = FALSE;
13407 /* TLS optimizations. Replace instruction sequences and relocs
13408 based on information we collected in tls_optimize. We edit
13409 RELOCS so that --emit-relocs will output something sensible
13410 for the final instruction stream. */
13415 tls_mask = h->tls_mask;
13416 else if (local_got_ents != NULL)
13418 struct plt_entry **local_plt = (struct plt_entry **)
13419 (local_got_ents + symtab_hdr->sh_info);
13420 unsigned char *lgot_masks = (unsigned char *)
13421 (local_plt + symtab_hdr->sh_info);
13422 tls_mask = lgot_masks[r_symndx];
13425 && (r_type == R_PPC64_TLS
13426 || r_type == R_PPC64_TLSGD
13427 || r_type == R_PPC64_TLSLD))
13429 /* Check for toc tls entries. */
13430 unsigned char *toc_tls;
13432 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13433 &local_syms, rel, input_bfd))
13437 tls_mask = *toc_tls;
13440 /* Check that tls relocs are used with tls syms, and non-tls
13441 relocs are used with non-tls syms. */
13442 if (r_symndx != STN_UNDEF
13443 && r_type != R_PPC64_NONE
13445 || h->elf.root.type == bfd_link_hash_defined
13446 || h->elf.root.type == bfd_link_hash_defweak)
13447 && (IS_PPC64_TLS_RELOC (r_type)
13448 != (sym_type == STT_TLS
13449 || (sym_type == STT_SECTION
13450 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13453 && (r_type == R_PPC64_TLS
13454 || r_type == R_PPC64_TLSGD
13455 || r_type == R_PPC64_TLSLD))
13456 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13459 info->callbacks->einfo
13460 (!IS_PPC64_TLS_RELOC (r_type)
13461 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13462 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13463 input_bfd, input_section, rel->r_offset,
13464 ppc64_elf_howto_table[r_type]->name,
13468 /* Ensure reloc mapping code below stays sane. */
13469 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13470 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13471 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13472 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13473 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13474 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13475 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13476 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13477 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13478 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13486 case R_PPC64_LO_DS_OPT:
13487 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13488 if ((insn & (0x3f << 26)) != 58u << 26)
13490 insn += (14u << 26) - (58u << 26);
13491 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13492 r_type = R_PPC64_TOC16_LO;
13493 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13496 case R_PPC64_TOC16:
13497 case R_PPC64_TOC16_LO:
13498 case R_PPC64_TOC16_DS:
13499 case R_PPC64_TOC16_LO_DS:
13501 /* Check for toc tls entries. */
13502 unsigned char *toc_tls;
13505 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13506 &local_syms, rel, input_bfd);
13512 tls_mask = *toc_tls;
13513 if (r_type == R_PPC64_TOC16_DS
13514 || r_type == R_PPC64_TOC16_LO_DS)
13517 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13522 /* If we found a GD reloc pair, then we might be
13523 doing a GD->IE transition. */
13526 tls_gd = TLS_TPRELGD;
13527 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13530 else if (retval == 3)
13532 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13540 case R_PPC64_GOT_TPREL16_HI:
13541 case R_PPC64_GOT_TPREL16_HA:
13543 && (tls_mask & TLS_TPREL) == 0)
13545 rel->r_offset -= d_offset;
13546 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13547 r_type = R_PPC64_NONE;
13548 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13552 case R_PPC64_GOT_TPREL16_DS:
13553 case R_PPC64_GOT_TPREL16_LO_DS:
13555 && (tls_mask & TLS_TPREL) == 0)
13558 insn = bfd_get_32 (output_bfd,
13559 contents + rel->r_offset - d_offset);
13561 insn |= 0x3c0d0000; /* addis 0,13,0 */
13562 bfd_put_32 (output_bfd, insn,
13563 contents + rel->r_offset - d_offset);
13564 r_type = R_PPC64_TPREL16_HA;
13565 if (toc_symndx != 0)
13567 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13568 rel->r_addend = toc_addend;
13569 /* We changed the symbol. Start over in order to
13570 get h, sym, sec etc. right. */
13574 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13580 && (tls_mask & TLS_TPREL) == 0)
13582 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13583 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13586 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13587 /* Was PPC64_TLS which sits on insn boundary, now
13588 PPC64_TPREL16_LO which is at low-order half-word. */
13589 rel->r_offset += d_offset;
13590 r_type = R_PPC64_TPREL16_LO;
13591 if (toc_symndx != 0)
13593 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13594 rel->r_addend = toc_addend;
13595 /* We changed the symbol. Start over in order to
13596 get h, sym, sec etc. right. */
13600 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13604 case R_PPC64_GOT_TLSGD16_HI:
13605 case R_PPC64_GOT_TLSGD16_HA:
13606 tls_gd = TLS_TPRELGD;
13607 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13611 case R_PPC64_GOT_TLSLD16_HI:
13612 case R_PPC64_GOT_TLSLD16_HA:
13613 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13616 if ((tls_mask & tls_gd) != 0)
13617 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13618 + R_PPC64_GOT_TPREL16_DS);
13621 rel->r_offset -= d_offset;
13622 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13623 r_type = R_PPC64_NONE;
13625 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13629 case R_PPC64_GOT_TLSGD16:
13630 case R_PPC64_GOT_TLSGD16_LO:
13631 tls_gd = TLS_TPRELGD;
13632 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13636 case R_PPC64_GOT_TLSLD16:
13637 case R_PPC64_GOT_TLSLD16_LO:
13638 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13640 unsigned int insn1, insn2, insn3;
13644 offset = (bfd_vma) -1;
13645 /* If not using the newer R_PPC64_TLSGD/LD to mark
13646 __tls_get_addr calls, we must trust that the call
13647 stays with its arg setup insns, ie. that the next
13648 reloc is the __tls_get_addr call associated with
13649 the current reloc. Edit both insns. */
13650 if (input_section->has_tls_get_addr_call
13651 && rel + 1 < relend
13652 && branch_reloc_hash_match (input_bfd, rel + 1,
13653 htab->tls_get_addr,
13654 htab->tls_get_addr_fd))
13655 offset = rel[1].r_offset;
13656 /* We read the low GOT_TLS (or TOC16) insn because we
13657 need to keep the destination reg. It may be
13658 something other than the usual r3, and moved to r3
13659 before the call by intervening code. */
13660 insn1 = bfd_get_32 (output_bfd,
13661 contents + rel->r_offset - d_offset);
13662 if ((tls_mask & tls_gd) != 0)
13665 insn1 &= (0x1f << 21) | (0x1f << 16);
13666 insn1 |= 58 << 26; /* ld */
13667 insn2 = 0x7c636a14; /* add 3,3,13 */
13668 if (offset != (bfd_vma) -1)
13669 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13670 if ((tls_mask & TLS_EXPLICIT) == 0)
13671 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13672 + R_PPC64_GOT_TPREL16_DS);
13674 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13675 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13680 insn1 &= 0x1f << 21;
13681 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13682 insn2 = 0x38630000; /* addi 3,3,0 */
13685 /* Was an LD reloc. */
13687 sec = local_sections[toc_symndx];
13689 r_symndx < symtab_hdr->sh_info;
13691 if (local_sections[r_symndx] == sec)
13693 if (r_symndx >= symtab_hdr->sh_info)
13694 r_symndx = STN_UNDEF;
13695 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13696 if (r_symndx != STN_UNDEF)
13697 rel->r_addend -= (local_syms[r_symndx].st_value
13698 + sec->output_offset
13699 + sec->output_section->vma);
13701 else if (toc_symndx != 0)
13703 r_symndx = toc_symndx;
13704 rel->r_addend = toc_addend;
13706 r_type = R_PPC64_TPREL16_HA;
13707 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13708 if (offset != (bfd_vma) -1)
13710 rel[1].r_info = ELF64_R_INFO (r_symndx,
13711 R_PPC64_TPREL16_LO);
13712 rel[1].r_offset = offset + d_offset;
13713 rel[1].r_addend = rel->r_addend;
13716 bfd_put_32 (output_bfd, insn1,
13717 contents + rel->r_offset - d_offset);
13718 if (offset != (bfd_vma) -1)
13720 insn3 = bfd_get_32 (output_bfd,
13721 contents + offset + 4);
13723 || insn3 == CROR_151515 || insn3 == CROR_313131)
13725 rel[1].r_offset += 4;
13726 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13729 bfd_put_32 (output_bfd, insn2, contents + offset);
13731 if ((tls_mask & tls_gd) == 0
13732 && (tls_gd == 0 || toc_symndx != 0))
13734 /* We changed the symbol. Start over in order
13735 to get h, sym, sec etc. right. */
13741 case R_PPC64_TLSGD:
13742 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13744 unsigned int insn2, insn3;
13745 bfd_vma offset = rel->r_offset;
13747 if ((tls_mask & TLS_TPRELGD) != 0)
13750 r_type = R_PPC64_NONE;
13751 insn2 = 0x7c636a14; /* add 3,3,13 */
13756 if (toc_symndx != 0)
13758 r_symndx = toc_symndx;
13759 rel->r_addend = toc_addend;
13761 r_type = R_PPC64_TPREL16_LO;
13762 rel->r_offset = offset + d_offset;
13763 insn2 = 0x38630000; /* addi 3,3,0 */
13765 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13766 /* Zap the reloc on the _tls_get_addr call too. */
13767 BFD_ASSERT (offset == rel[1].r_offset);
13768 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13769 insn3 = bfd_get_32 (output_bfd,
13770 contents + offset + 4);
13772 || insn3 == CROR_151515 || insn3 == CROR_313131)
13774 rel->r_offset += 4;
13775 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13778 bfd_put_32 (output_bfd, insn2, contents + offset);
13779 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13784 case R_PPC64_TLSLD:
13785 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13787 unsigned int insn2, insn3;
13788 bfd_vma offset = rel->r_offset;
13791 sec = local_sections[toc_symndx];
13793 r_symndx < symtab_hdr->sh_info;
13795 if (local_sections[r_symndx] == sec)
13797 if (r_symndx >= symtab_hdr->sh_info)
13798 r_symndx = STN_UNDEF;
13799 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13800 if (r_symndx != STN_UNDEF)
13801 rel->r_addend -= (local_syms[r_symndx].st_value
13802 + sec->output_offset
13803 + sec->output_section->vma);
13805 r_type = R_PPC64_TPREL16_LO;
13806 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13807 rel->r_offset = offset + d_offset;
13808 /* Zap the reloc on the _tls_get_addr call too. */
13809 BFD_ASSERT (offset == rel[1].r_offset);
13810 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13811 insn2 = 0x38630000; /* addi 3,3,0 */
13812 insn3 = bfd_get_32 (output_bfd,
13813 contents + offset + 4);
13815 || insn3 == CROR_151515 || insn3 == CROR_313131)
13817 rel->r_offset += 4;
13818 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13821 bfd_put_32 (output_bfd, insn2, contents + offset);
13826 case R_PPC64_DTPMOD64:
13827 if (rel + 1 < relend
13828 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13829 && rel[1].r_offset == rel->r_offset + 8)
13831 if ((tls_mask & TLS_GD) == 0)
13833 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13834 if ((tls_mask & TLS_TPRELGD) != 0)
13835 r_type = R_PPC64_TPREL64;
13838 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13839 r_type = R_PPC64_NONE;
13841 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13846 if ((tls_mask & TLS_LD) == 0)
13848 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13849 r_type = R_PPC64_NONE;
13850 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13855 case R_PPC64_TPREL64:
13856 if ((tls_mask & TLS_TPREL) == 0)
13858 r_type = R_PPC64_NONE;
13859 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13863 case R_PPC64_ENTRY:
13864 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13865 if (!bfd_link_pic (info)
13866 && !info->traditional_format
13867 && relocation + 0x80008000 <= 0xffffffff)
13869 unsigned int insn1, insn2;
13871 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13872 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13873 if ((insn1 & ~0xfffc) == LD_R2_0R12
13874 && insn2 == ADD_R2_R2_R12)
13876 bfd_put_32 (output_bfd,
13877 LIS_R2 + PPC_HA (relocation),
13878 contents + rel->r_offset);
13879 bfd_put_32 (output_bfd,
13880 ADDI_R2_R2 + PPC_LO (relocation),
13881 contents + rel->r_offset + 4);
13886 relocation -= (rel->r_offset
13887 + input_section->output_offset
13888 + input_section->output_section->vma);
13889 if (relocation + 0x80008000 <= 0xffffffff)
13891 unsigned int insn1, insn2;
13893 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13894 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13895 if ((insn1 & ~0xfffc) == LD_R2_0R12
13896 && insn2 == ADD_R2_R2_R12)
13898 bfd_put_32 (output_bfd,
13899 ADDIS_R2_R12 + PPC_HA (relocation),
13900 contents + rel->r_offset);
13901 bfd_put_32 (output_bfd,
13902 ADDI_R2_R2 + PPC_LO (relocation),
13903 contents + rel->r_offset + 4);
13909 case R_PPC64_REL16_HA:
13910 /* If we are generating a non-PIC executable, edit
13911 . 0: addis 2,12,.TOC.-0b@ha
13912 . addi 2,2,.TOC.-0b@l
13913 used by ELFv2 global entry points to set up r2, to
13916 if .TOC. is in range. */
13917 if (!bfd_link_pic (info)
13918 && !info->traditional_format
13920 && rel->r_addend == d_offset
13921 && h != NULL && &h->elf == htab->elf.hgot
13922 && rel + 1 < relend
13923 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13924 && rel[1].r_offset == rel->r_offset + 4
13925 && rel[1].r_addend == rel->r_addend + 4
13926 && relocation + 0x80008000 <= 0xffffffff)
13928 unsigned int insn1, insn2;
13929 bfd_vma offset = rel->r_offset - d_offset;
13930 insn1 = bfd_get_32 (output_bfd, contents + offset);
13931 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13932 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13933 && (insn2 & 0xffff0000) == ADDI_R2_R2)
13935 r_type = R_PPC64_ADDR16_HA;
13936 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13937 rel->r_addend -= d_offset;
13938 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13939 rel[1].r_addend -= d_offset + 4;
13940 bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13946 /* Handle other relocations that tweak non-addend part of insn. */
13948 max_br_offset = 1 << 25;
13949 addend = rel->r_addend;
13950 reloc_dest = DEST_NORMAL;
13956 case R_PPC64_TOCSAVE:
13957 if (relocation + addend == (rel->r_offset
13958 + input_section->output_offset
13959 + input_section->output_section->vma)
13960 && tocsave_find (htab, NO_INSERT,
13961 &local_syms, rel, input_bfd))
13963 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13965 || insn == CROR_151515 || insn == CROR_313131)
13966 bfd_put_32 (input_bfd,
13967 STD_R2_0R1 + STK_TOC (htab),
13968 contents + rel->r_offset);
13972 /* Branch taken prediction relocations. */
13973 case R_PPC64_ADDR14_BRTAKEN:
13974 case R_PPC64_REL14_BRTAKEN:
13975 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13978 /* Branch not taken prediction relocations. */
13979 case R_PPC64_ADDR14_BRNTAKEN:
13980 case R_PPC64_REL14_BRNTAKEN:
13981 insn |= bfd_get_32 (output_bfd,
13982 contents + rel->r_offset) & ~(0x01 << 21);
13985 case R_PPC64_REL14:
13986 max_br_offset = 1 << 15;
13989 case R_PPC64_REL24:
13990 /* Calls to functions with a different TOC, such as calls to
13991 shared objects, need to alter the TOC pointer. This is
13992 done using a linkage stub. A REL24 branching to these
13993 linkage stubs needs to be followed by a nop, as the nop
13994 will be replaced with an instruction to restore the TOC
13999 && h->oh->is_func_descriptor)
14000 fdh = ppc_follow_link (h->oh);
14001 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14003 if (stub_entry != NULL
14004 && (stub_entry->stub_type == ppc_stub_plt_call
14005 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14006 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14007 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14009 bfd_boolean can_plt_call = FALSE;
14011 /* All of these stubs will modify r2, so there must be a
14012 branch and link followed by a nop. The nop is
14013 replaced by an insn to restore r2. */
14014 if (rel->r_offset + 8 <= input_section->size)
14018 br = bfd_get_32 (input_bfd,
14019 contents + rel->r_offset);
14024 nop = bfd_get_32 (input_bfd,
14025 contents + rel->r_offset + 4);
14027 || nop == CROR_151515 || nop == CROR_313131)
14030 && (h == htab->tls_get_addr_fd
14031 || h == htab->tls_get_addr)
14032 && htab->params->tls_get_addr_opt)
14034 /* Special stub used, leave nop alone. */
14037 bfd_put_32 (input_bfd,
14038 LD_R2_0R1 + STK_TOC (htab),
14039 contents + rel->r_offset + 4);
14040 can_plt_call = TRUE;
14045 if (!can_plt_call && h != NULL)
14047 const char *name = h->elf.root.root.string;
14052 if (strncmp (name, "__libc_start_main", 17) == 0
14053 && (name[17] == 0 || name[17] == '@'))
14055 /* Allow crt1 branch to go via a toc adjusting
14056 stub. Other calls that never return could do
14057 the same, if we could detect such. */
14058 can_plt_call = TRUE;
14064 /* g++ as of 20130507 emits self-calls without a
14065 following nop. This is arguably wrong since we
14066 have conflicting information. On the one hand a
14067 global symbol and on the other a local call
14068 sequence, but don't error for this special case.
14069 It isn't possible to cheaply verify we have
14070 exactly such a call. Allow all calls to the same
14072 asection *code_sec = sec;
14074 if (get_opd_info (sec) != NULL)
14076 bfd_vma off = (relocation + addend
14077 - sec->output_section->vma
14078 - sec->output_offset);
14080 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14082 if (code_sec == input_section)
14083 can_plt_call = TRUE;
14088 if (stub_entry->stub_type == ppc_stub_plt_call
14089 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14090 info->callbacks->einfo
14091 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14092 "recompile with -fPIC\n"),
14093 input_bfd, input_section, rel->r_offset, sym_name);
14095 info->callbacks->einfo
14096 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14097 "(-mcmodel=small toc adjust stub)\n"),
14098 input_bfd, input_section, rel->r_offset, sym_name);
14100 bfd_set_error (bfd_error_bad_value);
14105 && (stub_entry->stub_type == ppc_stub_plt_call
14106 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14107 unresolved_reloc = FALSE;
14110 if ((stub_entry == NULL
14111 || stub_entry->stub_type == ppc_stub_long_branch
14112 || stub_entry->stub_type == ppc_stub_plt_branch)
14113 && get_opd_info (sec) != NULL)
14115 /* The branch destination is the value of the opd entry. */
14116 bfd_vma off = (relocation + addend
14117 - sec->output_section->vma
14118 - sec->output_offset);
14119 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14120 if (dest != (bfd_vma) -1)
14124 reloc_dest = DEST_OPD;
14128 /* If the branch is out of reach we ought to have a long
14130 from = (rel->r_offset
14131 + input_section->output_offset
14132 + input_section->output_section->vma);
14134 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14138 if (stub_entry != NULL
14139 && (stub_entry->stub_type == ppc_stub_long_branch
14140 || stub_entry->stub_type == ppc_stub_plt_branch)
14141 && (r_type == R_PPC64_ADDR14_BRTAKEN
14142 || r_type == R_PPC64_ADDR14_BRNTAKEN
14143 || (relocation + addend - from + max_br_offset
14144 < 2 * max_br_offset)))
14145 /* Don't use the stub if this branch is in range. */
14148 if (stub_entry != NULL)
14150 /* Munge up the value and addend so that we call the stub
14151 rather than the procedure directly. */
14152 asection *stub_sec = stub_entry->group->stub_sec;
14154 if (stub_entry->stub_type == ppc_stub_save_res)
14155 relocation += (stub_sec->output_offset
14156 + stub_sec->output_section->vma
14157 + stub_sec->size - htab->sfpr->size
14158 - htab->sfpr->output_offset
14159 - htab->sfpr->output_section->vma);
14161 relocation = (stub_entry->stub_offset
14162 + stub_sec->output_offset
14163 + stub_sec->output_section->vma);
14165 reloc_dest = DEST_STUB;
14167 if ((stub_entry->stub_type == ppc_stub_plt_call
14168 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14169 && (ALWAYS_EMIT_R2SAVE
14170 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14171 && rel + 1 < relend
14172 && rel[1].r_offset == rel->r_offset + 4
14173 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14181 /* Set 'a' bit. This is 0b00010 in BO field for branch
14182 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14183 for branch on CTR insns (BO == 1a00t or 1a01t). */
14184 if ((insn & (0x14 << 21)) == (0x04 << 21))
14185 insn |= 0x02 << 21;
14186 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14187 insn |= 0x08 << 21;
14193 /* Invert 'y' bit if not the default. */
14194 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14195 insn ^= 0x01 << 21;
14198 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14201 /* NOP out calls to undefined weak functions.
14202 We can thus call a weak function without first
14203 checking whether the function is defined. */
14205 && h->elf.root.type == bfd_link_hash_undefweak
14206 && h->elf.dynindx == -1
14207 && r_type == R_PPC64_REL24
14211 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14217 /* Set `addend'. */
14222 info->callbacks->einfo
14223 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14224 input_bfd, (int) r_type, sym_name);
14226 bfd_set_error (bfd_error_bad_value);
14232 case R_PPC64_TLSGD:
14233 case R_PPC64_TLSLD:
14234 case R_PPC64_TOCSAVE:
14235 case R_PPC64_GNU_VTINHERIT:
14236 case R_PPC64_GNU_VTENTRY:
14237 case R_PPC64_ENTRY:
14240 /* GOT16 relocations. Like an ADDR16 using the symbol's
14241 address in the GOT as relocation value instead of the
14242 symbol's value itself. Also, create a GOT entry for the
14243 symbol and put the symbol value there. */
14244 case R_PPC64_GOT_TLSGD16:
14245 case R_PPC64_GOT_TLSGD16_LO:
14246 case R_PPC64_GOT_TLSGD16_HI:
14247 case R_PPC64_GOT_TLSGD16_HA:
14248 tls_type = TLS_TLS | TLS_GD;
14251 case R_PPC64_GOT_TLSLD16:
14252 case R_PPC64_GOT_TLSLD16_LO:
14253 case R_PPC64_GOT_TLSLD16_HI:
14254 case R_PPC64_GOT_TLSLD16_HA:
14255 tls_type = TLS_TLS | TLS_LD;
14258 case R_PPC64_GOT_TPREL16_DS:
14259 case R_PPC64_GOT_TPREL16_LO_DS:
14260 case R_PPC64_GOT_TPREL16_HI:
14261 case R_PPC64_GOT_TPREL16_HA:
14262 tls_type = TLS_TLS | TLS_TPREL;
14265 case R_PPC64_GOT_DTPREL16_DS:
14266 case R_PPC64_GOT_DTPREL16_LO_DS:
14267 case R_PPC64_GOT_DTPREL16_HI:
14268 case R_PPC64_GOT_DTPREL16_HA:
14269 tls_type = TLS_TLS | TLS_DTPREL;
14272 case R_PPC64_GOT16:
14273 case R_PPC64_GOT16_LO:
14274 case R_PPC64_GOT16_HI:
14275 case R_PPC64_GOT16_HA:
14276 case R_PPC64_GOT16_DS:
14277 case R_PPC64_GOT16_LO_DS:
14280 /* Relocation is to the entry for this symbol in the global
14285 unsigned long indx = 0;
14286 struct got_entry *ent;
14288 if (tls_type == (TLS_TLS | TLS_LD)
14290 || !h->elf.def_dynamic))
14291 ent = ppc64_tlsld_got (input_bfd);
14297 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14298 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14300 || (bfd_link_pic (info)
14301 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14302 /* This is actually a static link, or it is a
14303 -Bsymbolic link and the symbol is defined
14304 locally, or the symbol was forced to be local
14305 because of a version file. */
14309 BFD_ASSERT (h->elf.dynindx != -1);
14310 indx = h->elf.dynindx;
14311 unresolved_reloc = FALSE;
14313 ent = h->elf.got.glist;
14317 if (local_got_ents == NULL)
14319 ent = local_got_ents[r_symndx];
14322 for (; ent != NULL; ent = ent->next)
14323 if (ent->addend == orig_rel.r_addend
14324 && ent->owner == input_bfd
14325 && ent->tls_type == tls_type)
14331 if (ent->is_indirect)
14332 ent = ent->got.ent;
14333 offp = &ent->got.offset;
14334 got = ppc64_elf_tdata (ent->owner)->got;
14338 /* The offset must always be a multiple of 8. We use the
14339 least significant bit to record whether we have already
14340 processed this entry. */
14342 if ((off & 1) != 0)
14346 /* Generate relocs for the dynamic linker, except in
14347 the case of TLSLD where we'll use one entry per
14355 ? h->elf.type == STT_GNU_IFUNC
14356 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14358 relgot = htab->elf.irelplt;
14359 else if ((bfd_link_pic (info) || indx != 0)
14361 || (tls_type == (TLS_TLS | TLS_LD)
14362 && !h->elf.def_dynamic)
14363 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14364 || h->elf.root.type != bfd_link_hash_undefweak))
14365 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14366 if (relgot != NULL)
14368 outrel.r_offset = (got->output_section->vma
14369 + got->output_offset
14371 outrel.r_addend = addend;
14372 if (tls_type & (TLS_LD | TLS_GD))
14374 outrel.r_addend = 0;
14375 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14376 if (tls_type == (TLS_TLS | TLS_GD))
14378 loc = relgot->contents;
14379 loc += (relgot->reloc_count++
14380 * sizeof (Elf64_External_Rela));
14381 bfd_elf64_swap_reloca_out (output_bfd,
14383 outrel.r_offset += 8;
14384 outrel.r_addend = addend;
14386 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14389 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14390 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14391 else if (tls_type == (TLS_TLS | TLS_TPREL))
14392 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14393 else if (indx != 0)
14394 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14398 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14400 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14402 /* Write the .got section contents for the sake
14404 loc = got->contents + off;
14405 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14409 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14411 outrel.r_addend += relocation;
14412 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14414 if (htab->elf.tls_sec == NULL)
14415 outrel.r_addend = 0;
14417 outrel.r_addend -= htab->elf.tls_sec->vma;
14420 loc = relgot->contents;
14421 loc += (relgot->reloc_count++
14422 * sizeof (Elf64_External_Rela));
14423 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14426 /* Init the .got section contents here if we're not
14427 emitting a reloc. */
14430 relocation += addend;
14431 if (tls_type == (TLS_TLS | TLS_LD))
14433 else if (tls_type != 0)
14435 if (htab->elf.tls_sec == NULL)
14439 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14440 if (tls_type == (TLS_TLS | TLS_TPREL))
14441 relocation += DTP_OFFSET - TP_OFFSET;
14444 if (tls_type == (TLS_TLS | TLS_GD))
14446 bfd_put_64 (output_bfd, relocation,
14447 got->contents + off + 8);
14452 bfd_put_64 (output_bfd, relocation,
14453 got->contents + off);
14457 if (off >= (bfd_vma) -2)
14460 relocation = got->output_section->vma + got->output_offset + off;
14461 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14465 case R_PPC64_PLT16_HA:
14466 case R_PPC64_PLT16_HI:
14467 case R_PPC64_PLT16_LO:
14468 case R_PPC64_PLT32:
14469 case R_PPC64_PLT64:
14470 /* Relocation is to the entry for this symbol in the
14471 procedure linkage table. */
14473 struct plt_entry **plt_list = NULL;
14475 plt_list = &h->elf.plt.plist;
14476 else if (local_got_ents != NULL)
14478 struct plt_entry **local_plt = (struct plt_entry **)
14479 (local_got_ents + symtab_hdr->sh_info);
14480 unsigned char *local_got_tls_masks = (unsigned char *)
14481 (local_plt + symtab_hdr->sh_info);
14482 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14483 plt_list = local_plt + r_symndx;
14487 struct plt_entry *ent;
14489 for (ent = *plt_list; ent != NULL; ent = ent->next)
14490 if (ent->plt.offset != (bfd_vma) -1
14491 && ent->addend == orig_rel.r_addend)
14495 plt = htab->elf.splt;
14496 if (!htab->elf.dynamic_sections_created
14498 || h->elf.dynindx == -1)
14499 plt = htab->elf.iplt;
14500 relocation = (plt->output_section->vma
14501 + plt->output_offset
14502 + ent->plt.offset);
14504 unresolved_reloc = FALSE;
14512 /* Relocation value is TOC base. */
14513 relocation = TOCstart;
14514 if (r_symndx == STN_UNDEF)
14515 relocation += htab->sec_info[input_section->id].toc_off;
14516 else if (unresolved_reloc)
14518 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14519 relocation += htab->sec_info[sec->id].toc_off;
14521 unresolved_reloc = TRUE;
14524 /* TOC16 relocs. We want the offset relative to the TOC base,
14525 which is the address of the start of the TOC plus 0x8000.
14526 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14528 case R_PPC64_TOC16:
14529 case R_PPC64_TOC16_LO:
14530 case R_PPC64_TOC16_HI:
14531 case R_PPC64_TOC16_DS:
14532 case R_PPC64_TOC16_LO_DS:
14533 case R_PPC64_TOC16_HA:
14534 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14537 /* Relocate against the beginning of the section. */
14538 case R_PPC64_SECTOFF:
14539 case R_PPC64_SECTOFF_LO:
14540 case R_PPC64_SECTOFF_HI:
14541 case R_PPC64_SECTOFF_DS:
14542 case R_PPC64_SECTOFF_LO_DS:
14543 case R_PPC64_SECTOFF_HA:
14545 addend -= sec->output_section->vma;
14548 case R_PPC64_REL16:
14549 case R_PPC64_REL16_LO:
14550 case R_PPC64_REL16_HI:
14551 case R_PPC64_REL16_HA:
14552 case R_PPC64_REL16DX_HA:
14555 case R_PPC64_REL14:
14556 case R_PPC64_REL14_BRNTAKEN:
14557 case R_PPC64_REL14_BRTAKEN:
14558 case R_PPC64_REL24:
14561 case R_PPC64_TPREL16:
14562 case R_PPC64_TPREL16_LO:
14563 case R_PPC64_TPREL16_HI:
14564 case R_PPC64_TPREL16_HA:
14565 case R_PPC64_TPREL16_DS:
14566 case R_PPC64_TPREL16_LO_DS:
14567 case R_PPC64_TPREL16_HIGH:
14568 case R_PPC64_TPREL16_HIGHA:
14569 case R_PPC64_TPREL16_HIGHER:
14570 case R_PPC64_TPREL16_HIGHERA:
14571 case R_PPC64_TPREL16_HIGHEST:
14572 case R_PPC64_TPREL16_HIGHESTA:
14574 && h->elf.root.type == bfd_link_hash_undefweak
14575 && h->elf.dynindx == -1)
14577 /* Make this relocation against an undefined weak symbol
14578 resolve to zero. This is really just a tweak, since
14579 code using weak externs ought to check that they are
14580 defined before using them. */
14581 bfd_byte *p = contents + rel->r_offset - d_offset;
14583 insn = bfd_get_32 (output_bfd, p);
14584 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14586 bfd_put_32 (output_bfd, insn, p);
14589 if (htab->elf.tls_sec != NULL)
14590 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14591 if (bfd_link_pic (info))
14592 /* The TPREL16 relocs shouldn't really be used in shared
14593 libs as they will result in DT_TEXTREL being set, but
14594 support them anyway. */
14598 case R_PPC64_DTPREL16:
14599 case R_PPC64_DTPREL16_LO:
14600 case R_PPC64_DTPREL16_HI:
14601 case R_PPC64_DTPREL16_HA:
14602 case R_PPC64_DTPREL16_DS:
14603 case R_PPC64_DTPREL16_LO_DS:
14604 case R_PPC64_DTPREL16_HIGH:
14605 case R_PPC64_DTPREL16_HIGHA:
14606 case R_PPC64_DTPREL16_HIGHER:
14607 case R_PPC64_DTPREL16_HIGHERA:
14608 case R_PPC64_DTPREL16_HIGHEST:
14609 case R_PPC64_DTPREL16_HIGHESTA:
14610 if (htab->elf.tls_sec != NULL)
14611 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14614 case R_PPC64_ADDR64_LOCAL:
14615 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14620 case R_PPC64_DTPMOD64:
14625 case R_PPC64_TPREL64:
14626 if (htab->elf.tls_sec != NULL)
14627 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14630 case R_PPC64_DTPREL64:
14631 if (htab->elf.tls_sec != NULL)
14632 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14635 /* Relocations that may need to be propagated if this is a
14637 case R_PPC64_REL30:
14638 case R_PPC64_REL32:
14639 case R_PPC64_REL64:
14640 case R_PPC64_ADDR14:
14641 case R_PPC64_ADDR14_BRNTAKEN:
14642 case R_PPC64_ADDR14_BRTAKEN:
14643 case R_PPC64_ADDR16:
14644 case R_PPC64_ADDR16_DS:
14645 case R_PPC64_ADDR16_HA:
14646 case R_PPC64_ADDR16_HI:
14647 case R_PPC64_ADDR16_HIGH:
14648 case R_PPC64_ADDR16_HIGHA:
14649 case R_PPC64_ADDR16_HIGHER:
14650 case R_PPC64_ADDR16_HIGHERA:
14651 case R_PPC64_ADDR16_HIGHEST:
14652 case R_PPC64_ADDR16_HIGHESTA:
14653 case R_PPC64_ADDR16_LO:
14654 case R_PPC64_ADDR16_LO_DS:
14655 case R_PPC64_ADDR24:
14656 case R_PPC64_ADDR32:
14657 case R_PPC64_ADDR64:
14658 case R_PPC64_UADDR16:
14659 case R_PPC64_UADDR32:
14660 case R_PPC64_UADDR64:
14662 if ((input_section->flags & SEC_ALLOC) == 0)
14665 if (NO_OPD_RELOCS && is_opd)
14668 if ((bfd_link_pic (info)
14670 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14671 || h->elf.root.type != bfd_link_hash_undefweak)
14672 && (must_be_dyn_reloc (info, r_type)
14673 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14674 || (ELIMINATE_COPY_RELOCS
14675 && !bfd_link_pic (info)
14677 && h->elf.dynindx != -1
14678 && !h->elf.non_got_ref
14679 && !h->elf.def_regular)
14680 || (!bfd_link_pic (info)
14682 ? h->elf.type == STT_GNU_IFUNC
14683 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14685 bfd_boolean skip, relocate;
14689 /* When generating a dynamic object, these relocations
14690 are copied into the output file to be resolved at run
14696 out_off = _bfd_elf_section_offset (output_bfd, info,
14697 input_section, rel->r_offset);
14698 if (out_off == (bfd_vma) -1)
14700 else if (out_off == (bfd_vma) -2)
14701 skip = TRUE, relocate = TRUE;
14702 out_off += (input_section->output_section->vma
14703 + input_section->output_offset);
14704 outrel.r_offset = out_off;
14705 outrel.r_addend = rel->r_addend;
14707 /* Optimize unaligned reloc use. */
14708 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14709 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14710 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14711 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14712 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14713 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14714 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14715 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14716 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14719 memset (&outrel, 0, sizeof outrel);
14720 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14722 && r_type != R_PPC64_TOC)
14724 BFD_ASSERT (h->elf.dynindx != -1);
14725 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14729 /* This symbol is local, or marked to become local,
14730 or this is an opd section reloc which must point
14731 at a local function. */
14732 outrel.r_addend += relocation;
14733 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14735 if (is_opd && h != NULL)
14737 /* Lie about opd entries. This case occurs
14738 when building shared libraries and we
14739 reference a function in another shared
14740 lib. The same thing happens for a weak
14741 definition in an application that's
14742 overridden by a strong definition in a
14743 shared lib. (I believe this is a generic
14744 bug in binutils handling of weak syms.)
14745 In these cases we won't use the opd
14746 entry in this lib. */
14747 unresolved_reloc = FALSE;
14750 && r_type == R_PPC64_ADDR64
14752 ? h->elf.type == STT_GNU_IFUNC
14753 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14754 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14757 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14759 /* We need to relocate .opd contents for ld.so.
14760 Prelink also wants simple and consistent rules
14761 for relocs. This make all RELATIVE relocs have
14762 *r_offset equal to r_addend. */
14771 ? h->elf.type == STT_GNU_IFUNC
14772 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14774 info->callbacks->einfo
14775 (_("%P: %H: %s for indirect "
14776 "function `%T' unsupported\n"),
14777 input_bfd, input_section, rel->r_offset,
14778 ppc64_elf_howto_table[r_type]->name,
14782 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14784 else if (sec == NULL || sec->owner == NULL)
14786 bfd_set_error (bfd_error_bad_value);
14793 osec = sec->output_section;
14794 indx = elf_section_data (osec)->dynindx;
14798 if ((osec->flags & SEC_READONLY) == 0
14799 && htab->elf.data_index_section != NULL)
14800 osec = htab->elf.data_index_section;
14802 osec = htab->elf.text_index_section;
14803 indx = elf_section_data (osec)->dynindx;
14805 BFD_ASSERT (indx != 0);
14807 /* We are turning this relocation into one
14808 against a section symbol, so subtract out
14809 the output section's address but not the
14810 offset of the input section in the output
14812 outrel.r_addend -= osec->vma;
14815 outrel.r_info = ELF64_R_INFO (indx, r_type);
14819 sreloc = elf_section_data (input_section)->sreloc;
14821 ? h->elf.type == STT_GNU_IFUNC
14822 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14823 sreloc = htab->elf.irelplt;
14824 if (sreloc == NULL)
14827 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14830 loc = sreloc->contents;
14831 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14832 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14834 /* If this reloc is against an external symbol, it will
14835 be computed at runtime, so there's no need to do
14836 anything now. However, for the sake of prelink ensure
14837 that the section contents are a known value. */
14840 unresolved_reloc = FALSE;
14841 /* The value chosen here is quite arbitrary as ld.so
14842 ignores section contents except for the special
14843 case of .opd where the contents might be accessed
14844 before relocation. Choose zero, as that won't
14845 cause reloc overflow. */
14848 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14849 to improve backward compatibility with older
14851 if (r_type == R_PPC64_ADDR64)
14852 addend = outrel.r_addend;
14853 /* Adjust pc_relative relocs to have zero in *r_offset. */
14854 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14855 addend = (input_section->output_section->vma
14856 + input_section->output_offset
14863 case R_PPC64_GLOB_DAT:
14864 case R_PPC64_JMP_SLOT:
14865 case R_PPC64_JMP_IREL:
14866 case R_PPC64_RELATIVE:
14867 /* We shouldn't ever see these dynamic relocs in relocatable
14869 /* Fall through. */
14871 case R_PPC64_PLTGOT16:
14872 case R_PPC64_PLTGOT16_DS:
14873 case R_PPC64_PLTGOT16_HA:
14874 case R_PPC64_PLTGOT16_HI:
14875 case R_PPC64_PLTGOT16_LO:
14876 case R_PPC64_PLTGOT16_LO_DS:
14877 case R_PPC64_PLTREL32:
14878 case R_PPC64_PLTREL64:
14879 /* These ones haven't been implemented yet. */
14881 info->callbacks->einfo
14882 (_("%P: %B: %s is not supported for `%T'\n"),
14884 ppc64_elf_howto_table[r_type]->name, sym_name);
14886 bfd_set_error (bfd_error_invalid_operation);
14891 /* Multi-instruction sequences that access the TOC can be
14892 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14893 to nop; addi rb,r2,x; */
14899 case R_PPC64_GOT_TLSLD16_HI:
14900 case R_PPC64_GOT_TLSGD16_HI:
14901 case R_PPC64_GOT_TPREL16_HI:
14902 case R_PPC64_GOT_DTPREL16_HI:
14903 case R_PPC64_GOT16_HI:
14904 case R_PPC64_TOC16_HI:
14905 /* These relocs would only be useful if building up an
14906 offset to later add to r2, perhaps in an indexed
14907 addressing mode instruction. Don't try to optimize.
14908 Unfortunately, the possibility of someone building up an
14909 offset like this or even with the HA relocs, means that
14910 we need to check the high insn when optimizing the low
14914 case R_PPC64_GOT_TLSLD16_HA:
14915 case R_PPC64_GOT_TLSGD16_HA:
14916 case R_PPC64_GOT_TPREL16_HA:
14917 case R_PPC64_GOT_DTPREL16_HA:
14918 case R_PPC64_GOT16_HA:
14919 case R_PPC64_TOC16_HA:
14920 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14921 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14923 bfd_byte *p = contents + (rel->r_offset & ~3);
14924 bfd_put_32 (input_bfd, NOP, p);
14928 case R_PPC64_GOT_TLSLD16_LO:
14929 case R_PPC64_GOT_TLSGD16_LO:
14930 case R_PPC64_GOT_TPREL16_LO_DS:
14931 case R_PPC64_GOT_DTPREL16_LO_DS:
14932 case R_PPC64_GOT16_LO:
14933 case R_PPC64_GOT16_LO_DS:
14934 case R_PPC64_TOC16_LO:
14935 case R_PPC64_TOC16_LO_DS:
14936 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14937 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14939 bfd_byte *p = contents + (rel->r_offset & ~3);
14940 insn = bfd_get_32 (input_bfd, p);
14941 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14943 /* Transform addic to addi when we change reg. */
14944 insn &= ~((0x3f << 26) | (0x1f << 16));
14945 insn |= (14u << 26) | (2 << 16);
14949 insn &= ~(0x1f << 16);
14952 bfd_put_32 (input_bfd, insn, p);
14957 /* Do any further special processing. */
14958 howto = ppc64_elf_howto_table[(int) r_type];
14964 case R_PPC64_REL16_HA:
14965 case R_PPC64_REL16DX_HA:
14966 case R_PPC64_ADDR16_HA:
14967 case R_PPC64_ADDR16_HIGHA:
14968 case R_PPC64_ADDR16_HIGHERA:
14969 case R_PPC64_ADDR16_HIGHESTA:
14970 case R_PPC64_TOC16_HA:
14971 case R_PPC64_SECTOFF_HA:
14972 case R_PPC64_TPREL16_HA:
14973 case R_PPC64_TPREL16_HIGHA:
14974 case R_PPC64_TPREL16_HIGHERA:
14975 case R_PPC64_TPREL16_HIGHESTA:
14976 case R_PPC64_DTPREL16_HA:
14977 case R_PPC64_DTPREL16_HIGHA:
14978 case R_PPC64_DTPREL16_HIGHERA:
14979 case R_PPC64_DTPREL16_HIGHESTA:
14980 /* It's just possible that this symbol is a weak symbol
14981 that's not actually defined anywhere. In that case,
14982 'sec' would be NULL, and we should leave the symbol
14983 alone (it will be set to zero elsewhere in the link). */
14988 case R_PPC64_GOT16_HA:
14989 case R_PPC64_PLTGOT16_HA:
14990 case R_PPC64_PLT16_HA:
14991 case R_PPC64_GOT_TLSGD16_HA:
14992 case R_PPC64_GOT_TLSLD16_HA:
14993 case R_PPC64_GOT_TPREL16_HA:
14994 case R_PPC64_GOT_DTPREL16_HA:
14995 /* Add 0x10000 if sign bit in 0:15 is set.
14996 Bits 0:15 are not used. */
15000 case R_PPC64_ADDR16_DS:
15001 case R_PPC64_ADDR16_LO_DS:
15002 case R_PPC64_GOT16_DS:
15003 case R_PPC64_GOT16_LO_DS:
15004 case R_PPC64_PLT16_LO_DS:
15005 case R_PPC64_SECTOFF_DS:
15006 case R_PPC64_SECTOFF_LO_DS:
15007 case R_PPC64_TOC16_DS:
15008 case R_PPC64_TOC16_LO_DS:
15009 case R_PPC64_PLTGOT16_DS:
15010 case R_PPC64_PLTGOT16_LO_DS:
15011 case R_PPC64_GOT_TPREL16_DS:
15012 case R_PPC64_GOT_TPREL16_LO_DS:
15013 case R_PPC64_GOT_DTPREL16_DS:
15014 case R_PPC64_GOT_DTPREL16_LO_DS:
15015 case R_PPC64_TPREL16_DS:
15016 case R_PPC64_TPREL16_LO_DS:
15017 case R_PPC64_DTPREL16_DS:
15018 case R_PPC64_DTPREL16_LO_DS:
15019 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15021 /* If this reloc is against an lq, lxv, or stxv insn, then
15022 the value must be a multiple of 16. This is somewhat of
15023 a hack, but the "correct" way to do this by defining _DQ
15024 forms of all the _DS relocs bloats all reloc switches in
15025 this file. It doesn't make much sense to use these
15026 relocs in data, so testing the insn should be safe. */
15027 if ((insn & (0x3f << 26)) == (56u << 26)
15028 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15030 relocation += addend;
15031 addend = insn & (mask ^ 3);
15032 if ((relocation & mask) != 0)
15034 relocation ^= relocation & mask;
15035 info->callbacks->einfo
15036 (_("%P: %H: error: %s not a multiple of %u\n"),
15037 input_bfd, input_section, rel->r_offset,
15040 bfd_set_error (bfd_error_bad_value);
15047 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15048 because such sections are not SEC_ALLOC and thus ld.so will
15049 not process them. */
15050 if (unresolved_reloc
15051 && !((input_section->flags & SEC_DEBUGGING) != 0
15052 && h->elf.def_dynamic)
15053 && _bfd_elf_section_offset (output_bfd, info, input_section,
15054 rel->r_offset) != (bfd_vma) -1)
15056 info->callbacks->einfo
15057 (_("%P: %H: unresolvable %s against `%T'\n"),
15058 input_bfd, input_section, rel->r_offset,
15060 h->elf.root.root.string);
15064 /* 16-bit fields in insns mostly have signed values, but a
15065 few insns have 16-bit unsigned values. Really, we should
15066 have different reloc types. */
15067 if (howto->complain_on_overflow != complain_overflow_dont
15068 && howto->dst_mask == 0xffff
15069 && (input_section->flags & SEC_CODE) != 0)
15071 enum complain_overflow complain = complain_overflow_signed;
15073 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15074 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15075 complain = complain_overflow_bitfield;
15076 else if (howto->rightshift == 0
15077 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15078 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15079 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15080 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15081 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15082 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15083 complain = complain_overflow_unsigned;
15084 if (howto->complain_on_overflow != complain)
15086 alt_howto = *howto;
15087 alt_howto.complain_on_overflow = complain;
15088 howto = &alt_howto;
15092 if (r_type == R_PPC64_REL16DX_HA)
15094 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15095 if (rel->r_offset + 4 > input_section->size)
15096 r = bfd_reloc_outofrange;
15099 relocation += addend;
15100 relocation -= (rel->r_offset
15101 + input_section->output_offset
15102 + input_section->output_section->vma);
15103 relocation = (bfd_signed_vma) relocation >> 16;
15104 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15106 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15107 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15109 if (relocation + 0x8000 > 0xffff)
15110 r = bfd_reloc_overflow;
15114 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15115 rel->r_offset, relocation, addend);
15117 if (r != bfd_reloc_ok)
15119 char *more_info = NULL;
15120 const char *reloc_name = howto->name;
15122 if (reloc_dest != DEST_NORMAL)
15124 more_info = bfd_malloc (strlen (reloc_name) + 8);
15125 if (more_info != NULL)
15127 strcpy (more_info, reloc_name);
15128 strcat (more_info, (reloc_dest == DEST_OPD
15129 ? " (OPD)" : " (stub)"));
15130 reloc_name = more_info;
15134 if (r == bfd_reloc_overflow)
15136 /* On code like "if (foo) foo();" don't report overflow
15137 on a branch to zero when foo is undefined. */
15139 && (reloc_dest == DEST_STUB
15141 && (h->elf.root.type == bfd_link_hash_undefweak
15142 || h->elf.root.type == bfd_link_hash_undefined)
15143 && is_branch_reloc (r_type))))
15145 if (!((*info->callbacks->reloc_overflow)
15146 (info, &h->elf.root, sym_name,
15147 reloc_name, orig_rel.r_addend,
15148 input_bfd, input_section, rel->r_offset)))
15154 info->callbacks->einfo
15155 (_("%P: %H: %s against `%T': error %d\n"),
15156 input_bfd, input_section, rel->r_offset,
15157 reloc_name, sym_name, (int) r);
15160 if (more_info != NULL)
15170 Elf_Internal_Shdr *rel_hdr;
15171 size_t deleted = rel - wrel;
15173 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15174 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15175 if (rel_hdr->sh_size == 0)
15177 /* It is too late to remove an empty reloc section. Leave
15179 ??? What is wrong with an empty section??? */
15180 rel_hdr->sh_size = rel_hdr->sh_entsize;
15183 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15184 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15185 input_section->reloc_count -= deleted;
15188 /* If we're emitting relocations, then shortly after this function
15189 returns, reloc offsets and addends for this section will be
15190 adjusted. Worse, reloc symbol indices will be for the output
15191 file rather than the input. Save a copy of the relocs for
15192 opd_entry_value. */
15193 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15196 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15197 rel = bfd_alloc (input_bfd, amt);
15198 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15199 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15202 memcpy (rel, relocs, amt);
15207 /* Adjust the value of any local symbols in opd sections. */
15210 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15211 const char *name ATTRIBUTE_UNUSED,
15212 Elf_Internal_Sym *elfsym,
15213 asection *input_sec,
15214 struct elf_link_hash_entry *h)
15216 struct _opd_sec_data *opd;
15223 opd = get_opd_info (input_sec);
15224 if (opd == NULL || opd->adjust == NULL)
15227 value = elfsym->st_value - input_sec->output_offset;
15228 if (!bfd_link_relocatable (info))
15229 value -= input_sec->output_section->vma;
15231 adjust = opd->adjust[OPD_NDX (value)];
15235 elfsym->st_value += adjust;
15239 /* Finish up dynamic symbol handling. We set the contents of various
15240 dynamic sections here. */
15243 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15244 struct bfd_link_info *info,
15245 struct elf_link_hash_entry *h,
15246 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15248 struct ppc_link_hash_table *htab;
15249 struct plt_entry *ent;
15250 Elf_Internal_Rela rela;
15253 htab = ppc_hash_table (info);
15257 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15258 if (ent->plt.offset != (bfd_vma) -1)
15260 /* This symbol has an entry in the procedure linkage
15261 table. Set it up. */
15262 if (!htab->elf.dynamic_sections_created
15263 || h->dynindx == -1)
15265 BFD_ASSERT (h->type == STT_GNU_IFUNC
15267 && (h->root.type == bfd_link_hash_defined
15268 || h->root.type == bfd_link_hash_defweak));
15269 rela.r_offset = (htab->elf.iplt->output_section->vma
15270 + htab->elf.iplt->output_offset
15271 + ent->plt.offset);
15273 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15275 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15276 rela.r_addend = (h->root.u.def.value
15277 + h->root.u.def.section->output_offset
15278 + h->root.u.def.section->output_section->vma
15280 loc = (htab->elf.irelplt->contents
15281 + (htab->elf.irelplt->reloc_count++
15282 * sizeof (Elf64_External_Rela)));
15286 rela.r_offset = (htab->elf.splt->output_section->vma
15287 + htab->elf.splt->output_offset
15288 + ent->plt.offset);
15289 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15290 rela.r_addend = ent->addend;
15291 loc = (htab->elf.srelplt->contents
15292 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15293 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15295 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15297 if (!htab->opd_abi)
15299 if (!h->def_regular)
15301 /* Mark the symbol as undefined, rather than as
15302 defined in glink. Leave the value if there were
15303 any relocations where pointer equality matters
15304 (this is a clue for the dynamic linker, to make
15305 function pointer comparisons work between an
15306 application and shared library), otherwise set it
15308 sym->st_shndx = SHN_UNDEF;
15309 if (!h->pointer_equality_needed)
15311 else if (!h->ref_regular_nonweak)
15313 /* This breaks function pointer comparisons, but
15314 that is better than breaking tests for a NULL
15315 function pointer. */
15324 /* This symbol needs a copy reloc. Set it up. */
15326 if (h->dynindx == -1
15327 || (h->root.type != bfd_link_hash_defined
15328 && h->root.type != bfd_link_hash_defweak)
15329 || htab->relbss == NULL)
15332 rela.r_offset = (h->root.u.def.value
15333 + h->root.u.def.section->output_section->vma
15334 + h->root.u.def.section->output_offset);
15335 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15337 loc = htab->relbss->contents;
15338 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15339 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15345 /* Used to decide how to sort relocs in an optimal manner for the
15346 dynamic linker, before writing them out. */
15348 static enum elf_reloc_type_class
15349 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15350 const asection *rel_sec,
15351 const Elf_Internal_Rela *rela)
15353 enum elf_ppc64_reloc_type r_type;
15354 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15356 if (rel_sec == htab->elf.irelplt)
15357 return reloc_class_ifunc;
15359 r_type = ELF64_R_TYPE (rela->r_info);
15362 case R_PPC64_RELATIVE:
15363 return reloc_class_relative;
15364 case R_PPC64_JMP_SLOT:
15365 return reloc_class_plt;
15367 return reloc_class_copy;
15369 return reloc_class_normal;
15373 /* Finish up the dynamic sections. */
15376 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15377 struct bfd_link_info *info)
15379 struct ppc_link_hash_table *htab;
15383 htab = ppc_hash_table (info);
15387 dynobj = htab->elf.dynobj;
15388 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15390 if (htab->elf.dynamic_sections_created)
15392 Elf64_External_Dyn *dyncon, *dynconend;
15394 if (sdyn == NULL || htab->elf.sgot == NULL)
15397 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15398 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15399 for (; dyncon < dynconend; dyncon++)
15401 Elf_Internal_Dyn dyn;
15404 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15411 case DT_PPC64_GLINK:
15413 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15414 /* We stupidly defined DT_PPC64_GLINK to be the start
15415 of glink rather than the first entry point, which is
15416 what ld.so needs, and now have a bigger stub to
15417 support automatic multiple TOCs. */
15418 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15422 s = bfd_get_section_by_name (output_bfd, ".opd");
15425 dyn.d_un.d_ptr = s->vma;
15429 if (htab->do_multi_toc && htab->multi_toc_needed)
15430 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15433 case DT_PPC64_OPDSZ:
15434 s = bfd_get_section_by_name (output_bfd, ".opd");
15437 dyn.d_un.d_val = s->size;
15441 s = htab->elf.splt;
15442 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15446 s = htab->elf.srelplt;
15447 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15451 dyn.d_un.d_val = htab->elf.srelplt->size;
15455 /* Don't count procedure linkage table relocs in the
15456 overall reloc count. */
15457 s = htab->elf.srelplt;
15460 dyn.d_un.d_val -= s->size;
15464 /* We may not be using the standard ELF linker script.
15465 If .rela.plt is the first .rela section, we adjust
15466 DT_RELA to not include it. */
15467 s = htab->elf.srelplt;
15470 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15472 dyn.d_un.d_ptr += s->size;
15476 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15480 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15482 /* Fill in the first entry in the global offset table.
15483 We use it to hold the link-time TOCbase. */
15484 bfd_put_64 (output_bfd,
15485 elf_gp (output_bfd) + TOC_BASE_OFF,
15486 htab->elf.sgot->contents);
15488 /* Set .got entry size. */
15489 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15492 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15494 /* Set .plt entry size. */
15495 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15496 = PLT_ENTRY_SIZE (htab);
15499 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15500 brlt ourselves if emitrelocations. */
15501 if (htab->brlt != NULL
15502 && htab->brlt->reloc_count != 0
15503 && !_bfd_elf_link_output_relocs (output_bfd,
15505 elf_section_data (htab->brlt)->rela.hdr,
15506 elf_section_data (htab->brlt)->relocs,
15510 if (htab->glink != NULL
15511 && htab->glink->reloc_count != 0
15512 && !_bfd_elf_link_output_relocs (output_bfd,
15514 elf_section_data (htab->glink)->rela.hdr,
15515 elf_section_data (htab->glink)->relocs,
15519 if (htab->glink_eh_frame != NULL
15520 && htab->glink_eh_frame->size != 0)
15524 asection *stub_sec;
15526 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15527 for (stub_sec = htab->params->stub_bfd->sections;
15529 stub_sec = stub_sec->next)
15530 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15536 /* Offset to stub section. */
15537 val = (stub_sec->output_section->vma
15538 + stub_sec->output_offset);
15539 val -= (htab->glink_eh_frame->output_section->vma
15540 + htab->glink_eh_frame->output_offset
15541 + (p - htab->glink_eh_frame->contents));
15542 if (val + 0x80000000 > 0xffffffff)
15544 info->callbacks->einfo
15545 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15549 bfd_put_32 (dynobj, val, p);
15551 /* stub section size. */
15553 /* Augmentation. */
15558 if (htab->glink != NULL && htab->glink->size != 0)
15564 /* Offset to .glink. */
15565 val = (htab->glink->output_section->vma
15566 + htab->glink->output_offset
15568 val -= (htab->glink_eh_frame->output_section->vma
15569 + htab->glink_eh_frame->output_offset
15570 + (p - htab->glink_eh_frame->contents));
15571 if (val + 0x80000000 > 0xffffffff)
15573 info->callbacks->einfo
15574 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15575 htab->glink->name);
15578 bfd_put_32 (dynobj, val, p);
15582 /* Augmentation. */
15588 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15589 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15590 htab->glink_eh_frame,
15591 htab->glink_eh_frame->contents))
15595 /* We need to handle writing out multiple GOT sections ourselves,
15596 since we didn't add them to DYNOBJ. We know dynobj is the first
15598 while ((dynobj = dynobj->link.next) != NULL)
15602 if (!is_ppc64_elf (dynobj))
15605 s = ppc64_elf_tdata (dynobj)->got;
15608 && s->output_section != bfd_abs_section_ptr
15609 && !bfd_set_section_contents (output_bfd, s->output_section,
15610 s->contents, s->output_offset,
15613 s = ppc64_elf_tdata (dynobj)->relgot;
15616 && s->output_section != bfd_abs_section_ptr
15617 && !bfd_set_section_contents (output_bfd, s->output_section,
15618 s->contents, s->output_offset,
15626 #include "elf64-target.h"
15628 /* FreeBSD support */
15630 #undef TARGET_LITTLE_SYM
15631 #undef TARGET_LITTLE_NAME
15633 #undef TARGET_BIG_SYM
15634 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15635 #undef TARGET_BIG_NAME
15636 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15639 #define ELF_OSABI ELFOSABI_FREEBSD
15642 #define elf64_bed elf64_powerpc_fbsd_bed
15644 #include "elf64-target.h"