1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
60 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME "elf64-powerpcle"
62 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME "elf64-powerpc"
64 #define ELF_ARCH bfd_arch_powerpc
65 #define ELF_TARGET_ID PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE EM_PPC64
67 #define ELF_MAXPAGESIZE 0x10000
68 #define ELF_COMMONPAGESIZE 0x1000
69 #define elf_info_to_howto ppc64_elf_info_to_howto
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_default_execstack 0
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded ppc64_elf_action_discarded
115 #define elf_backend_relocate_section ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections ppc64_elf_special_sections
121 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
123 /* The name of the dynamic interpreter. This is put in the .interp
125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
127 /* The size in bytes of an entry in the procedure linkage table. */
128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
130 /* The initial size of the plt reserved for the dynamic linker. */
131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
133 /* Offsets to some stack save slots. */
135 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
136 /* This one is dodgy. ELFv2 does not have a linker word, so use the
137 CR save slot. Used only by optimised __tls_get_addr call stub,
138 relying on __tls_get_addr_opt not saving CR.. */
139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
141 /* TOC base pointers offset from start of TOC. */
142 #define TOC_BASE_OFF 0x8000
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) */
177 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
178 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
180 /* glink call stub instructions. We enter with the index in R0. */
181 #define GLINK_CALL_STUB_SIZE (16*4)
185 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
186 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
188 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
189 /* ld %2,(0b-1b)(%11) */
190 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
191 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
197 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
198 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
199 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
200 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
201 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
204 #define NOP 0x60000000
206 /* Some other nops. */
207 #define CROR_151515 0x4def7b82
208 #define CROR_313131 0x4ffffb82
210 /* .glink entries for the first 32k functions are two instructions. */
211 #define LI_R0_0 0x38000000 /* li %r0,0 */
212 #define B_DOT 0x48000000 /* b . */
214 /* After that, we need two instructions to load the index, followed by
216 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
217 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
219 /* Instructions used by the save and restore reg functions. */
220 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
221 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
222 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
223 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
224 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
225 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
226 #define LI_R12_0 0x39800000 /* li %r12,0 */
227 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
228 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define BLR 0x4e800020 /* blr */
232 /* Since .opd is an array of descriptors and each entry will end up
233 with identical R_PPC64_RELATIVE relocs, there is really no need to
234 propagate .opd relocs; The dynamic linker should be taught to
235 relocate .opd without reloc entries. */
236 #ifndef NO_OPD_RELOCS
237 #define NO_OPD_RELOCS 0
240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
242 /* Relocation HOWTO's. */
243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
245 static reloc_howto_type ppc64_elf_howto_raw[] = {
246 /* This reloc does nothing. */
247 HOWTO (R_PPC64_NONE, /* type */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
251 FALSE, /* pc_relative */
253 complain_overflow_dont, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_PPC64_NONE", /* name */
256 FALSE, /* partial_inplace */
259 FALSE), /* pcrel_offset */
261 /* A standard 32 bit relocation. */
262 HOWTO (R_PPC64_ADDR32, /* type */
264 2, /* size (0 = byte, 1 = short, 2 = long) */
266 FALSE, /* pc_relative */
268 complain_overflow_bitfield, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_PPC64_ADDR32", /* name */
271 FALSE, /* partial_inplace */
273 0xffffffff, /* dst_mask */
274 FALSE), /* pcrel_offset */
276 /* An absolute 26 bit branch; the lower two bits must be zero.
277 FIXME: we don't check that, we just clear them. */
278 HOWTO (R_PPC64_ADDR24, /* type */
280 2, /* size (0 = byte, 1 = short, 2 = long) */
282 FALSE, /* pc_relative */
284 complain_overflow_bitfield, /* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_PPC64_ADDR24", /* name */
287 FALSE, /* partial_inplace */
289 0x03fffffc, /* dst_mask */
290 FALSE), /* pcrel_offset */
292 /* A standard 16 bit relocation. */
293 HOWTO (R_PPC64_ADDR16, /* type */
295 1, /* size (0 = byte, 1 = short, 2 = long) */
297 FALSE, /* pc_relative */
299 complain_overflow_bitfield, /* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_PPC64_ADDR16", /* name */
302 FALSE, /* partial_inplace */
304 0xffff, /* dst_mask */
305 FALSE), /* pcrel_offset */
307 /* A 16 bit relocation without overflow. */
308 HOWTO (R_PPC64_ADDR16_LO, /* type */
310 1, /* size (0 = byte, 1 = short, 2 = long) */
312 FALSE, /* pc_relative */
314 complain_overflow_dont,/* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_PPC64_ADDR16_LO", /* name */
317 FALSE, /* partial_inplace */
319 0xffff, /* dst_mask */
320 FALSE), /* pcrel_offset */
322 /* Bits 16-31 of an address. */
323 HOWTO (R_PPC64_ADDR16_HI, /* type */
325 1, /* size (0 = byte, 1 = short, 2 = long) */
327 FALSE, /* pc_relative */
329 complain_overflow_signed, /* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_PPC64_ADDR16_HI", /* name */
332 FALSE, /* partial_inplace */
334 0xffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
337 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
338 bits, treated as a signed number, is negative. */
339 HOWTO (R_PPC64_ADDR16_HA, /* type */
341 1, /* size (0 = byte, 1 = short, 2 = long) */
343 FALSE, /* pc_relative */
345 complain_overflow_signed, /* complain_on_overflow */
346 ppc64_elf_ha_reloc, /* special_function */
347 "R_PPC64_ADDR16_HA", /* name */
348 FALSE, /* partial_inplace */
350 0xffff, /* dst_mask */
351 FALSE), /* pcrel_offset */
353 /* An absolute 16 bit branch; the lower two bits must be zero.
354 FIXME: we don't check that, we just clear them. */
355 HOWTO (R_PPC64_ADDR14, /* type */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
359 FALSE, /* pc_relative */
361 complain_overflow_bitfield, /* complain_on_overflow */
362 ppc64_elf_branch_reloc, /* special_function */
363 "R_PPC64_ADDR14", /* name */
364 FALSE, /* partial_inplace */
366 0x0000fffc, /* dst_mask */
367 FALSE), /* pcrel_offset */
369 /* An absolute 16 bit branch, for which bit 10 should be set to
370 indicate that the branch is expected to be taken. The lower two
371 bits must be zero. */
372 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
376 FALSE, /* pc_relative */
378 complain_overflow_bitfield, /* complain_on_overflow */
379 ppc64_elf_brtaken_reloc, /* special_function */
380 "R_PPC64_ADDR14_BRTAKEN",/* name */
381 FALSE, /* partial_inplace */
383 0x0000fffc, /* dst_mask */
384 FALSE), /* pcrel_offset */
386 /* An absolute 16 bit branch, for which bit 10 should be set to
387 indicate that the branch is not expected to be taken. The lower
388 two bits must be zero. */
389 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
391 2, /* size (0 = byte, 1 = short, 2 = long) */
393 FALSE, /* pc_relative */
395 complain_overflow_bitfield, /* complain_on_overflow */
396 ppc64_elf_brtaken_reloc, /* special_function */
397 "R_PPC64_ADDR14_BRNTAKEN",/* name */
398 FALSE, /* partial_inplace */
400 0x0000fffc, /* dst_mask */
401 FALSE), /* pcrel_offset */
403 /* A relative 26 bit branch; the lower two bits must be zero. */
404 HOWTO (R_PPC64_REL24, /* type */
406 2, /* size (0 = byte, 1 = short, 2 = long) */
408 TRUE, /* pc_relative */
410 complain_overflow_signed, /* complain_on_overflow */
411 ppc64_elf_branch_reloc, /* special_function */
412 "R_PPC64_REL24", /* name */
413 FALSE, /* partial_inplace */
415 0x03fffffc, /* dst_mask */
416 TRUE), /* pcrel_offset */
418 /* A relative 16 bit branch; the lower two bits must be zero. */
419 HOWTO (R_PPC64_REL14, /* type */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
423 TRUE, /* pc_relative */
425 complain_overflow_signed, /* complain_on_overflow */
426 ppc64_elf_branch_reloc, /* special_function */
427 "R_PPC64_REL14", /* name */
428 FALSE, /* partial_inplace */
430 0x0000fffc, /* dst_mask */
431 TRUE), /* pcrel_offset */
433 /* A relative 16 bit branch. Bit 10 should be set to indicate that
434 the branch is expected to be taken. The lower two bits must be
436 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
440 TRUE, /* pc_relative */
442 complain_overflow_signed, /* complain_on_overflow */
443 ppc64_elf_brtaken_reloc, /* special_function */
444 "R_PPC64_REL14_BRTAKEN", /* name */
445 FALSE, /* partial_inplace */
447 0x0000fffc, /* dst_mask */
448 TRUE), /* pcrel_offset */
450 /* A relative 16 bit branch. Bit 10 should be set to indicate that
451 the branch is not expected to be taken. The lower two bits must
453 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
457 TRUE, /* pc_relative */
459 complain_overflow_signed, /* complain_on_overflow */
460 ppc64_elf_brtaken_reloc, /* special_function */
461 "R_PPC64_REL14_BRNTAKEN",/* name */
462 FALSE, /* partial_inplace */
464 0x0000fffc, /* dst_mask */
465 TRUE), /* pcrel_offset */
467 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
469 HOWTO (R_PPC64_GOT16, /* type */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
473 FALSE, /* pc_relative */
475 complain_overflow_signed, /* complain_on_overflow */
476 ppc64_elf_unhandled_reloc, /* special_function */
477 "R_PPC64_GOT16", /* name */
478 FALSE, /* partial_inplace */
480 0xffff, /* dst_mask */
481 FALSE), /* pcrel_offset */
483 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
485 HOWTO (R_PPC64_GOT16_LO, /* type */
487 1, /* size (0 = byte, 1 = short, 2 = long) */
489 FALSE, /* pc_relative */
491 complain_overflow_dont, /* complain_on_overflow */
492 ppc64_elf_unhandled_reloc, /* special_function */
493 "R_PPC64_GOT16_LO", /* name */
494 FALSE, /* partial_inplace */
496 0xffff, /* dst_mask */
497 FALSE), /* pcrel_offset */
499 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
501 HOWTO (R_PPC64_GOT16_HI, /* type */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
505 FALSE, /* pc_relative */
507 complain_overflow_signed,/* complain_on_overflow */
508 ppc64_elf_unhandled_reloc, /* special_function */
509 "R_PPC64_GOT16_HI", /* name */
510 FALSE, /* partial_inplace */
512 0xffff, /* dst_mask */
513 FALSE), /* pcrel_offset */
515 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
517 HOWTO (R_PPC64_GOT16_HA, /* type */
519 1, /* size (0 = byte, 1 = short, 2 = long) */
521 FALSE, /* pc_relative */
523 complain_overflow_signed,/* complain_on_overflow */
524 ppc64_elf_unhandled_reloc, /* special_function */
525 "R_PPC64_GOT16_HA", /* name */
526 FALSE, /* partial_inplace */
528 0xffff, /* dst_mask */
529 FALSE), /* pcrel_offset */
531 /* This is used only by the dynamic linker. The symbol should exist
532 both in the object being run and in some shared library. The
533 dynamic linker copies the data addressed by the symbol from the
534 shared library into the object, because the object being
535 run has to have the data at some particular address. */
536 HOWTO (R_PPC64_COPY, /* type */
538 0, /* this one is variable size */
540 FALSE, /* pc_relative */
542 complain_overflow_dont, /* complain_on_overflow */
543 ppc64_elf_unhandled_reloc, /* special_function */
544 "R_PPC64_COPY", /* name */
545 FALSE, /* partial_inplace */
548 FALSE), /* pcrel_offset */
550 /* Like R_PPC64_ADDR64, but used when setting global offset table
552 HOWTO (R_PPC64_GLOB_DAT, /* type */
554 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
556 FALSE, /* pc_relative */
558 complain_overflow_dont, /* complain_on_overflow */
559 ppc64_elf_unhandled_reloc, /* special_function */
560 "R_PPC64_GLOB_DAT", /* name */
561 FALSE, /* partial_inplace */
563 ONES (64), /* dst_mask */
564 FALSE), /* pcrel_offset */
566 /* Created by the link editor. Marks a procedure linkage table
567 entry for a symbol. */
568 HOWTO (R_PPC64_JMP_SLOT, /* type */
570 0, /* size (0 = byte, 1 = short, 2 = long) */
572 FALSE, /* pc_relative */
574 complain_overflow_dont, /* complain_on_overflow */
575 ppc64_elf_unhandled_reloc, /* special_function */
576 "R_PPC64_JMP_SLOT", /* name */
577 FALSE, /* partial_inplace */
580 FALSE), /* pcrel_offset */
582 /* Used only by the dynamic linker. When the object is run, this
583 doubleword64 is set to the load address of the object, plus the
585 HOWTO (R_PPC64_RELATIVE, /* type */
587 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
589 FALSE, /* pc_relative */
591 complain_overflow_dont, /* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_PPC64_RELATIVE", /* name */
594 FALSE, /* partial_inplace */
596 ONES (64), /* dst_mask */
597 FALSE), /* pcrel_offset */
599 /* Like R_PPC64_ADDR32, but may be unaligned. */
600 HOWTO (R_PPC64_UADDR32, /* type */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
604 FALSE, /* pc_relative */
606 complain_overflow_bitfield, /* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_PPC64_UADDR32", /* name */
609 FALSE, /* partial_inplace */
611 0xffffffff, /* dst_mask */
612 FALSE), /* pcrel_offset */
614 /* Like R_PPC64_ADDR16, but may be unaligned. */
615 HOWTO (R_PPC64_UADDR16, /* type */
617 1, /* size (0 = byte, 1 = short, 2 = long) */
619 FALSE, /* pc_relative */
621 complain_overflow_bitfield, /* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
623 "R_PPC64_UADDR16", /* name */
624 FALSE, /* partial_inplace */
626 0xffff, /* dst_mask */
627 FALSE), /* pcrel_offset */
629 /* 32-bit PC relative. */
630 HOWTO (R_PPC64_REL32, /* type */
632 2, /* size (0 = byte, 1 = short, 2 = long) */
634 TRUE, /* pc_relative */
636 /* FIXME: Verify. Was complain_overflow_bitfield. */
637 complain_overflow_signed, /* complain_on_overflow */
638 bfd_elf_generic_reloc, /* special_function */
639 "R_PPC64_REL32", /* name */
640 FALSE, /* partial_inplace */
642 0xffffffff, /* dst_mask */
643 TRUE), /* pcrel_offset */
645 /* 32-bit relocation to the symbol's procedure linkage table. */
646 HOWTO (R_PPC64_PLT32, /* type */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
650 FALSE, /* pc_relative */
652 complain_overflow_bitfield, /* complain_on_overflow */
653 ppc64_elf_unhandled_reloc, /* special_function */
654 "R_PPC64_PLT32", /* name */
655 FALSE, /* partial_inplace */
657 0xffffffff, /* dst_mask */
658 FALSE), /* pcrel_offset */
660 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
661 FIXME: R_PPC64_PLTREL32 not supported. */
662 HOWTO (R_PPC64_PLTREL32, /* type */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
666 TRUE, /* pc_relative */
668 complain_overflow_signed, /* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
670 "R_PPC64_PLTREL32", /* name */
671 FALSE, /* partial_inplace */
673 0xffffffff, /* dst_mask */
674 TRUE), /* pcrel_offset */
676 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
678 HOWTO (R_PPC64_PLT16_LO, /* type */
680 1, /* size (0 = byte, 1 = short, 2 = long) */
682 FALSE, /* pc_relative */
684 complain_overflow_dont, /* complain_on_overflow */
685 ppc64_elf_unhandled_reloc, /* special_function */
686 "R_PPC64_PLT16_LO", /* name */
687 FALSE, /* partial_inplace */
689 0xffff, /* dst_mask */
690 FALSE), /* pcrel_offset */
692 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
694 HOWTO (R_PPC64_PLT16_HI, /* type */
696 1, /* size (0 = byte, 1 = short, 2 = long) */
698 FALSE, /* pc_relative */
700 complain_overflow_signed, /* complain_on_overflow */
701 ppc64_elf_unhandled_reloc, /* special_function */
702 "R_PPC64_PLT16_HI", /* name */
703 FALSE, /* partial_inplace */
705 0xffff, /* dst_mask */
706 FALSE), /* pcrel_offset */
708 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
710 HOWTO (R_PPC64_PLT16_HA, /* type */
712 1, /* size (0 = byte, 1 = short, 2 = long) */
714 FALSE, /* pc_relative */
716 complain_overflow_signed, /* complain_on_overflow */
717 ppc64_elf_unhandled_reloc, /* special_function */
718 "R_PPC64_PLT16_HA", /* name */
719 FALSE, /* partial_inplace */
721 0xffff, /* dst_mask */
722 FALSE), /* pcrel_offset */
724 /* 16-bit section relative relocation. */
725 HOWTO (R_PPC64_SECTOFF, /* type */
727 1, /* size (0 = byte, 1 = short, 2 = long) */
729 FALSE, /* pc_relative */
731 complain_overflow_bitfield, /* complain_on_overflow */
732 ppc64_elf_sectoff_reloc, /* special_function */
733 "R_PPC64_SECTOFF", /* name */
734 FALSE, /* partial_inplace */
736 0xffff, /* dst_mask */
737 FALSE), /* pcrel_offset */
739 /* Like R_PPC64_SECTOFF, but no overflow warning. */
740 HOWTO (R_PPC64_SECTOFF_LO, /* type */
742 1, /* size (0 = byte, 1 = short, 2 = long) */
744 FALSE, /* pc_relative */
746 complain_overflow_dont, /* complain_on_overflow */
747 ppc64_elf_sectoff_reloc, /* special_function */
748 "R_PPC64_SECTOFF_LO", /* name */
749 FALSE, /* partial_inplace */
751 0xffff, /* dst_mask */
752 FALSE), /* pcrel_offset */
754 /* 16-bit upper half section relative relocation. */
755 HOWTO (R_PPC64_SECTOFF_HI, /* type */
757 1, /* size (0 = byte, 1 = short, 2 = long) */
759 FALSE, /* pc_relative */
761 complain_overflow_signed, /* complain_on_overflow */
762 ppc64_elf_sectoff_reloc, /* special_function */
763 "R_PPC64_SECTOFF_HI", /* name */
764 FALSE, /* partial_inplace */
766 0xffff, /* dst_mask */
767 FALSE), /* pcrel_offset */
769 /* 16-bit upper half adjusted section relative relocation. */
770 HOWTO (R_PPC64_SECTOFF_HA, /* type */
772 1, /* size (0 = byte, 1 = short, 2 = long) */
774 FALSE, /* pc_relative */
776 complain_overflow_signed, /* complain_on_overflow */
777 ppc64_elf_sectoff_ha_reloc, /* special_function */
778 "R_PPC64_SECTOFF_HA", /* name */
779 FALSE, /* partial_inplace */
781 0xffff, /* dst_mask */
782 FALSE), /* pcrel_offset */
784 /* Like R_PPC64_REL24 without touching the two least significant bits. */
785 HOWTO (R_PPC64_REL30, /* type */
787 2, /* size (0 = byte, 1 = short, 2 = long) */
789 TRUE, /* pc_relative */
791 complain_overflow_dont, /* complain_on_overflow */
792 bfd_elf_generic_reloc, /* special_function */
793 "R_PPC64_REL30", /* name */
794 FALSE, /* partial_inplace */
796 0xfffffffc, /* dst_mask */
797 TRUE), /* pcrel_offset */
799 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
801 /* A standard 64-bit relocation. */
802 HOWTO (R_PPC64_ADDR64, /* type */
804 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
806 FALSE, /* pc_relative */
808 complain_overflow_dont, /* complain_on_overflow */
809 bfd_elf_generic_reloc, /* special_function */
810 "R_PPC64_ADDR64", /* name */
811 FALSE, /* partial_inplace */
813 ONES (64), /* dst_mask */
814 FALSE), /* pcrel_offset */
816 /* The bits 32-47 of an address. */
817 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
819 1, /* size (0 = byte, 1 = short, 2 = long) */
821 FALSE, /* pc_relative */
823 complain_overflow_dont, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
825 "R_PPC64_ADDR16_HIGHER", /* name */
826 FALSE, /* partial_inplace */
828 0xffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
831 /* The bits 32-47 of an address, plus 1 if the contents of the low
832 16 bits, treated as a signed number, is negative. */
833 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
835 1, /* size (0 = byte, 1 = short, 2 = long) */
837 FALSE, /* pc_relative */
839 complain_overflow_dont, /* complain_on_overflow */
840 ppc64_elf_ha_reloc, /* special_function */
841 "R_PPC64_ADDR16_HIGHERA", /* name */
842 FALSE, /* partial_inplace */
844 0xffff, /* dst_mask */
845 FALSE), /* pcrel_offset */
847 /* The bits 48-63 of an address. */
848 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
850 1, /* size (0 = byte, 1 = short, 2 = long) */
852 FALSE, /* pc_relative */
854 complain_overflow_dont, /* complain_on_overflow */
855 bfd_elf_generic_reloc, /* special_function */
856 "R_PPC64_ADDR16_HIGHEST", /* name */
857 FALSE, /* partial_inplace */
859 0xffff, /* dst_mask */
860 FALSE), /* pcrel_offset */
862 /* The bits 48-63 of an address, plus 1 if the contents of the low
863 16 bits, treated as a signed number, is negative. */
864 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
866 1, /* size (0 = byte, 1 = short, 2 = long) */
868 FALSE, /* pc_relative */
870 complain_overflow_dont, /* complain_on_overflow */
871 ppc64_elf_ha_reloc, /* special_function */
872 "R_PPC64_ADDR16_HIGHESTA", /* name */
873 FALSE, /* partial_inplace */
875 0xffff, /* dst_mask */
876 FALSE), /* pcrel_offset */
878 /* Like ADDR64, but may be unaligned. */
879 HOWTO (R_PPC64_UADDR64, /* type */
881 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
883 FALSE, /* pc_relative */
885 complain_overflow_dont, /* complain_on_overflow */
886 bfd_elf_generic_reloc, /* special_function */
887 "R_PPC64_UADDR64", /* name */
888 FALSE, /* partial_inplace */
890 ONES (64), /* dst_mask */
891 FALSE), /* pcrel_offset */
893 /* 64-bit relative relocation. */
894 HOWTO (R_PPC64_REL64, /* type */
896 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
898 TRUE, /* pc_relative */
900 complain_overflow_dont, /* complain_on_overflow */
901 bfd_elf_generic_reloc, /* special_function */
902 "R_PPC64_REL64", /* name */
903 FALSE, /* partial_inplace */
905 ONES (64), /* dst_mask */
906 TRUE), /* pcrel_offset */
908 /* 64-bit relocation to the symbol's procedure linkage table. */
909 HOWTO (R_PPC64_PLT64, /* type */
911 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
913 FALSE, /* pc_relative */
915 complain_overflow_dont, /* complain_on_overflow */
916 ppc64_elf_unhandled_reloc, /* special_function */
917 "R_PPC64_PLT64", /* name */
918 FALSE, /* partial_inplace */
920 ONES (64), /* dst_mask */
921 FALSE), /* pcrel_offset */
923 /* 64-bit PC relative relocation to the symbol's procedure linkage
925 /* FIXME: R_PPC64_PLTREL64 not supported. */
926 HOWTO (R_PPC64_PLTREL64, /* type */
928 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
930 TRUE, /* pc_relative */
932 complain_overflow_dont, /* complain_on_overflow */
933 ppc64_elf_unhandled_reloc, /* special_function */
934 "R_PPC64_PLTREL64", /* name */
935 FALSE, /* partial_inplace */
937 ONES (64), /* dst_mask */
938 TRUE), /* pcrel_offset */
940 /* 16 bit TOC-relative relocation. */
942 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
943 HOWTO (R_PPC64_TOC16, /* type */
945 1, /* size (0 = byte, 1 = short, 2 = long) */
947 FALSE, /* pc_relative */
949 complain_overflow_signed, /* complain_on_overflow */
950 ppc64_elf_toc_reloc, /* special_function */
951 "R_PPC64_TOC16", /* name */
952 FALSE, /* partial_inplace */
954 0xffff, /* dst_mask */
955 FALSE), /* pcrel_offset */
957 /* 16 bit TOC-relative relocation without overflow. */
959 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
960 HOWTO (R_PPC64_TOC16_LO, /* type */
962 1, /* size (0 = byte, 1 = short, 2 = long) */
964 FALSE, /* pc_relative */
966 complain_overflow_dont, /* complain_on_overflow */
967 ppc64_elf_toc_reloc, /* special_function */
968 "R_PPC64_TOC16_LO", /* name */
969 FALSE, /* partial_inplace */
971 0xffff, /* dst_mask */
972 FALSE), /* pcrel_offset */
974 /* 16 bit TOC-relative relocation, high 16 bits. */
976 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
977 HOWTO (R_PPC64_TOC16_HI, /* type */
979 1, /* size (0 = byte, 1 = short, 2 = long) */
981 FALSE, /* pc_relative */
983 complain_overflow_signed, /* complain_on_overflow */
984 ppc64_elf_toc_reloc, /* special_function */
985 "R_PPC64_TOC16_HI", /* name */
986 FALSE, /* partial_inplace */
988 0xffff, /* dst_mask */
989 FALSE), /* pcrel_offset */
991 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
992 contents of the low 16 bits, treated as a signed number, is
995 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
996 HOWTO (R_PPC64_TOC16_HA, /* type */
998 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 FALSE, /* pc_relative */
1002 complain_overflow_signed, /* complain_on_overflow */
1003 ppc64_elf_toc_ha_reloc, /* special_function */
1004 "R_PPC64_TOC16_HA", /* name */
1005 FALSE, /* partial_inplace */
1007 0xffff, /* dst_mask */
1008 FALSE), /* pcrel_offset */
1010 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1012 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1013 HOWTO (R_PPC64_TOC, /* type */
1015 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1017 FALSE, /* pc_relative */
1019 complain_overflow_bitfield, /* complain_on_overflow */
1020 ppc64_elf_toc64_reloc, /* special_function */
1021 "R_PPC64_TOC", /* name */
1022 FALSE, /* partial_inplace */
1024 ONES (64), /* dst_mask */
1025 FALSE), /* pcrel_offset */
1027 /* Like R_PPC64_GOT16, but also informs the link editor that the
1028 value to relocate may (!) refer to a PLT entry which the link
1029 editor (a) may replace with the symbol value. If the link editor
1030 is unable to fully resolve the symbol, it may (b) create a PLT
1031 entry and store the address to the new PLT entry in the GOT.
1032 This permits lazy resolution of function symbols at run time.
1033 The link editor may also skip all of this and just (c) emit a
1034 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1035 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1036 HOWTO (R_PPC64_PLTGOT16, /* type */
1038 1, /* size (0 = byte, 1 = short, 2 = long) */
1040 FALSE, /* pc_relative */
1042 complain_overflow_signed, /* complain_on_overflow */
1043 ppc64_elf_unhandled_reloc, /* special_function */
1044 "R_PPC64_PLTGOT16", /* name */
1045 FALSE, /* partial_inplace */
1047 0xffff, /* dst_mask */
1048 FALSE), /* pcrel_offset */
1050 /* Like R_PPC64_PLTGOT16, but without overflow. */
1051 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1052 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1054 1, /* size (0 = byte, 1 = short, 2 = long) */
1056 FALSE, /* pc_relative */
1058 complain_overflow_dont, /* complain_on_overflow */
1059 ppc64_elf_unhandled_reloc, /* special_function */
1060 "R_PPC64_PLTGOT16_LO", /* name */
1061 FALSE, /* partial_inplace */
1063 0xffff, /* dst_mask */
1064 FALSE), /* pcrel_offset */
1066 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1067 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1068 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1069 16, /* rightshift */
1070 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 FALSE, /* pc_relative */
1074 complain_overflow_signed, /* complain_on_overflow */
1075 ppc64_elf_unhandled_reloc, /* special_function */
1076 "R_PPC64_PLTGOT16_HI", /* name */
1077 FALSE, /* partial_inplace */
1079 0xffff, /* dst_mask */
1080 FALSE), /* pcrel_offset */
1082 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083 1 if the contents of the low 16 bits, treated as a signed number,
1085 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1086 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1087 16, /* rightshift */
1088 1, /* size (0 = byte, 1 = short, 2 = long) */
1090 FALSE, /* pc_relative */
1092 complain_overflow_signed, /* complain_on_overflow */
1093 ppc64_elf_unhandled_reloc, /* special_function */
1094 "R_PPC64_PLTGOT16_HA", /* name */
1095 FALSE, /* partial_inplace */
1097 0xffff, /* dst_mask */
1098 FALSE), /* pcrel_offset */
1100 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1101 HOWTO (R_PPC64_ADDR16_DS, /* type */
1103 1, /* size (0 = byte, 1 = short, 2 = long) */
1105 FALSE, /* pc_relative */
1107 complain_overflow_bitfield, /* complain_on_overflow */
1108 bfd_elf_generic_reloc, /* special_function */
1109 "R_PPC64_ADDR16_DS", /* name */
1110 FALSE, /* partial_inplace */
1112 0xfffc, /* dst_mask */
1113 FALSE), /* pcrel_offset */
1115 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1116 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1118 1, /* size (0 = byte, 1 = short, 2 = long) */
1120 FALSE, /* pc_relative */
1122 complain_overflow_dont,/* complain_on_overflow */
1123 bfd_elf_generic_reloc, /* special_function */
1124 "R_PPC64_ADDR16_LO_DS",/* name */
1125 FALSE, /* partial_inplace */
1127 0xfffc, /* dst_mask */
1128 FALSE), /* pcrel_offset */
1130 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1131 HOWTO (R_PPC64_GOT16_DS, /* type */
1133 1, /* size (0 = byte, 1 = short, 2 = long) */
1135 FALSE, /* pc_relative */
1137 complain_overflow_signed, /* complain_on_overflow */
1138 ppc64_elf_unhandled_reloc, /* special_function */
1139 "R_PPC64_GOT16_DS", /* name */
1140 FALSE, /* partial_inplace */
1142 0xfffc, /* dst_mask */
1143 FALSE), /* pcrel_offset */
1145 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1146 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1148 1, /* size (0 = byte, 1 = short, 2 = long) */
1150 FALSE, /* pc_relative */
1152 complain_overflow_dont, /* complain_on_overflow */
1153 ppc64_elf_unhandled_reloc, /* special_function */
1154 "R_PPC64_GOT16_LO_DS", /* name */
1155 FALSE, /* partial_inplace */
1157 0xfffc, /* dst_mask */
1158 FALSE), /* pcrel_offset */
1160 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1161 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1163 1, /* size (0 = byte, 1 = short, 2 = long) */
1165 FALSE, /* pc_relative */
1167 complain_overflow_dont, /* complain_on_overflow */
1168 ppc64_elf_unhandled_reloc, /* special_function */
1169 "R_PPC64_PLT16_LO_DS", /* name */
1170 FALSE, /* partial_inplace */
1172 0xfffc, /* dst_mask */
1173 FALSE), /* pcrel_offset */
1175 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1176 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1178 1, /* size (0 = byte, 1 = short, 2 = long) */
1180 FALSE, /* pc_relative */
1182 complain_overflow_bitfield, /* complain_on_overflow */
1183 ppc64_elf_sectoff_reloc, /* special_function */
1184 "R_PPC64_SECTOFF_DS", /* name */
1185 FALSE, /* partial_inplace */
1187 0xfffc, /* dst_mask */
1188 FALSE), /* pcrel_offset */
1190 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1191 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1193 1, /* size (0 = byte, 1 = short, 2 = long) */
1195 FALSE, /* pc_relative */
1197 complain_overflow_dont, /* complain_on_overflow */
1198 ppc64_elf_sectoff_reloc, /* special_function */
1199 "R_PPC64_SECTOFF_LO_DS",/* name */
1200 FALSE, /* partial_inplace */
1202 0xfffc, /* dst_mask */
1203 FALSE), /* pcrel_offset */
1205 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1206 HOWTO (R_PPC64_TOC16_DS, /* type */
1208 1, /* size (0 = byte, 1 = short, 2 = long) */
1210 FALSE, /* pc_relative */
1212 complain_overflow_signed, /* complain_on_overflow */
1213 ppc64_elf_toc_reloc, /* special_function */
1214 "R_PPC64_TOC16_DS", /* name */
1215 FALSE, /* partial_inplace */
1217 0xfffc, /* dst_mask */
1218 FALSE), /* pcrel_offset */
1220 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1221 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1223 1, /* size (0 = byte, 1 = short, 2 = long) */
1225 FALSE, /* pc_relative */
1227 complain_overflow_dont, /* complain_on_overflow */
1228 ppc64_elf_toc_reloc, /* special_function */
1229 "R_PPC64_TOC16_LO_DS", /* name */
1230 FALSE, /* partial_inplace */
1232 0xfffc, /* dst_mask */
1233 FALSE), /* pcrel_offset */
1235 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1236 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1237 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1239 1, /* size (0 = byte, 1 = short, 2 = long) */
1241 FALSE, /* pc_relative */
1243 complain_overflow_signed, /* complain_on_overflow */
1244 ppc64_elf_unhandled_reloc, /* special_function */
1245 "R_PPC64_PLTGOT16_DS", /* name */
1246 FALSE, /* partial_inplace */
1248 0xfffc, /* dst_mask */
1249 FALSE), /* pcrel_offset */
1251 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1252 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1253 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1255 1, /* size (0 = byte, 1 = short, 2 = long) */
1257 FALSE, /* pc_relative */
1259 complain_overflow_dont, /* complain_on_overflow */
1260 ppc64_elf_unhandled_reloc, /* special_function */
1261 "R_PPC64_PLTGOT16_LO_DS",/* name */
1262 FALSE, /* partial_inplace */
1264 0xfffc, /* dst_mask */
1265 FALSE), /* pcrel_offset */
1267 /* Marker relocs for TLS. */
1270 2, /* size (0 = byte, 1 = short, 2 = long) */
1272 FALSE, /* pc_relative */
1274 complain_overflow_dont, /* complain_on_overflow */
1275 bfd_elf_generic_reloc, /* special_function */
1276 "R_PPC64_TLS", /* name */
1277 FALSE, /* partial_inplace */
1280 FALSE), /* pcrel_offset */
1282 HOWTO (R_PPC64_TLSGD,
1284 2, /* size (0 = byte, 1 = short, 2 = long) */
1286 FALSE, /* pc_relative */
1288 complain_overflow_dont, /* complain_on_overflow */
1289 bfd_elf_generic_reloc, /* special_function */
1290 "R_PPC64_TLSGD", /* name */
1291 FALSE, /* partial_inplace */
1294 FALSE), /* pcrel_offset */
1296 HOWTO (R_PPC64_TLSLD,
1298 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 FALSE, /* pc_relative */
1302 complain_overflow_dont, /* complain_on_overflow */
1303 bfd_elf_generic_reloc, /* special_function */
1304 "R_PPC64_TLSLD", /* name */
1305 FALSE, /* partial_inplace */
1308 FALSE), /* pcrel_offset */
1310 HOWTO (R_PPC64_TOCSAVE,
1312 2, /* size (0 = byte, 1 = short, 2 = long) */
1314 FALSE, /* pc_relative */
1316 complain_overflow_dont, /* complain_on_overflow */
1317 bfd_elf_generic_reloc, /* special_function */
1318 "R_PPC64_TOCSAVE", /* name */
1319 FALSE, /* partial_inplace */
1322 FALSE), /* pcrel_offset */
1324 /* Computes the load module index of the load module that contains the
1325 definition of its TLS sym. */
1326 HOWTO (R_PPC64_DTPMOD64,
1328 4, /* size (0 = byte, 1 = short, 2 = long) */
1330 FALSE, /* pc_relative */
1332 complain_overflow_dont, /* complain_on_overflow */
1333 ppc64_elf_unhandled_reloc, /* special_function */
1334 "R_PPC64_DTPMOD64", /* name */
1335 FALSE, /* partial_inplace */
1337 ONES (64), /* dst_mask */
1338 FALSE), /* pcrel_offset */
1340 /* Computes a dtv-relative displacement, the difference between the value
1341 of sym+add and the base address of the thread-local storage block that
1342 contains the definition of sym, minus 0x8000. */
1343 HOWTO (R_PPC64_DTPREL64,
1345 4, /* size (0 = byte, 1 = short, 2 = long) */
1347 FALSE, /* pc_relative */
1349 complain_overflow_dont, /* complain_on_overflow */
1350 ppc64_elf_unhandled_reloc, /* special_function */
1351 "R_PPC64_DTPREL64", /* name */
1352 FALSE, /* partial_inplace */
1354 ONES (64), /* dst_mask */
1355 FALSE), /* pcrel_offset */
1357 /* A 16 bit dtprel reloc. */
1358 HOWTO (R_PPC64_DTPREL16,
1360 1, /* size (0 = byte, 1 = short, 2 = long) */
1362 FALSE, /* pc_relative */
1364 complain_overflow_signed, /* complain_on_overflow */
1365 ppc64_elf_unhandled_reloc, /* special_function */
1366 "R_PPC64_DTPREL16", /* name */
1367 FALSE, /* partial_inplace */
1369 0xffff, /* dst_mask */
1370 FALSE), /* pcrel_offset */
1372 /* Like DTPREL16, but no overflow. */
1373 HOWTO (R_PPC64_DTPREL16_LO,
1375 1, /* size (0 = byte, 1 = short, 2 = long) */
1377 FALSE, /* pc_relative */
1379 complain_overflow_dont, /* complain_on_overflow */
1380 ppc64_elf_unhandled_reloc, /* special_function */
1381 "R_PPC64_DTPREL16_LO", /* name */
1382 FALSE, /* partial_inplace */
1384 0xffff, /* dst_mask */
1385 FALSE), /* pcrel_offset */
1387 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1388 HOWTO (R_PPC64_DTPREL16_HI,
1389 16, /* rightshift */
1390 1, /* size (0 = byte, 1 = short, 2 = long) */
1392 FALSE, /* pc_relative */
1394 complain_overflow_signed, /* complain_on_overflow */
1395 ppc64_elf_unhandled_reloc, /* special_function */
1396 "R_PPC64_DTPREL16_HI", /* name */
1397 FALSE, /* partial_inplace */
1399 0xffff, /* dst_mask */
1400 FALSE), /* pcrel_offset */
1402 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1403 HOWTO (R_PPC64_DTPREL16_HA,
1404 16, /* rightshift */
1405 1, /* size (0 = byte, 1 = short, 2 = long) */
1407 FALSE, /* pc_relative */
1409 complain_overflow_signed, /* complain_on_overflow */
1410 ppc64_elf_unhandled_reloc, /* special_function */
1411 "R_PPC64_DTPREL16_HA", /* name */
1412 FALSE, /* partial_inplace */
1414 0xffff, /* dst_mask */
1415 FALSE), /* pcrel_offset */
1417 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1418 HOWTO (R_PPC64_DTPREL16_HIGHER,
1419 32, /* rightshift */
1420 1, /* size (0 = byte, 1 = short, 2 = long) */
1422 FALSE, /* pc_relative */
1424 complain_overflow_dont, /* complain_on_overflow */
1425 ppc64_elf_unhandled_reloc, /* special_function */
1426 "R_PPC64_DTPREL16_HIGHER", /* name */
1427 FALSE, /* partial_inplace */
1429 0xffff, /* dst_mask */
1430 FALSE), /* pcrel_offset */
1432 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1433 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434 32, /* rightshift */
1435 1, /* size (0 = byte, 1 = short, 2 = long) */
1437 FALSE, /* pc_relative */
1439 complain_overflow_dont, /* complain_on_overflow */
1440 ppc64_elf_unhandled_reloc, /* special_function */
1441 "R_PPC64_DTPREL16_HIGHERA", /* name */
1442 FALSE, /* partial_inplace */
1444 0xffff, /* dst_mask */
1445 FALSE), /* pcrel_offset */
1447 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1448 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449 48, /* rightshift */
1450 1, /* size (0 = byte, 1 = short, 2 = long) */
1452 FALSE, /* pc_relative */
1454 complain_overflow_dont, /* complain_on_overflow */
1455 ppc64_elf_unhandled_reloc, /* special_function */
1456 "R_PPC64_DTPREL16_HIGHEST", /* name */
1457 FALSE, /* partial_inplace */
1459 0xffff, /* dst_mask */
1460 FALSE), /* pcrel_offset */
1462 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1463 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464 48, /* rightshift */
1465 1, /* size (0 = byte, 1 = short, 2 = long) */
1467 FALSE, /* pc_relative */
1469 complain_overflow_dont, /* complain_on_overflow */
1470 ppc64_elf_unhandled_reloc, /* special_function */
1471 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472 FALSE, /* partial_inplace */
1474 0xffff, /* dst_mask */
1475 FALSE), /* pcrel_offset */
1477 /* Like DTPREL16, but for insns with a DS field. */
1478 HOWTO (R_PPC64_DTPREL16_DS,
1480 1, /* size (0 = byte, 1 = short, 2 = long) */
1482 FALSE, /* pc_relative */
1484 complain_overflow_signed, /* complain_on_overflow */
1485 ppc64_elf_unhandled_reloc, /* special_function */
1486 "R_PPC64_DTPREL16_DS", /* name */
1487 FALSE, /* partial_inplace */
1489 0xfffc, /* dst_mask */
1490 FALSE), /* pcrel_offset */
1492 /* Like DTPREL16_DS, but no overflow. */
1493 HOWTO (R_PPC64_DTPREL16_LO_DS,
1495 1, /* size (0 = byte, 1 = short, 2 = long) */
1497 FALSE, /* pc_relative */
1499 complain_overflow_dont, /* complain_on_overflow */
1500 ppc64_elf_unhandled_reloc, /* special_function */
1501 "R_PPC64_DTPREL16_LO_DS", /* name */
1502 FALSE, /* partial_inplace */
1504 0xfffc, /* dst_mask */
1505 FALSE), /* pcrel_offset */
1507 /* Computes a tp-relative displacement, the difference between the value of
1508 sym+add and the value of the thread pointer (r13). */
1509 HOWTO (R_PPC64_TPREL64,
1511 4, /* size (0 = byte, 1 = short, 2 = long) */
1513 FALSE, /* pc_relative */
1515 complain_overflow_dont, /* complain_on_overflow */
1516 ppc64_elf_unhandled_reloc, /* special_function */
1517 "R_PPC64_TPREL64", /* name */
1518 FALSE, /* partial_inplace */
1520 ONES (64), /* dst_mask */
1521 FALSE), /* pcrel_offset */
1523 /* A 16 bit tprel reloc. */
1524 HOWTO (R_PPC64_TPREL16,
1526 1, /* size (0 = byte, 1 = short, 2 = long) */
1528 FALSE, /* pc_relative */
1530 complain_overflow_signed, /* complain_on_overflow */
1531 ppc64_elf_unhandled_reloc, /* special_function */
1532 "R_PPC64_TPREL16", /* name */
1533 FALSE, /* partial_inplace */
1535 0xffff, /* dst_mask */
1536 FALSE), /* pcrel_offset */
1538 /* Like TPREL16, but no overflow. */
1539 HOWTO (R_PPC64_TPREL16_LO,
1541 1, /* size (0 = byte, 1 = short, 2 = long) */
1543 FALSE, /* pc_relative */
1545 complain_overflow_dont, /* complain_on_overflow */
1546 ppc64_elf_unhandled_reloc, /* special_function */
1547 "R_PPC64_TPREL16_LO", /* name */
1548 FALSE, /* partial_inplace */
1550 0xffff, /* dst_mask */
1551 FALSE), /* pcrel_offset */
1553 /* Like TPREL16_LO, but next higher group of 16 bits. */
1554 HOWTO (R_PPC64_TPREL16_HI,
1555 16, /* rightshift */
1556 1, /* size (0 = byte, 1 = short, 2 = long) */
1558 FALSE, /* pc_relative */
1560 complain_overflow_signed, /* complain_on_overflow */
1561 ppc64_elf_unhandled_reloc, /* special_function */
1562 "R_PPC64_TPREL16_HI", /* name */
1563 FALSE, /* partial_inplace */
1565 0xffff, /* dst_mask */
1566 FALSE), /* pcrel_offset */
1568 /* Like TPREL16_HI, but adjust for low 16 bits. */
1569 HOWTO (R_PPC64_TPREL16_HA,
1570 16, /* rightshift */
1571 1, /* size (0 = byte, 1 = short, 2 = long) */
1573 FALSE, /* pc_relative */
1575 complain_overflow_signed, /* complain_on_overflow */
1576 ppc64_elf_unhandled_reloc, /* special_function */
1577 "R_PPC64_TPREL16_HA", /* name */
1578 FALSE, /* partial_inplace */
1580 0xffff, /* dst_mask */
1581 FALSE), /* pcrel_offset */
1583 /* Like TPREL16_HI, but next higher group of 16 bits. */
1584 HOWTO (R_PPC64_TPREL16_HIGHER,
1585 32, /* rightshift */
1586 1, /* size (0 = byte, 1 = short, 2 = long) */
1588 FALSE, /* pc_relative */
1590 complain_overflow_dont, /* complain_on_overflow */
1591 ppc64_elf_unhandled_reloc, /* special_function */
1592 "R_PPC64_TPREL16_HIGHER", /* name */
1593 FALSE, /* partial_inplace */
1595 0xffff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1598 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1599 HOWTO (R_PPC64_TPREL16_HIGHERA,
1600 32, /* rightshift */
1601 1, /* size (0 = byte, 1 = short, 2 = long) */
1603 FALSE, /* pc_relative */
1605 complain_overflow_dont, /* complain_on_overflow */
1606 ppc64_elf_unhandled_reloc, /* special_function */
1607 "R_PPC64_TPREL16_HIGHERA", /* name */
1608 FALSE, /* partial_inplace */
1610 0xffff, /* dst_mask */
1611 FALSE), /* pcrel_offset */
1613 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1614 HOWTO (R_PPC64_TPREL16_HIGHEST,
1615 48, /* rightshift */
1616 1, /* size (0 = byte, 1 = short, 2 = long) */
1618 FALSE, /* pc_relative */
1620 complain_overflow_dont, /* complain_on_overflow */
1621 ppc64_elf_unhandled_reloc, /* special_function */
1622 "R_PPC64_TPREL16_HIGHEST", /* name */
1623 FALSE, /* partial_inplace */
1625 0xffff, /* dst_mask */
1626 FALSE), /* pcrel_offset */
1628 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1629 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630 48, /* rightshift */
1631 1, /* size (0 = byte, 1 = short, 2 = long) */
1633 FALSE, /* pc_relative */
1635 complain_overflow_dont, /* complain_on_overflow */
1636 ppc64_elf_unhandled_reloc, /* special_function */
1637 "R_PPC64_TPREL16_HIGHESTA", /* name */
1638 FALSE, /* partial_inplace */
1640 0xffff, /* dst_mask */
1641 FALSE), /* pcrel_offset */
1643 /* Like TPREL16, but for insns with a DS field. */
1644 HOWTO (R_PPC64_TPREL16_DS,
1646 1, /* size (0 = byte, 1 = short, 2 = long) */
1648 FALSE, /* pc_relative */
1650 complain_overflow_signed, /* complain_on_overflow */
1651 ppc64_elf_unhandled_reloc, /* special_function */
1652 "R_PPC64_TPREL16_DS", /* name */
1653 FALSE, /* partial_inplace */
1655 0xfffc, /* dst_mask */
1656 FALSE), /* pcrel_offset */
1658 /* Like TPREL16_DS, but no overflow. */
1659 HOWTO (R_PPC64_TPREL16_LO_DS,
1661 1, /* size (0 = byte, 1 = short, 2 = long) */
1663 FALSE, /* pc_relative */
1665 complain_overflow_dont, /* complain_on_overflow */
1666 ppc64_elf_unhandled_reloc, /* special_function */
1667 "R_PPC64_TPREL16_LO_DS", /* name */
1668 FALSE, /* partial_inplace */
1670 0xfffc, /* dst_mask */
1671 FALSE), /* pcrel_offset */
1673 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675 to the first entry relative to the TOC base (r2). */
1676 HOWTO (R_PPC64_GOT_TLSGD16,
1678 1, /* size (0 = byte, 1 = short, 2 = long) */
1680 FALSE, /* pc_relative */
1682 complain_overflow_signed, /* complain_on_overflow */
1683 ppc64_elf_unhandled_reloc, /* special_function */
1684 "R_PPC64_GOT_TLSGD16", /* name */
1685 FALSE, /* partial_inplace */
1687 0xffff, /* dst_mask */
1688 FALSE), /* pcrel_offset */
1690 /* Like GOT_TLSGD16, but no overflow. */
1691 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1693 1, /* size (0 = byte, 1 = short, 2 = long) */
1695 FALSE, /* pc_relative */
1697 complain_overflow_dont, /* complain_on_overflow */
1698 ppc64_elf_unhandled_reloc, /* special_function */
1699 "R_PPC64_GOT_TLSGD16_LO", /* name */
1700 FALSE, /* partial_inplace */
1702 0xffff, /* dst_mask */
1703 FALSE), /* pcrel_offset */
1705 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1706 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707 16, /* rightshift */
1708 1, /* size (0 = byte, 1 = short, 2 = long) */
1710 FALSE, /* pc_relative */
1712 complain_overflow_signed, /* complain_on_overflow */
1713 ppc64_elf_unhandled_reloc, /* special_function */
1714 "R_PPC64_GOT_TLSGD16_HI", /* name */
1715 FALSE, /* partial_inplace */
1717 0xffff, /* dst_mask */
1718 FALSE), /* pcrel_offset */
1720 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1721 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722 16, /* rightshift */
1723 1, /* size (0 = byte, 1 = short, 2 = long) */
1725 FALSE, /* pc_relative */
1727 complain_overflow_signed, /* complain_on_overflow */
1728 ppc64_elf_unhandled_reloc, /* special_function */
1729 "R_PPC64_GOT_TLSGD16_HA", /* name */
1730 FALSE, /* partial_inplace */
1732 0xffff, /* dst_mask */
1733 FALSE), /* pcrel_offset */
1735 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736 with values (sym+add)@dtpmod and zero, and computes the offset to the
1737 first entry relative to the TOC base (r2). */
1738 HOWTO (R_PPC64_GOT_TLSLD16,
1740 1, /* size (0 = byte, 1 = short, 2 = long) */
1742 FALSE, /* pc_relative */
1744 complain_overflow_signed, /* complain_on_overflow */
1745 ppc64_elf_unhandled_reloc, /* special_function */
1746 "R_PPC64_GOT_TLSLD16", /* name */
1747 FALSE, /* partial_inplace */
1749 0xffff, /* dst_mask */
1750 FALSE), /* pcrel_offset */
1752 /* Like GOT_TLSLD16, but no overflow. */
1753 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1755 1, /* size (0 = byte, 1 = short, 2 = long) */
1757 FALSE, /* pc_relative */
1759 complain_overflow_dont, /* complain_on_overflow */
1760 ppc64_elf_unhandled_reloc, /* special_function */
1761 "R_PPC64_GOT_TLSLD16_LO", /* name */
1762 FALSE, /* partial_inplace */
1764 0xffff, /* dst_mask */
1765 FALSE), /* pcrel_offset */
1767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1768 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769 16, /* rightshift */
1770 1, /* size (0 = byte, 1 = short, 2 = long) */
1772 FALSE, /* pc_relative */
1774 complain_overflow_signed, /* complain_on_overflow */
1775 ppc64_elf_unhandled_reloc, /* special_function */
1776 "R_PPC64_GOT_TLSLD16_HI", /* name */
1777 FALSE, /* partial_inplace */
1779 0xffff, /* dst_mask */
1780 FALSE), /* pcrel_offset */
1782 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1783 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784 16, /* rightshift */
1785 1, /* size (0 = byte, 1 = short, 2 = long) */
1787 FALSE, /* pc_relative */
1789 complain_overflow_signed, /* complain_on_overflow */
1790 ppc64_elf_unhandled_reloc, /* special_function */
1791 "R_PPC64_GOT_TLSLD16_HA", /* name */
1792 FALSE, /* partial_inplace */
1794 0xffff, /* dst_mask */
1795 FALSE), /* pcrel_offset */
1797 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798 the offset to the entry relative to the TOC base (r2). */
1799 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1801 1, /* size (0 = byte, 1 = short, 2 = long) */
1803 FALSE, /* pc_relative */
1805 complain_overflow_signed, /* complain_on_overflow */
1806 ppc64_elf_unhandled_reloc, /* special_function */
1807 "R_PPC64_GOT_DTPREL16_DS", /* name */
1808 FALSE, /* partial_inplace */
1810 0xfffc, /* dst_mask */
1811 FALSE), /* pcrel_offset */
1813 /* Like GOT_DTPREL16_DS, but no overflow. */
1814 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1816 1, /* size (0 = byte, 1 = short, 2 = long) */
1818 FALSE, /* pc_relative */
1820 complain_overflow_dont, /* complain_on_overflow */
1821 ppc64_elf_unhandled_reloc, /* special_function */
1822 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823 FALSE, /* partial_inplace */
1825 0xfffc, /* dst_mask */
1826 FALSE), /* pcrel_offset */
1828 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1829 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830 16, /* rightshift */
1831 1, /* size (0 = byte, 1 = short, 2 = long) */
1833 FALSE, /* pc_relative */
1835 complain_overflow_signed, /* complain_on_overflow */
1836 ppc64_elf_unhandled_reloc, /* special_function */
1837 "R_PPC64_GOT_DTPREL16_HI", /* name */
1838 FALSE, /* partial_inplace */
1840 0xffff, /* dst_mask */
1841 FALSE), /* pcrel_offset */
1843 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1844 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845 16, /* rightshift */
1846 1, /* size (0 = byte, 1 = short, 2 = long) */
1848 FALSE, /* pc_relative */
1850 complain_overflow_signed, /* complain_on_overflow */
1851 ppc64_elf_unhandled_reloc, /* special_function */
1852 "R_PPC64_GOT_DTPREL16_HA", /* name */
1853 FALSE, /* partial_inplace */
1855 0xffff, /* dst_mask */
1856 FALSE), /* pcrel_offset */
1858 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859 offset to the entry relative to the TOC base (r2). */
1860 HOWTO (R_PPC64_GOT_TPREL16_DS,
1862 1, /* size (0 = byte, 1 = short, 2 = long) */
1864 FALSE, /* pc_relative */
1866 complain_overflow_signed, /* complain_on_overflow */
1867 ppc64_elf_unhandled_reloc, /* special_function */
1868 "R_PPC64_GOT_TPREL16_DS", /* name */
1869 FALSE, /* partial_inplace */
1871 0xfffc, /* dst_mask */
1872 FALSE), /* pcrel_offset */
1874 /* Like GOT_TPREL16_DS, but no overflow. */
1875 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1877 1, /* size (0 = byte, 1 = short, 2 = long) */
1879 FALSE, /* pc_relative */
1881 complain_overflow_dont, /* complain_on_overflow */
1882 ppc64_elf_unhandled_reloc, /* special_function */
1883 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884 FALSE, /* partial_inplace */
1886 0xfffc, /* dst_mask */
1887 FALSE), /* pcrel_offset */
1889 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1890 HOWTO (R_PPC64_GOT_TPREL16_HI,
1891 16, /* rightshift */
1892 1, /* size (0 = byte, 1 = short, 2 = long) */
1894 FALSE, /* pc_relative */
1896 complain_overflow_signed, /* complain_on_overflow */
1897 ppc64_elf_unhandled_reloc, /* special_function */
1898 "R_PPC64_GOT_TPREL16_HI", /* name */
1899 FALSE, /* partial_inplace */
1901 0xffff, /* dst_mask */
1902 FALSE), /* pcrel_offset */
1904 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1905 HOWTO (R_PPC64_GOT_TPREL16_HA,
1906 16, /* rightshift */
1907 1, /* size (0 = byte, 1 = short, 2 = long) */
1909 FALSE, /* pc_relative */
1911 complain_overflow_signed, /* complain_on_overflow */
1912 ppc64_elf_unhandled_reloc, /* special_function */
1913 "R_PPC64_GOT_TPREL16_HA", /* name */
1914 FALSE, /* partial_inplace */
1916 0xffff, /* dst_mask */
1917 FALSE), /* pcrel_offset */
1919 HOWTO (R_PPC64_JMP_IREL, /* type */
1921 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1923 FALSE, /* pc_relative */
1925 complain_overflow_dont, /* complain_on_overflow */
1926 ppc64_elf_unhandled_reloc, /* special_function */
1927 "R_PPC64_JMP_IREL", /* name */
1928 FALSE, /* partial_inplace */
1931 FALSE), /* pcrel_offset */
1933 HOWTO (R_PPC64_IRELATIVE, /* type */
1935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1937 FALSE, /* pc_relative */
1939 complain_overflow_dont, /* complain_on_overflow */
1940 bfd_elf_generic_reloc, /* special_function */
1941 "R_PPC64_IRELATIVE", /* name */
1942 FALSE, /* partial_inplace */
1944 ONES (64), /* dst_mask */
1945 FALSE), /* pcrel_offset */
1947 /* A 16 bit relative relocation. */
1948 HOWTO (R_PPC64_REL16, /* type */
1950 1, /* size (0 = byte, 1 = short, 2 = long) */
1952 TRUE, /* pc_relative */
1954 complain_overflow_bitfield, /* complain_on_overflow */
1955 bfd_elf_generic_reloc, /* special_function */
1956 "R_PPC64_REL16", /* name */
1957 FALSE, /* partial_inplace */
1959 0xffff, /* dst_mask */
1960 TRUE), /* pcrel_offset */
1962 /* A 16 bit relative relocation without overflow. */
1963 HOWTO (R_PPC64_REL16_LO, /* type */
1965 1, /* size (0 = byte, 1 = short, 2 = long) */
1967 TRUE, /* pc_relative */
1969 complain_overflow_dont,/* complain_on_overflow */
1970 bfd_elf_generic_reloc, /* special_function */
1971 "R_PPC64_REL16_LO", /* name */
1972 FALSE, /* partial_inplace */
1974 0xffff, /* dst_mask */
1975 TRUE), /* pcrel_offset */
1977 /* The high order 16 bits of a relative address. */
1978 HOWTO (R_PPC64_REL16_HI, /* type */
1979 16, /* rightshift */
1980 1, /* size (0 = byte, 1 = short, 2 = long) */
1982 TRUE, /* pc_relative */
1984 complain_overflow_signed, /* complain_on_overflow */
1985 bfd_elf_generic_reloc, /* special_function */
1986 "R_PPC64_REL16_HI", /* name */
1987 FALSE, /* partial_inplace */
1989 0xffff, /* dst_mask */
1990 TRUE), /* pcrel_offset */
1992 /* The high order 16 bits of a relative address, plus 1 if the contents of
1993 the low 16 bits, treated as a signed number, is negative. */
1994 HOWTO (R_PPC64_REL16_HA, /* type */
1995 16, /* rightshift */
1996 1, /* size (0 = byte, 1 = short, 2 = long) */
1998 TRUE, /* pc_relative */
2000 complain_overflow_signed, /* complain_on_overflow */
2001 ppc64_elf_ha_reloc, /* special_function */
2002 "R_PPC64_REL16_HA", /* name */
2003 FALSE, /* partial_inplace */
2005 0xffff, /* dst_mask */
2006 TRUE), /* pcrel_offset */
2008 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2009 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2010 16, /* rightshift */
2011 1, /* size (0 = byte, 1 = short, 2 = long) */
2013 FALSE, /* pc_relative */
2015 complain_overflow_dont, /* complain_on_overflow */
2016 bfd_elf_generic_reloc, /* special_function */
2017 "R_PPC64_ADDR16_HIGH", /* name */
2018 FALSE, /* partial_inplace */
2020 0xffff, /* dst_mask */
2021 FALSE), /* pcrel_offset */
2023 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2024 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2025 16, /* rightshift */
2026 1, /* size (0 = byte, 1 = short, 2 = long) */
2028 FALSE, /* pc_relative */
2030 complain_overflow_dont, /* complain_on_overflow */
2031 ppc64_elf_ha_reloc, /* special_function */
2032 "R_PPC64_ADDR16_HIGHA", /* name */
2033 FALSE, /* partial_inplace */
2035 0xffff, /* dst_mask */
2036 FALSE), /* pcrel_offset */
2038 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2039 HOWTO (R_PPC64_DTPREL16_HIGH,
2040 16, /* rightshift */
2041 1, /* size (0 = byte, 1 = short, 2 = long) */
2043 FALSE, /* pc_relative */
2045 complain_overflow_dont, /* complain_on_overflow */
2046 ppc64_elf_unhandled_reloc, /* special_function */
2047 "R_PPC64_DTPREL16_HIGH", /* name */
2048 FALSE, /* partial_inplace */
2050 0xffff, /* dst_mask */
2051 FALSE), /* pcrel_offset */
2053 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2054 HOWTO (R_PPC64_DTPREL16_HIGHA,
2055 16, /* rightshift */
2056 1, /* size (0 = byte, 1 = short, 2 = long) */
2058 FALSE, /* pc_relative */
2060 complain_overflow_dont, /* complain_on_overflow */
2061 ppc64_elf_unhandled_reloc, /* special_function */
2062 "R_PPC64_DTPREL16_HIGHA", /* name */
2063 FALSE, /* partial_inplace */
2065 0xffff, /* dst_mask */
2066 FALSE), /* pcrel_offset */
2068 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2069 HOWTO (R_PPC64_TPREL16_HIGH,
2070 16, /* rightshift */
2071 1, /* size (0 = byte, 1 = short, 2 = long) */
2073 FALSE, /* pc_relative */
2075 complain_overflow_dont, /* complain_on_overflow */
2076 ppc64_elf_unhandled_reloc, /* special_function */
2077 "R_PPC64_TPREL16_HIGH", /* name */
2078 FALSE, /* partial_inplace */
2080 0xffff, /* dst_mask */
2081 FALSE), /* pcrel_offset */
2083 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2084 HOWTO (R_PPC64_TPREL16_HIGHA,
2085 16, /* rightshift */
2086 1, /* size (0 = byte, 1 = short, 2 = long) */
2088 FALSE, /* pc_relative */
2090 complain_overflow_dont, /* complain_on_overflow */
2091 ppc64_elf_unhandled_reloc, /* special_function */
2092 "R_PPC64_TPREL16_HIGHA", /* name */
2093 FALSE, /* partial_inplace */
2095 0xffff, /* dst_mask */
2096 FALSE), /* pcrel_offset */
2098 /* GNU extension to record C++ vtable hierarchy. */
2099 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2101 0, /* size (0 = byte, 1 = short, 2 = long) */
2103 FALSE, /* pc_relative */
2105 complain_overflow_dont, /* complain_on_overflow */
2106 NULL, /* special_function */
2107 "R_PPC64_GNU_VTINHERIT", /* name */
2108 FALSE, /* partial_inplace */
2111 FALSE), /* pcrel_offset */
2113 /* GNU extension to record C++ vtable member usage. */
2114 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2116 0, /* size (0 = byte, 1 = short, 2 = long) */
2118 FALSE, /* pc_relative */
2120 complain_overflow_dont, /* complain_on_overflow */
2121 NULL, /* special_function */
2122 "R_PPC64_GNU_VTENTRY", /* name */
2123 FALSE, /* partial_inplace */
2126 FALSE), /* pcrel_offset */
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2134 ppc_howto_init (void)
2136 unsigned int i, type;
2139 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2142 type = ppc64_elf_howto_raw[i].type;
2143 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144 / sizeof (ppc64_elf_howto_table[0])));
2145 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151 bfd_reloc_code_real_type code)
2153 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2155 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156 /* Initialize howto table if needed. */
2164 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2166 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2168 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2170 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2172 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2174 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2176 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2178 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2180 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2182 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2184 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2186 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2188 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2190 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2192 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2194 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2196 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2198 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2200 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2202 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2204 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2206 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2208 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2210 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2212 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2214 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2216 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2218 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2220 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2222 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2224 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2226 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2228 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2230 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2232 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2234 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2236 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2238 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2240 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2242 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2244 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2246 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2248 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2250 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2252 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2254 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2256 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2258 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2260 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2262 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2264 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2266 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2268 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2270 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2272 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2274 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2276 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2278 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2280 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2282 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2284 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2286 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2288 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2290 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2292 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2294 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2296 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2298 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2300 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2302 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2304 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2306 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2308 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2310 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2312 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2314 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2316 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2318 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2320 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2322 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2324 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2326 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2328 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2330 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2332 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2334 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2336 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2338 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2340 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2342 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2344 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2346 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2348 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2350 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2352 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2354 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2356 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2358 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2360 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2362 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2364 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2366 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2368 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2370 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2372 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2374 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2376 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2378 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2380 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2382 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2384 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2386 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2388 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2392 return ppc64_elf_howto_table[r];
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2402 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2404 if (ppc64_elf_howto_raw[i].name != NULL
2405 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406 return &ppc64_elf_howto_raw[i];
2411 /* Set the howto pointer for a PowerPC ELF reloc. */
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415 Elf_Internal_Rela *dst)
2419 /* Initialize howto table if needed. */
2420 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2423 type = ELF64_R_TYPE (dst->r_info);
2424 if (type >= (sizeof (ppc64_elf_howto_table)
2425 / sizeof (ppc64_elf_howto_table[0])))
2427 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2429 type = R_PPC64_NONE;
2431 cache_ptr->howto = ppc64_elf_howto_table[type];
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438 void *data, asection *input_section,
2439 bfd *output_bfd, char **error_message)
2441 /* If this is a relocatable link (output_bfd test tells us), just
2442 call the generic function. Any adjustment will be done at final
2444 if (output_bfd != NULL)
2445 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446 input_section, output_bfd, error_message);
2448 /* Adjust the addend for sign extension of the low 16 bits.
2449 We won't actually be using the low 16 bits, so trashing them
2451 reloc_entry->addend += 0x8000;
2452 return bfd_reloc_continue;
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457 void *data, asection *input_section,
2458 bfd *output_bfd, char **error_message)
2460 if (output_bfd != NULL)
2461 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462 input_section, output_bfd, error_message);
2464 if (strcmp (symbol->section->name, ".opd") == 0
2465 && (symbol->section->owner->flags & DYNAMIC) == 0)
2467 bfd_vma dest = opd_entry_value (symbol->section,
2468 symbol->value + reloc_entry->addend,
2470 if (dest != (bfd_vma) -1)
2471 reloc_entry->addend = dest - (symbol->value
2472 + symbol->section->output_section->vma
2473 + symbol->section->output_offset);
2475 return bfd_reloc_continue;
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480 void *data, asection *input_section,
2481 bfd *output_bfd, char **error_message)
2484 enum elf_ppc64_reloc_type r_type;
2485 bfd_size_type octets;
2486 /* Assume 'at' branch hints. */
2487 bfd_boolean is_isa_v2 = TRUE;
2489 /* If this is a relocatable link (output_bfd test tells us), just
2490 call the generic function. Any adjustment will be done at final
2492 if (output_bfd != NULL)
2493 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494 input_section, output_bfd, error_message);
2496 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498 insn &= ~(0x01 << 21);
2499 r_type = reloc_entry->howto->type;
2500 if (r_type == R_PPC64_ADDR14_BRTAKEN
2501 || r_type == R_PPC64_REL14_BRTAKEN)
2502 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2506 /* Set 'a' bit. This is 0b00010 in BO field for branch
2507 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508 for branch on CTR insns (BO == 1a00t or 1a01t). */
2509 if ((insn & (0x14 << 21)) == (0x04 << 21))
2511 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2521 if (!bfd_is_com_section (symbol->section))
2522 target = symbol->value;
2523 target += symbol->section->output_section->vma;
2524 target += symbol->section->output_offset;
2525 target += reloc_entry->addend;
2527 from = (reloc_entry->address
2528 + input_section->output_offset
2529 + input_section->output_section->vma);
2531 /* Invert 'y' bit if not the default. */
2532 if ((bfd_signed_vma) (target - from) < 0)
2535 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2537 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538 input_section, output_bfd, error_message);
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543 void *data, asection *input_section,
2544 bfd *output_bfd, char **error_message)
2546 /* If this is a relocatable link (output_bfd test tells us), just
2547 call the generic function. Any adjustment will be done at final
2549 if (output_bfd != NULL)
2550 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551 input_section, output_bfd, error_message);
2553 /* Subtract the symbol section base address. */
2554 reloc_entry->addend -= symbol->section->output_section->vma;
2555 return bfd_reloc_continue;
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560 void *data, asection *input_section,
2561 bfd *output_bfd, char **error_message)
2563 /* If this is a relocatable link (output_bfd test tells us), just
2564 call the generic function. Any adjustment will be done at final
2566 if (output_bfd != NULL)
2567 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568 input_section, output_bfd, error_message);
2570 /* Subtract the symbol section base address. */
2571 reloc_entry->addend -= symbol->section->output_section->vma;
2573 /* Adjust the addend for sign extension of the low 16 bits. */
2574 reloc_entry->addend += 0x8000;
2575 return bfd_reloc_continue;
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580 void *data, asection *input_section,
2581 bfd *output_bfd, char **error_message)
2585 /* If this is a relocatable link (output_bfd test tells us), just
2586 call the generic function. Any adjustment will be done at final
2588 if (output_bfd != NULL)
2589 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590 input_section, output_bfd, error_message);
2592 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2594 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2596 /* Subtract the TOC base address. */
2597 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598 return bfd_reloc_continue;
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 void *data, asection *input_section,
2604 bfd *output_bfd, char **error_message)
2608 /* If this is a relocatable link (output_bfd test tells us), just
2609 call the generic function. Any adjustment will be done at final
2611 if (output_bfd != NULL)
2612 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613 input_section, output_bfd, error_message);
2615 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2617 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2619 /* Subtract the TOC base address. */
2620 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2622 /* Adjust the addend for sign extension of the low 16 bits. */
2623 reloc_entry->addend += 0x8000;
2624 return bfd_reloc_continue;
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629 void *data, asection *input_section,
2630 bfd *output_bfd, char **error_message)
2633 bfd_size_type octets;
2635 /* If this is a relocatable link (output_bfd test tells us), just
2636 call the generic function. Any adjustment will be done at final
2638 if (output_bfd != NULL)
2639 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640 input_section, output_bfd, error_message);
2642 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2646 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648 return bfd_reloc_ok;
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653 void *data, asection *input_section,
2654 bfd *output_bfd, char **error_message)
2656 /* If this is a relocatable link (output_bfd test tells us), just
2657 call the generic function. Any adjustment will be done at final
2659 if (output_bfd != NULL)
2660 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661 input_section, output_bfd, error_message);
2663 if (error_message != NULL)
2665 static char buf[60];
2666 sprintf (buf, "generic linker can't handle %s",
2667 reloc_entry->howto->name);
2668 *error_message = buf;
2670 return bfd_reloc_dangerous;
2673 /* Track GOT entries needed for a given symbol. We might need more
2674 than one got entry per symbol. */
2677 struct got_entry *next;
2679 /* The symbol addend that we'll be placing in the GOT. */
2682 /* Unlike other ELF targets, we use separate GOT entries for the same
2683 symbol referenced from different input files. This is to support
2684 automatic multiple TOC/GOT sections, where the TOC base can vary
2685 from one input file to another. After partitioning into TOC groups
2686 we merge entries within the group.
2688 Point to the BFD owning this GOT entry. */
2691 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692 TLS_TPREL or TLS_DTPREL for tls entries. */
2693 unsigned char tls_type;
2695 /* Non-zero if got.ent points to real entry. */
2696 unsigned char is_indirect;
2698 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2701 bfd_signed_vma refcount;
2703 struct got_entry *ent;
2707 /* The same for PLT. */
2710 struct plt_entry *next;
2716 bfd_signed_vma refcount;
2721 struct ppc64_elf_obj_tdata
2723 struct elf_obj_tdata elf;
2725 /* Shortcuts to dynamic linker sections. */
2729 /* Used during garbage collection. We attach global symbols defined
2730 on removed .opd entries to this section so that the sym is removed. */
2731 asection *deleted_section;
2733 /* TLS local dynamic got entry handling. Support for multiple GOT
2734 sections means we potentially need one of these for each input bfd. */
2735 struct got_entry tlsld_got;
2738 /* A copy of relocs before they are modified for --emit-relocs. */
2739 Elf_Internal_Rela *relocs;
2741 /* Section contents. */
2745 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746 the reloc to be in the range -32768 to 32767. */
2747 unsigned int has_small_toc_reloc : 1;
2749 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750 instruction not one we handle. */
2751 unsigned int unexpected_toc_insn : 1;
2754 #define ppc64_elf_tdata(bfd) \
2755 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2757 #define ppc64_tlsld_got(bfd) \
2758 (&ppc64_elf_tdata (bfd)->tlsld_got)
2760 #define is_ppc64_elf(bfd) \
2761 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762 && elf_object_id (bfd) == PPC64_ELF_DATA)
2764 /* Override the generic function because we store some extras. */
2767 ppc64_elf_mkobject (bfd *abfd)
2769 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774 default is 32 bit. */
2777 ppc64_elf_object_p (bfd *abfd)
2779 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2781 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2783 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2785 /* Relies on arch after 32 bit default being 64 bit default. */
2786 abfd->arch_info = abfd->arch_info->next;
2787 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2793 /* Support for core dump NOTE sections. */
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2798 size_t offset, size;
2800 if (note->descsz != 504)
2804 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2807 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2813 /* Make a ".reg/999" section. */
2814 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815 size, note->descpos + offset);
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2821 if (note->descsz != 136)
2824 elf_tdata (abfd)->core->pid
2825 = bfd_get_32 (abfd, note->descdata + 24);
2826 elf_tdata (abfd)->core->program
2827 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828 elf_tdata (abfd)->core->command
2829 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2848 va_start (ap, note_type);
2849 memset (data, 0, sizeof (data));
2850 strncpy (data + 40, va_arg (ap, const char *), 16);
2851 strncpy (data + 56, va_arg (ap, const char *), 80);
2853 return elfcore_write_note (abfd, buf, bufsiz,
2854 "CORE", note_type, data, sizeof (data));
2865 va_start (ap, note_type);
2866 memset (data, 0, 112);
2867 pid = va_arg (ap, long);
2868 bfd_put_32 (abfd, pid, data + 32);
2869 cursig = va_arg (ap, int);
2870 bfd_put_16 (abfd, cursig, data + 12);
2871 greg = va_arg (ap, const void *);
2872 memcpy (data + 112, greg, 384);
2873 memset (data + 496, 0, 8);
2875 return elfcore_write_note (abfd, buf, bufsiz,
2876 "CORE", note_type, data, sizeof (data));
2881 /* Add extra PPC sections. */
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2885 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2886 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2887 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2891 { NULL, 0, 0, 0, 0 }
2894 enum _ppc64_sec_type {
2900 struct _ppc64_elf_section_data
2902 struct bfd_elf_section_data elf;
2906 /* An array with one entry for each opd function descriptor. */
2907 struct _opd_sec_data
2909 /* Points to the function code section for local opd entries. */
2910 asection **func_sec;
2912 /* After editing .opd, adjust references to opd local syms. */
2916 /* An array for toc sections, indexed by offset/8. */
2917 struct _toc_sec_data
2919 /* Specifies the relocation symbol index used at a given toc offset. */
2922 /* And the relocation addend. */
2927 enum _ppc64_sec_type sec_type:2;
2929 /* Flag set when small branches are detected. Used to
2930 select suitable defaults for the stub group size. */
2931 unsigned int has_14bit_branch:1;
2934 #define ppc64_elf_section_data(sec) \
2935 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2940 if (!sec->used_by_bfd)
2942 struct _ppc64_elf_section_data *sdata;
2943 bfd_size_type amt = sizeof (*sdata);
2945 sdata = bfd_zalloc (abfd, amt);
2948 sec->used_by_bfd = sdata;
2951 return _bfd_elf_new_section_hook (abfd, sec);
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2958 && ppc64_elf_section_data (sec) != NULL
2959 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960 return &ppc64_elf_section_data (sec)->u.opd;
2965 abiversion (bfd *abfd)
2967 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2971 set_abiversion (bfd *abfd, int ver)
2973 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2977 /* Parameters for the qsort hook. */
2978 static bfd_boolean synthetic_relocatable;
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2983 compare_symbols (const void *ap, const void *bp)
2985 const asymbol *a = * (const asymbol **) ap;
2986 const asymbol *b = * (const asymbol **) bp;
2988 /* Section symbols first. */
2989 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2991 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2994 /* then .opd symbols. */
2995 if (strcmp (a->section->name, ".opd") == 0
2996 && strcmp (b->section->name, ".opd") != 0)
2998 if (strcmp (a->section->name, ".opd") != 0
2999 && strcmp (b->section->name, ".opd") == 0)
3002 /* then other code symbols. */
3003 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004 == (SEC_CODE | SEC_ALLOC)
3005 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006 != (SEC_CODE | SEC_ALLOC))
3009 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010 != (SEC_CODE | SEC_ALLOC)
3011 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012 == (SEC_CODE | SEC_ALLOC))
3015 if (synthetic_relocatable)
3017 if (a->section->id < b->section->id)
3020 if (a->section->id > b->section->id)
3024 if (a->value + a->section->vma < b->value + b->section->vma)
3027 if (a->value + a->section->vma > b->value + b->section->vma)
3030 /* For syms with the same value, prefer strong dynamic global function
3031 syms over other syms. */
3032 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3035 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3038 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3041 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3044 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3047 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3050 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3053 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3059 /* Search SYMS for a symbol of the given VALUE. */
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3070 mid = (lo + hi) >> 1;
3071 if (syms[mid]->value + syms[mid]->section->vma < value)
3073 else if (syms[mid]->value + syms[mid]->section->vma > value)
3083 mid = (lo + hi) >> 1;
3084 if (syms[mid]->section->id < id)
3086 else if (syms[mid]->section->id > id)
3088 else if (syms[mid]->value < value)
3090 else if (syms[mid]->value > value)
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3102 bfd_vma vma = *(bfd_vma *) ptr;
3103 return ((section->flags & SEC_ALLOC) != 0
3104 && section->vma <= vma
3105 && vma < section->vma + section->size);
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109 entry syms. Also generate @plt symbols for the glink branch table. */
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113 long static_count, asymbol **static_syms,
3114 long dyn_count, asymbol **dyn_syms,
3121 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122 asection *opd = NULL;
3123 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3125 int abi = abiversion (abfd);
3131 opd = bfd_get_section_by_name (abfd, ".opd");
3132 if (opd == NULL && abi == 1)
3136 symcount = static_count;
3138 symcount += dyn_count;
3142 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3146 if (!relocatable && static_count != 0 && dyn_count != 0)
3148 /* Use both symbol tables. */
3149 memcpy (syms, static_syms, static_count * sizeof (*syms));
3150 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3152 else if (!relocatable && static_count == 0)
3153 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3155 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3157 synthetic_relocatable = relocatable;
3158 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3160 if (!relocatable && symcount > 1)
3163 /* Trim duplicate syms, since we may have merged the normal and
3164 dynamic symbols. Actually, we only care about syms that have
3165 different values, so trim any with the same value. */
3166 for (i = 1, j = 1; i < symcount; ++i)
3167 if (syms[i - 1]->value + syms[i - 1]->section->vma
3168 != syms[i]->value + syms[i]->section->vma)
3169 syms[j++] = syms[i];
3174 if (strcmp (syms[i]->section->name, ".opd") == 0)
3178 for (; i < symcount; ++i)
3179 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180 != (SEC_CODE | SEC_ALLOC))
3181 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3185 for (; i < symcount; ++i)
3186 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3190 for (; i < symcount; ++i)
3191 if (strcmp (syms[i]->section->name, ".opd") != 0)
3195 for (; i < symcount; ++i)
3196 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197 != (SEC_CODE | SEC_ALLOC))
3205 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3210 if (opdsymend == secsymend)
3213 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3218 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3225 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3229 while (r < opd->relocation + relcount
3230 && r->address < syms[i]->value + opd->vma)
3233 if (r == opd->relocation + relcount)
3236 if (r->address != syms[i]->value + opd->vma)
3239 if (r->howto->type != R_PPC64_ADDR64)
3242 sym = *r->sym_ptr_ptr;
3243 if (!sym_exists_at (syms, opdsymend, symcount,
3244 sym->section->id, sym->value + r->addend))
3247 size += sizeof (asymbol);
3248 size += strlen (syms[i]->name) + 2;
3252 s = *ret = bfd_malloc (size);
3259 names = (char *) (s + count);
3261 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3265 while (r < opd->relocation + relcount
3266 && r->address < syms[i]->value + opd->vma)
3269 if (r == opd->relocation + relcount)
3272 if (r->address != syms[i]->value + opd->vma)
3275 if (r->howto->type != R_PPC64_ADDR64)
3278 sym = *r->sym_ptr_ptr;
3279 if (!sym_exists_at (syms, opdsymend, symcount,
3280 sym->section->id, sym->value + r->addend))
3285 s->flags |= BSF_SYNTHETIC;
3286 s->section = sym->section;
3287 s->value = sym->value + r->addend;
3290 len = strlen (syms[i]->name);
3291 memcpy (names, syms[i]->name, len + 1);
3293 /* Have udata.p point back to the original symbol this
3294 synthetic symbol was derived from. */
3295 s->udata.p = syms[i];
3302 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303 bfd_byte *contents = NULL;
3306 bfd_vma glink_vma = 0, resolv_vma = 0;
3307 asection *dynamic, *glink = NULL, *relplt = NULL;
3310 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3312 free_contents_and_exit:
3320 for (i = secsymend; i < opdsymend; ++i)
3324 /* Ignore bogus symbols. */
3325 if (syms[i]->value > opd->size - 8)
3328 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3332 size += sizeof (asymbol);
3333 size += strlen (syms[i]->name) + 2;
3337 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3339 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3341 bfd_byte *dynbuf, *extdyn, *extdynend;
3343 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3345 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346 goto free_contents_and_exit;
3348 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3352 extdynend = extdyn + dynamic->size;
3353 for (; extdyn < extdynend; extdyn += extdynsize)
3355 Elf_Internal_Dyn dyn;
3356 (*swap_dyn_in) (abfd, extdyn, &dyn);
3358 if (dyn.d_tag == DT_NULL)
3361 if (dyn.d_tag == DT_PPC64_GLINK)
3363 /* The first glink stub starts at offset 32; see
3364 comment in ppc64_elf_finish_dynamic_sections. */
3365 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366 /* The .glink section usually does not survive the final
3367 link; search for the section (usually .text) where the
3368 glink stubs now reside. */
3369 glink = bfd_sections_find_if (abfd, section_covers_vma,
3380 /* Determine __glink trampoline by reading the relative branch
3381 from the first glink stub. */
3383 unsigned int off = 0;
3385 while (bfd_get_section_contents (abfd, glink, buf,
3386 glink_vma + off - glink->vma, 4))
3388 unsigned int insn = bfd_get_32 (abfd, buf);
3390 if ((insn & ~0x3fffffc) == 0)
3392 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3401 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3403 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3406 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408 goto free_contents_and_exit;
3410 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411 size += plt_count * sizeof (asymbol);
3413 p = relplt->relocation;
3414 for (i = 0; i < plt_count; i++, p++)
3416 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3418 size += sizeof ("+0x") - 1 + 16;
3423 s = *ret = bfd_malloc (size);
3425 goto free_contents_and_exit;
3427 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3429 for (i = secsymend; i < opdsymend; ++i)
3433 if (syms[i]->value > opd->size - 8)
3436 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3441 asection *sec = abfd->sections;
3448 long mid = (lo + hi) >> 1;
3449 if (syms[mid]->section->vma < ent)
3451 else if (syms[mid]->section->vma > ent)
3455 sec = syms[mid]->section;
3460 if (lo >= hi && lo > codesecsym)
3461 sec = syms[lo - 1]->section;
3463 for (; sec != NULL; sec = sec->next)
3467 /* SEC_LOAD may not be set if SEC is from a separate debug
3469 if ((sec->flags & SEC_ALLOC) == 0)
3471 if ((sec->flags & SEC_CODE) != 0)
3474 s->flags |= BSF_SYNTHETIC;
3475 s->value = ent - s->section->vma;
3478 len = strlen (syms[i]->name);
3479 memcpy (names, syms[i]->name, len + 1);
3481 /* Have udata.p point back to the original symbol this
3482 synthetic symbol was derived from. */
3483 s->udata.p = syms[i];
3489 if (glink != NULL && relplt != NULL)
3493 /* Add a symbol for the main glink trampoline. */
3494 memset (s, 0, sizeof *s);
3496 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3498 s->value = resolv_vma - glink->vma;
3500 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501 names += sizeof ("__glink_PLTresolve");
3506 /* FIXME: It would be very much nicer to put sym@plt on the
3507 stub rather than on the glink branch table entry. The
3508 objdump disassembler would then use a sensible symbol
3509 name on plt calls. The difficulty in doing so is
3510 a) finding the stubs, and,
3511 b) matching stubs against plt entries, and,
3512 c) there can be multiple stubs for a given plt entry.
3514 Solving (a) could be done by code scanning, but older
3515 ppc64 binaries used different stubs to current code.
3516 (b) is the tricky one since you need to known the toc
3517 pointer for at least one function that uses a pic stub to
3518 be able to calculate the plt address referenced.
3519 (c) means gdb would need to set multiple breakpoints (or
3520 find the glink branch itself) when setting breakpoints
3521 for pending shared library loads. */
3522 p = relplt->relocation;
3523 for (i = 0; i < plt_count; i++, p++)
3527 *s = **p->sym_ptr_ptr;
3528 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3529 we are defining a symbol, ensure one of them is set. */
3530 if ((s->flags & BSF_LOCAL) == 0)
3531 s->flags |= BSF_GLOBAL;
3532 s->flags |= BSF_SYNTHETIC;
3534 s->value = glink_vma - glink->vma;
3537 len = strlen ((*p->sym_ptr_ptr)->name);
3538 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3542 memcpy (names, "+0x", sizeof ("+0x") - 1);
3543 names += sizeof ("+0x") - 1;
3544 bfd_sprintf_vma (abfd, names, p->addend);
3545 names += strlen (names);
3547 memcpy (names, "@plt", sizeof ("@plt"));
3548 names += sizeof ("@plt");
3568 /* The following functions are specific to the ELF linker, while
3569 functions above are used generally. Those named ppc64_elf_* are
3570 called by the main ELF linker code. They appear in this file more
3571 or less in the order in which they are called. eg.
3572 ppc64_elf_check_relocs is called early in the link process,
3573 ppc64_elf_finish_dynamic_sections is one of the last functions
3576 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577 functions have both a function code symbol and a function descriptor
3578 symbol. A call to foo in a relocatable object file looks like:
3585 The function definition in another object file might be:
3589 . .quad .TOC.@tocbase
3595 When the linker resolves the call during a static link, the branch
3596 unsurprisingly just goes to .foo and the .opd information is unused.
3597 If the function definition is in a shared library, things are a little
3598 different: The call goes via a plt call stub, the opd information gets
3599 copied to the plt, and the linker patches the nop.
3607 . std 2,40(1) # in practice, the call stub
3608 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3609 . addi 11,11,Lfoo@toc@l # this is the general idea
3617 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3619 The "reloc ()" notation is supposed to indicate that the linker emits
3620 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3623 What are the difficulties here? Well, firstly, the relocations
3624 examined by the linker in check_relocs are against the function code
3625 sym .foo, while the dynamic relocation in the plt is emitted against
3626 the function descriptor symbol, foo. Somewhere along the line, we need
3627 to carefully copy dynamic link information from one symbol to the other.
3628 Secondly, the generic part of the elf linker will make .foo a dynamic
3629 symbol as is normal for most other backends. We need foo dynamic
3630 instead, at least for an application final link. However, when
3631 creating a shared library containing foo, we need to have both symbols
3632 dynamic so that references to .foo are satisfied during the early
3633 stages of linking. Otherwise the linker might decide to pull in a
3634 definition from some other object, eg. a static library.
3636 Update: As of August 2004, we support a new convention. Function
3637 calls may use the function descriptor symbol, ie. "bl foo". This
3638 behaves exactly as "bl .foo". */
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641 selects those that must be copied when linking a shared library,
3642 even when the symbol is local. */
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646 enum elf_ppc64_reloc_type r_type)
3658 case R_PPC64_TPREL16:
3659 case R_PPC64_TPREL16_LO:
3660 case R_PPC64_TPREL16_HI:
3661 case R_PPC64_TPREL16_HA:
3662 case R_PPC64_TPREL16_DS:
3663 case R_PPC64_TPREL16_LO_DS:
3664 case R_PPC64_TPREL16_HIGH:
3665 case R_PPC64_TPREL16_HIGHA:
3666 case R_PPC64_TPREL16_HIGHER:
3667 case R_PPC64_TPREL16_HIGHERA:
3668 case R_PPC64_TPREL16_HIGHEST:
3669 case R_PPC64_TPREL16_HIGHESTA:
3670 case R_PPC64_TPREL64:
3671 return !info->executable;
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676 copying dynamic variables from a shared lib into an app's dynbss
3677 section, and instead use a dynamic relocation to point into the
3678 shared lib. With code that gcc generates, it's vital that this be
3679 enabled; In the PowerPC64 ABI, the address of a function is actually
3680 the address of a function descriptor, which resides in the .opd
3681 section. gcc uses the descriptor directly rather than going via the
3682 GOT as some other ABI's do, which means that initialized function
3683 pointers must reference the descriptor. Thus, a function pointer
3684 initialized to the address of a function in a shared library will
3685 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3686 redefines the function descriptor symbol to point to the copy. This
3687 presents a problem as a plt entry for that function is also
3688 initialized from the function descriptor symbol and the copy reloc
3689 may not be initialized first. */
3690 #define ELIMINATE_COPY_RELOCS 1
3692 /* Section name for stubs is the associated section name plus this
3694 #define STUB_SUFFIX ".stub"
3697 ppc_stub_long_branch:
3698 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699 destination, but a 24 bit branch in a stub section will reach.
3702 ppc_stub_plt_branch:
3703 Similar to the above, but a 24 bit branch in the stub section won't
3704 reach its destination.
3705 . addis %r11,%r2,xxx@toc@ha
3706 . ld %r12,xxx@toc@l(%r11)
3711 Used to call a function in a shared library. If it so happens that
3712 the plt entry referenced crosses a 64k boundary, then an extra
3713 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3715 . addis %r11,%r2,xxx@toc@ha
3716 . ld %r12,xxx+0@toc@l(%r11)
3718 . ld %r2,xxx+8@toc@l(%r11)
3719 . ld %r11,xxx+16@toc@l(%r11)
3722 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723 code to adjust the value and save r2 to support multiple toc sections.
3724 A ppc_stub_long_branch with an r2 offset looks like:
3726 . addis %r2,%r2,off@ha
3727 . addi %r2,%r2,off@l
3730 A ppc_stub_plt_branch with an r2 offset looks like:
3732 . addis %r11,%r2,xxx@toc@ha
3733 . ld %r12,xxx@toc@l(%r11)
3734 . addis %r2,%r2,off@ha
3735 . addi %r2,%r2,off@l
3739 In cases where the "addis" instruction would add zero, the "addis" is
3740 omitted and following instructions modified slightly in some cases.
3743 enum ppc_stub_type {
3745 ppc_stub_long_branch,
3746 ppc_stub_long_branch_r2off,
3747 ppc_stub_plt_branch,
3748 ppc_stub_plt_branch_r2off,
3750 ppc_stub_plt_call_r2save
3753 struct ppc_stub_hash_entry {
3755 /* Base hash table entry structure. */
3756 struct bfd_hash_entry root;
3758 enum ppc_stub_type stub_type;
3760 /* The stub section. */
3763 /* Offset within stub_sec of the beginning of this stub. */
3764 bfd_vma stub_offset;
3766 /* Given the symbol's value and its section we can determine its final
3767 value when building the stubs (so the stub knows where to jump. */
3768 bfd_vma target_value;
3769 asection *target_section;
3771 /* The symbol table entry, if any, that this was derived from. */
3772 struct ppc_link_hash_entry *h;
3773 struct plt_entry *plt_ent;
3775 /* Where this stub is being called from, or, in the case of combined
3776 stub sections, the first input section in the group. */
3779 /* Symbol st_other. */
3780 unsigned char other;
3783 struct ppc_branch_hash_entry {
3785 /* Base hash table entry structure. */
3786 struct bfd_hash_entry root;
3788 /* Offset within branch lookup table. */
3789 unsigned int offset;
3791 /* Generation marker. */
3795 /* Used to track dynamic relocations for local symbols. */
3796 struct ppc_dyn_relocs
3798 struct ppc_dyn_relocs *next;
3800 /* The input section of the reloc. */
3803 /* Total number of relocs copied for the input section. */
3804 unsigned int count : 31;
3806 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3807 unsigned int ifunc : 1;
3810 struct ppc_link_hash_entry
3812 struct elf_link_hash_entry elf;
3815 /* A pointer to the most recently used stub hash entry against this
3817 struct ppc_stub_hash_entry *stub_cache;
3819 /* A pointer to the next symbol starting with a '.' */
3820 struct ppc_link_hash_entry *next_dot_sym;
3823 /* Track dynamic relocs copied for this symbol. */
3824 struct elf_dyn_relocs *dyn_relocs;
3826 /* Link between function code and descriptor symbols. */
3827 struct ppc_link_hash_entry *oh;
3829 /* Flag function code and descriptor symbols. */
3830 unsigned int is_func:1;
3831 unsigned int is_func_descriptor:1;
3832 unsigned int fake:1;
3834 /* Whether global opd/toc sym has been adjusted or not.
3835 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836 should be set for all globals defined in any opd/toc section. */
3837 unsigned int adjust_done:1;
3839 /* Set if we twiddled this symbol to weak at some stage. */
3840 unsigned int was_undefined:1;
3842 /* Contexts in which symbol is used in the GOT (or TOC).
3843 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844 corresponding relocs are encountered during check_relocs.
3845 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846 indicate the corresponding GOT entry type is not needed.
3847 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848 a TPREL one. We use a separate flag rather than setting TPREL
3849 just for convenience in distinguishing the two cases. */
3850 #define TLS_GD 1 /* GD reloc. */
3851 #define TLS_LD 2 /* LD reloc. */
3852 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3853 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3854 #define TLS_TLS 16 /* Any TLS reloc. */
3855 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3858 unsigned char tls_mask;
3861 /* ppc64 ELF linker hash table. */
3863 struct ppc_link_hash_table
3865 struct elf_link_hash_table elf;
3867 /* The stub hash table. */
3868 struct bfd_hash_table stub_hash_table;
3870 /* Another hash table for plt_branch stubs. */
3871 struct bfd_hash_table branch_hash_table;
3873 /* Hash table for function prologue tocsave. */
3874 htab_t tocsave_htab;
3876 /* Various options and other info passed from the linker. */
3877 struct ppc64_elf_params *params;
3879 /* Array to keep track of which stub sections have been created, and
3880 information on stub grouping. */
3882 /* This is the section to which stubs in the group will be attached. */
3884 /* The stub section. */
3886 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3890 /* Temp used when calculating TOC pointers. */
3893 asection *toc_first_sec;
3895 /* Highest input section id. */
3898 /* Highest output section index. */
3901 /* Used when adding symbols. */
3902 struct ppc_link_hash_entry *dot_syms;
3904 /* List of input sections for each output section. */
3905 asection **input_list;
3907 /* Shortcuts to get to dynamic linker sections. */
3914 asection *glink_eh_frame;
3916 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3917 struct ppc_link_hash_entry *tls_get_addr;
3918 struct ppc_link_hash_entry *tls_get_addr_fd;
3920 /* The size of reliplt used by got entry relocs. */
3921 bfd_size_type got_reli_size;
3924 unsigned long stub_count[ppc_stub_plt_call_r2save];
3926 /* Number of stubs against global syms. */
3927 unsigned long stub_globals;
3929 /* Set if we're linking code with function descriptors. */
3930 unsigned int opd_abi:1;
3932 /* Support for multiple toc sections. */
3933 unsigned int do_multi_toc:1;
3934 unsigned int multi_toc_needed:1;
3935 unsigned int second_toc_pass:1;
3936 unsigned int do_toc_opt:1;
3939 unsigned int stub_error:1;
3941 /* Temp used by ppc64_elf_process_dot_syms. */
3942 unsigned int twiddled_syms:1;
3944 /* Incremented every time we size stubs. */
3945 unsigned int stub_iteration;
3947 /* Small local sym cache. */
3948 struct sym_cache sym_cache;
3951 /* Rename some of the generic section flags to better document how they
3954 /* Nonzero if this section has TLS related relocations. */
3955 #define has_tls_reloc sec_flg0
3957 /* Nonzero if this section has a call to __tls_get_addr. */
3958 #define has_tls_get_addr_call sec_flg1
3960 /* Nonzero if this section has any toc or got relocs. */
3961 #define has_toc_reloc sec_flg2
3963 /* Nonzero if this section has a call to another section that uses
3965 #define makes_toc_func_call sec_flg3
3967 /* Recursion protection when determining above flag. */
3968 #define call_check_in_progress sec_flg4
3969 #define call_check_done sec_flg5
3971 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3973 #define ppc_hash_table(p) \
3974 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3975 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3977 #define ppc_stub_hash_lookup(table, string, create, copy) \
3978 ((struct ppc_stub_hash_entry *) \
3979 bfd_hash_lookup ((table), (string), (create), (copy)))
3981 #define ppc_branch_hash_lookup(table, string, create, copy) \
3982 ((struct ppc_branch_hash_entry *) \
3983 bfd_hash_lookup ((table), (string), (create), (copy)))
3985 /* Create an entry in the stub hash table. */
3987 static struct bfd_hash_entry *
3988 stub_hash_newfunc (struct bfd_hash_entry *entry,
3989 struct bfd_hash_table *table,
3992 /* Allocate the structure if it has not already been allocated by a
3996 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4001 /* Call the allocation method of the superclass. */
4002 entry = bfd_hash_newfunc (entry, table, string);
4005 struct ppc_stub_hash_entry *eh;
4007 /* Initialize the local fields. */
4008 eh = (struct ppc_stub_hash_entry *) entry;
4009 eh->stub_type = ppc_stub_none;
4010 eh->stub_sec = NULL;
4011 eh->stub_offset = 0;
4012 eh->target_value = 0;
4013 eh->target_section = NULL;
4023 /* Create an entry in the branch hash table. */
4025 static struct bfd_hash_entry *
4026 branch_hash_newfunc (struct bfd_hash_entry *entry,
4027 struct bfd_hash_table *table,
4030 /* Allocate the structure if it has not already been allocated by a
4034 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4039 /* Call the allocation method of the superclass. */
4040 entry = bfd_hash_newfunc (entry, table, string);
4043 struct ppc_branch_hash_entry *eh;
4045 /* Initialize the local fields. */
4046 eh = (struct ppc_branch_hash_entry *) entry;
4054 /* Create an entry in a ppc64 ELF linker hash table. */
4056 static struct bfd_hash_entry *
4057 link_hash_newfunc (struct bfd_hash_entry *entry,
4058 struct bfd_hash_table *table,
4061 /* Allocate the structure if it has not already been allocated by a
4065 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4070 /* Call the allocation method of the superclass. */
4071 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4074 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4076 memset (&eh->u.stub_cache, 0,
4077 (sizeof (struct ppc_link_hash_entry)
4078 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4080 /* When making function calls, old ABI code references function entry
4081 points (dot symbols), while new ABI code references the function
4082 descriptor symbol. We need to make any combination of reference and
4083 definition work together, without breaking archive linking.
4085 For a defined function "foo" and an undefined call to "bar":
4086 An old object defines "foo" and ".foo", references ".bar" (possibly
4088 A new object defines "foo" and references "bar".
4090 A new object thus has no problem with its undefined symbols being
4091 satisfied by definitions in an old object. On the other hand, the
4092 old object won't have ".bar" satisfied by a new object.
4094 Keep a list of newly added dot-symbols. */
4096 if (string[0] == '.')
4098 struct ppc_link_hash_table *htab;
4100 htab = (struct ppc_link_hash_table *) table;
4101 eh->u.next_dot_sym = htab->dot_syms;
4102 htab->dot_syms = eh;
4109 struct tocsave_entry {
4115 tocsave_htab_hash (const void *p)
4117 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4118 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4122 tocsave_htab_eq (const void *p1, const void *p2)
4124 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4125 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4126 return e1->sec == e2->sec && e1->offset == e2->offset;
4129 /* Create a ppc64 ELF linker hash table. */
4131 static struct bfd_link_hash_table *
4132 ppc64_elf_link_hash_table_create (bfd *abfd)
4134 struct ppc_link_hash_table *htab;
4135 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4137 htab = bfd_zmalloc (amt);
4141 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4142 sizeof (struct ppc_link_hash_entry),
4149 /* Init the stub hash table too. */
4150 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4151 sizeof (struct ppc_stub_hash_entry)))
4153 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4157 /* And the branch hash table. */
4158 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4159 sizeof (struct ppc_branch_hash_entry)))
4161 bfd_hash_table_free (&htab->stub_hash_table);
4162 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4166 htab->tocsave_htab = htab_try_create (1024,
4170 if (htab->tocsave_htab == NULL)
4172 bfd_hash_table_free (&htab->branch_hash_table);
4173 bfd_hash_table_free (&htab->stub_hash_table);
4174 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4178 /* Initializing two fields of the union is just cosmetic. We really
4179 only care about glist, but when compiled on a 32-bit host the
4180 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4181 debugger inspection of these fields look nicer. */
4182 htab->elf.init_got_refcount.refcount = 0;
4183 htab->elf.init_got_refcount.glist = NULL;
4184 htab->elf.init_plt_refcount.refcount = 0;
4185 htab->elf.init_plt_refcount.glist = NULL;
4186 htab->elf.init_got_offset.offset = 0;
4187 htab->elf.init_got_offset.glist = NULL;
4188 htab->elf.init_plt_offset.offset = 0;
4189 htab->elf.init_plt_offset.glist = NULL;
4191 return &htab->elf.root;
4194 /* Free the derived linker hash table. */
4197 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4199 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4201 bfd_hash_table_free (&htab->stub_hash_table);
4202 bfd_hash_table_free (&htab->branch_hash_table);
4203 if (htab->tocsave_htab)
4204 htab_delete (htab->tocsave_htab);
4205 _bfd_elf_link_hash_table_free (hash);
4208 /* Create sections for linker generated code. */
4211 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4213 struct ppc_link_hash_table *htab;
4216 htab = ppc_hash_table (info);
4218 /* Create .sfpr for code to save and restore fp regs. */
4219 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4220 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4221 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4223 if (htab->sfpr == NULL
4224 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4227 /* Create .glink for lazy dynamic linking support. */
4228 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4230 if (htab->glink == NULL
4231 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4234 if (!info->no_ld_generated_unwind_info)
4236 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4237 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4238 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4241 if (htab->glink_eh_frame == NULL
4242 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4246 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4247 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4248 if (htab->elf.iplt == NULL
4249 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4252 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4253 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4255 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4256 if (htab->elf.irelplt == NULL
4257 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4260 /* Create branch lookup table for plt_branch stubs. */
4261 flags = (SEC_ALLOC | SEC_LOAD
4262 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4263 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4265 if (htab->brlt == NULL
4266 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4272 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4273 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4274 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4277 if (htab->relbrlt == NULL
4278 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4284 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4287 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4288 struct ppc64_elf_params *params)
4290 struct ppc_link_hash_table *htab;
4292 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4294 /* Always hook our dynamic sections into the first bfd, which is the
4295 linker created stub bfd. This ensures that the GOT header is at
4296 the start of the output TOC section. */
4297 htab = ppc_hash_table (info);
4300 htab->elf.dynobj = params->stub_bfd;
4301 htab->params = params;
4303 if (info->relocatable)
4306 return create_linkage_sections (htab->elf.dynobj, info);
4309 /* Build a name for an entry in the stub hash table. */
4312 ppc_stub_name (const asection *input_section,
4313 const asection *sym_sec,
4314 const struct ppc_link_hash_entry *h,
4315 const Elf_Internal_Rela *rel)
4320 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4321 offsets from a sym as a branch target? In fact, we could
4322 probably assume the addend is always zero. */
4323 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4327 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4328 stub_name = bfd_malloc (len);
4329 if (stub_name == NULL)
4332 len = sprintf (stub_name, "%08x.%s+%x",
4333 input_section->id & 0xffffffff,
4334 h->elf.root.root.string,
4335 (int) rel->r_addend & 0xffffffff);
4339 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4340 stub_name = bfd_malloc (len);
4341 if (stub_name == NULL)
4344 len = sprintf (stub_name, "%08x.%x:%x+%x",
4345 input_section->id & 0xffffffff,
4346 sym_sec->id & 0xffffffff,
4347 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4348 (int) rel->r_addend & 0xffffffff);
4350 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4351 stub_name[len - 2] = 0;
4355 /* Look up an entry in the stub hash. Stub entries are cached because
4356 creating the stub name takes a bit of time. */
4358 static struct ppc_stub_hash_entry *
4359 ppc_get_stub_entry (const asection *input_section,
4360 const asection *sym_sec,
4361 struct ppc_link_hash_entry *h,
4362 const Elf_Internal_Rela *rel,
4363 struct ppc_link_hash_table *htab)
4365 struct ppc_stub_hash_entry *stub_entry;
4366 const asection *id_sec;
4368 /* If this input section is part of a group of sections sharing one
4369 stub section, then use the id of the first section in the group.
4370 Stub names need to include a section id, as there may well be
4371 more than one stub used to reach say, printf, and we need to
4372 distinguish between them. */
4373 id_sec = htab->stub_group[input_section->id].link_sec;
4375 if (h != NULL && h->u.stub_cache != NULL
4376 && h->u.stub_cache->h == h
4377 && h->u.stub_cache->id_sec == id_sec)
4379 stub_entry = h->u.stub_cache;
4385 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4386 if (stub_name == NULL)
4389 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4390 stub_name, FALSE, FALSE);
4392 h->u.stub_cache = stub_entry;
4400 /* Add a new stub entry to the stub hash. Not all fields of the new
4401 stub entry are initialised. */
4403 static struct ppc_stub_hash_entry *
4404 ppc_add_stub (const char *stub_name,
4406 struct bfd_link_info *info)
4408 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4411 struct ppc_stub_hash_entry *stub_entry;
4413 link_sec = htab->stub_group[section->id].link_sec;
4414 stub_sec = htab->stub_group[section->id].stub_sec;
4415 if (stub_sec == NULL)
4417 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4418 if (stub_sec == NULL)
4424 namelen = strlen (link_sec->name);
4425 len = namelen + sizeof (STUB_SUFFIX);
4426 s_name = bfd_alloc (htab->params->stub_bfd, len);
4430 memcpy (s_name, link_sec->name, namelen);
4431 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4432 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4433 if (stub_sec == NULL)
4435 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4437 htab->stub_group[section->id].stub_sec = stub_sec;
4440 /* Enter this entry into the linker stub hash table. */
4441 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4443 if (stub_entry == NULL)
4445 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4446 section->owner, stub_name);
4450 stub_entry->stub_sec = stub_sec;
4451 stub_entry->stub_offset = 0;
4452 stub_entry->id_sec = link_sec;
4456 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4457 not already done. */
4460 create_got_section (bfd *abfd, struct bfd_link_info *info)
4462 asection *got, *relgot;
4464 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4466 if (!is_ppc64_elf (abfd))
4472 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4475 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4476 | SEC_LINKER_CREATED);
4478 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4480 || !bfd_set_section_alignment (abfd, got, 3))
4483 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4484 flags | SEC_READONLY);
4486 || ! bfd_set_section_alignment (abfd, relgot, 3))
4489 ppc64_elf_tdata (abfd)->got = got;
4490 ppc64_elf_tdata (abfd)->relgot = relgot;
4494 /* Create the dynamic sections, and set up shortcuts. */
4497 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4499 struct ppc_link_hash_table *htab;
4501 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4504 htab = ppc_hash_table (info);
4508 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4510 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4512 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4513 || (!info->shared && !htab->relbss))
4519 /* Follow indirect and warning symbol links. */
4521 static inline struct bfd_link_hash_entry *
4522 follow_link (struct bfd_link_hash_entry *h)
4524 while (h->type == bfd_link_hash_indirect
4525 || h->type == bfd_link_hash_warning)
4530 static inline struct elf_link_hash_entry *
4531 elf_follow_link (struct elf_link_hash_entry *h)
4533 return (struct elf_link_hash_entry *) follow_link (&h->root);
4536 static inline struct ppc_link_hash_entry *
4537 ppc_follow_link (struct ppc_link_hash_entry *h)
4539 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4542 /* Merge PLT info on FROM with that on TO. */
4545 move_plt_plist (struct ppc_link_hash_entry *from,
4546 struct ppc_link_hash_entry *to)
4548 if (from->elf.plt.plist != NULL)
4550 if (to->elf.plt.plist != NULL)
4552 struct plt_entry **entp;
4553 struct plt_entry *ent;
4555 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4557 struct plt_entry *dent;
4559 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4560 if (dent->addend == ent->addend)
4562 dent->plt.refcount += ent->plt.refcount;
4569 *entp = to->elf.plt.plist;
4572 to->elf.plt.plist = from->elf.plt.plist;
4573 from->elf.plt.plist = NULL;
4577 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4580 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4581 struct elf_link_hash_entry *dir,
4582 struct elf_link_hash_entry *ind)
4584 struct ppc_link_hash_entry *edir, *eind;
4586 edir = (struct ppc_link_hash_entry *) dir;
4587 eind = (struct ppc_link_hash_entry *) ind;
4589 edir->is_func |= eind->is_func;
4590 edir->is_func_descriptor |= eind->is_func_descriptor;
4591 edir->tls_mask |= eind->tls_mask;
4592 if (eind->oh != NULL)
4593 edir->oh = ppc_follow_link (eind->oh);
4595 /* If called to transfer flags for a weakdef during processing
4596 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4597 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4598 if (!(ELIMINATE_COPY_RELOCS
4599 && eind->elf.root.type != bfd_link_hash_indirect
4600 && edir->elf.dynamic_adjusted))
4601 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4603 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4604 edir->elf.ref_regular |= eind->elf.ref_regular;
4605 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4606 edir->elf.needs_plt |= eind->elf.needs_plt;
4607 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4609 /* Copy over any dynamic relocs we may have on the indirect sym. */
4610 if (eind->dyn_relocs != NULL)
4612 if (edir->dyn_relocs != NULL)
4614 struct elf_dyn_relocs **pp;
4615 struct elf_dyn_relocs *p;
4617 /* Add reloc counts against the indirect sym to the direct sym
4618 list. Merge any entries against the same section. */
4619 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4621 struct elf_dyn_relocs *q;
4623 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4624 if (q->sec == p->sec)
4626 q->pc_count += p->pc_count;
4627 q->count += p->count;
4634 *pp = edir->dyn_relocs;
4637 edir->dyn_relocs = eind->dyn_relocs;
4638 eind->dyn_relocs = NULL;
4641 /* If we were called to copy over info for a weak sym, that's all.
4642 You might think dyn_relocs need not be copied over; After all,
4643 both syms will be dynamic or both non-dynamic so we're just
4644 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4645 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4646 dyn_relocs in read-only sections, and it does so on what is the
4648 if (eind->elf.root.type != bfd_link_hash_indirect)
4651 /* Copy over got entries that we may have already seen to the
4652 symbol which just became indirect. */
4653 if (eind->elf.got.glist != NULL)
4655 if (edir->elf.got.glist != NULL)
4657 struct got_entry **entp;
4658 struct got_entry *ent;
4660 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4662 struct got_entry *dent;
4664 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4665 if (dent->addend == ent->addend
4666 && dent->owner == ent->owner
4667 && dent->tls_type == ent->tls_type)
4669 dent->got.refcount += ent->got.refcount;
4676 *entp = edir->elf.got.glist;
4679 edir->elf.got.glist = eind->elf.got.glist;
4680 eind->elf.got.glist = NULL;
4683 /* And plt entries. */
4684 move_plt_plist (eind, edir);
4686 if (eind->elf.dynindx != -1)
4688 if (edir->elf.dynindx != -1)
4689 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4690 edir->elf.dynstr_index);
4691 edir->elf.dynindx = eind->elf.dynindx;
4692 edir->elf.dynstr_index = eind->elf.dynstr_index;
4693 eind->elf.dynindx = -1;
4694 eind->elf.dynstr_index = 0;
4698 /* Find the function descriptor hash entry from the given function code
4699 hash entry FH. Link the entries via their OH fields. */
4701 static struct ppc_link_hash_entry *
4702 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4704 struct ppc_link_hash_entry *fdh = fh->oh;
4708 const char *fd_name = fh->elf.root.root.string + 1;
4710 fdh = (struct ppc_link_hash_entry *)
4711 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4715 fdh->is_func_descriptor = 1;
4721 return ppc_follow_link (fdh);
4724 /* Make a fake function descriptor sym for the code sym FH. */
4726 static struct ppc_link_hash_entry *
4727 make_fdh (struct bfd_link_info *info,
4728 struct ppc_link_hash_entry *fh)
4732 struct bfd_link_hash_entry *bh;
4733 struct ppc_link_hash_entry *fdh;
4735 abfd = fh->elf.root.u.undef.abfd;
4736 newsym = bfd_make_empty_symbol (abfd);
4737 newsym->name = fh->elf.root.root.string + 1;
4738 newsym->section = bfd_und_section_ptr;
4740 newsym->flags = BSF_WEAK;
4743 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4744 newsym->flags, newsym->section,
4745 newsym->value, NULL, FALSE, FALSE,
4749 fdh = (struct ppc_link_hash_entry *) bh;
4750 fdh->elf.non_elf = 0;
4752 fdh->is_func_descriptor = 1;
4759 /* Fix function descriptor symbols defined in .opd sections to be
4763 ppc64_elf_add_symbol_hook (bfd *ibfd,
4764 struct bfd_link_info *info,
4765 Elf_Internal_Sym *isym,
4767 flagword *flags ATTRIBUTE_UNUSED,
4769 bfd_vma *value ATTRIBUTE_UNUSED)
4771 if ((ibfd->flags & DYNAMIC) == 0
4772 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4773 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4775 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4777 if ((ibfd->flags & DYNAMIC) == 0)
4778 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4780 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4782 else if (*sec != NULL
4783 && strcmp ((*sec)->name, ".opd") == 0)
4784 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4786 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4788 if (abiversion (ibfd) == 0)
4789 set_abiversion (ibfd, 2);
4790 else if (abiversion (ibfd) == 1)
4792 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4793 " for ABI version 1\n"), name);
4794 bfd_set_error (bfd_error_bad_value);
4802 /* Merge non-visibility st_other attributes: local entry point. */
4805 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4806 const Elf_Internal_Sym *isym,
4807 bfd_boolean definition,
4808 bfd_boolean dynamic)
4810 if (definition && !dynamic)
4811 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4812 | ELF_ST_VISIBILITY (h->other));
4815 /* This function makes an old ABI object reference to ".bar" cause the
4816 inclusion of a new ABI object archive that defines "bar".
4817 NAME is a symbol defined in an archive. Return a symbol in the hash
4818 table that might be satisfied by the archive symbols. */
4820 static struct elf_link_hash_entry *
4821 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4822 struct bfd_link_info *info,
4825 struct elf_link_hash_entry *h;
4829 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4831 /* Don't return this sym if it is a fake function descriptor
4832 created by add_symbol_adjust. */
4833 && !(h->root.type == bfd_link_hash_undefweak
4834 && ((struct ppc_link_hash_entry *) h)->fake))
4840 len = strlen (name);
4841 dot_name = bfd_alloc (abfd, len + 2);
4842 if (dot_name == NULL)
4843 return (struct elf_link_hash_entry *) 0 - 1;
4845 memcpy (dot_name + 1, name, len + 1);
4846 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4847 bfd_release (abfd, dot_name);
4851 /* This function satisfies all old ABI object references to ".bar" if a
4852 new ABI object defines "bar". Well, at least, undefined dot symbols
4853 are made weak. This stops later archive searches from including an
4854 object if we already have a function descriptor definition. It also
4855 prevents the linker complaining about undefined symbols.
4856 We also check and correct mismatched symbol visibility here. The
4857 most restrictive visibility of the function descriptor and the
4858 function entry symbol is used. */
4861 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4863 struct ppc_link_hash_table *htab;
4864 struct ppc_link_hash_entry *fdh;
4866 if (eh->elf.root.type == bfd_link_hash_indirect)
4869 if (eh->elf.root.type == bfd_link_hash_warning)
4870 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4872 if (eh->elf.root.root.string[0] != '.')
4875 htab = ppc_hash_table (info);
4879 fdh = lookup_fdh (eh, htab);
4882 if (!info->relocatable
4883 && (eh->elf.root.type == bfd_link_hash_undefined
4884 || eh->elf.root.type == bfd_link_hash_undefweak)
4885 && eh->elf.ref_regular)
4887 /* Make an undefweak function descriptor sym, which is enough to
4888 pull in an --as-needed shared lib, but won't cause link
4889 errors. Archives are handled elsewhere. */
4890 fdh = make_fdh (info, eh);
4893 fdh->elf.ref_regular = 1;
4898 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4899 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4900 if (entry_vis < descr_vis)
4901 fdh->elf.other += entry_vis - descr_vis;
4902 else if (entry_vis > descr_vis)
4903 eh->elf.other += descr_vis - entry_vis;
4905 if ((fdh->elf.root.type == bfd_link_hash_defined
4906 || fdh->elf.root.type == bfd_link_hash_defweak)
4907 && eh->elf.root.type == bfd_link_hash_undefined)
4909 eh->elf.root.type = bfd_link_hash_undefweak;
4910 eh->was_undefined = 1;
4911 htab->twiddled_syms = 1;
4918 /* Process list of dot-symbols we made in link_hash_newfunc. */
4921 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4923 struct ppc_link_hash_table *htab;
4924 struct ppc_link_hash_entry **p, *eh;
4926 if (!is_ppc64_elf (info->output_bfd))
4928 htab = ppc_hash_table (info);
4932 if (is_ppc64_elf (ibfd))
4934 p = &htab->dot_syms;
4935 while ((eh = *p) != NULL)
4938 if (&eh->elf == htab->elf.hgot)
4940 else if (htab->elf.hgot == NULL
4941 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4942 htab->elf.hgot = &eh->elf;
4943 else if (!add_symbol_adjust (eh, info))
4945 p = &eh->u.next_dot_sym;
4949 /* Clear the list for non-ppc64 input files. */
4950 p = &htab->dot_syms;
4951 while ((eh = *p) != NULL)
4954 p = &eh->u.next_dot_sym;
4957 /* We need to fix the undefs list for any syms we have twiddled to
4959 if (htab->twiddled_syms)
4961 bfd_link_repair_undef_list (&htab->elf.root);
4962 htab->twiddled_syms = 0;
4967 /* Undo hash table changes when an --as-needed input file is determined
4968 not to be needed. */
4971 ppc64_elf_notice_as_needed (bfd *ibfd,
4972 struct bfd_link_info *info,
4973 enum notice_asneeded_action act)
4975 if (act == notice_not_needed)
4977 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4982 htab->dot_syms = NULL;
4984 return _bfd_elf_notice_as_needed (ibfd, info, act);
4987 /* If --just-symbols against a final linked binary, then assume we need
4988 toc adjusting stubs when calling functions defined there. */
4991 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4993 if ((sec->flags & SEC_CODE) != 0
4994 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4995 && is_ppc64_elf (sec->owner))
4997 if (abiversion (sec->owner) >= 2
4998 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4999 sec->has_toc_reloc = 1;
5001 _bfd_elf_link_just_syms (sec, info);
5004 static struct plt_entry **
5005 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5006 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5008 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5009 struct plt_entry **local_plt;
5010 unsigned char *local_got_tls_masks;
5012 if (local_got_ents == NULL)
5014 bfd_size_type size = symtab_hdr->sh_info;
5016 size *= (sizeof (*local_got_ents)
5017 + sizeof (*local_plt)
5018 + sizeof (*local_got_tls_masks));
5019 local_got_ents = bfd_zalloc (abfd, size);
5020 if (local_got_ents == NULL)
5022 elf_local_got_ents (abfd) = local_got_ents;
5025 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5027 struct got_entry *ent;
5029 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5030 if (ent->addend == r_addend
5031 && ent->owner == abfd
5032 && ent->tls_type == tls_type)
5036 bfd_size_type amt = sizeof (*ent);
5037 ent = bfd_alloc (abfd, amt);
5040 ent->next = local_got_ents[r_symndx];
5041 ent->addend = r_addend;
5043 ent->tls_type = tls_type;
5044 ent->is_indirect = FALSE;
5045 ent->got.refcount = 0;
5046 local_got_ents[r_symndx] = ent;
5048 ent->got.refcount += 1;
5051 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5052 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5053 local_got_tls_masks[r_symndx] |= tls_type;
5055 return local_plt + r_symndx;
5059 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5061 struct plt_entry *ent;
5063 for (ent = *plist; ent != NULL; ent = ent->next)
5064 if (ent->addend == addend)
5068 bfd_size_type amt = sizeof (*ent);
5069 ent = bfd_alloc (abfd, amt);
5073 ent->addend = addend;
5074 ent->plt.refcount = 0;
5077 ent->plt.refcount += 1;
5082 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5084 return (r_type == R_PPC64_REL24
5085 || r_type == R_PPC64_REL14
5086 || r_type == R_PPC64_REL14_BRTAKEN
5087 || r_type == R_PPC64_REL14_BRNTAKEN
5088 || r_type == R_PPC64_ADDR24
5089 || r_type == R_PPC64_ADDR14
5090 || r_type == R_PPC64_ADDR14_BRTAKEN
5091 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5094 /* Look through the relocs for a section during the first phase, and
5095 calculate needed space in the global offset table, procedure
5096 linkage table, and dynamic reloc sections. */
5099 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5100 asection *sec, const Elf_Internal_Rela *relocs)
5102 struct ppc_link_hash_table *htab;
5103 Elf_Internal_Shdr *symtab_hdr;
5104 struct elf_link_hash_entry **sym_hashes;
5105 const Elf_Internal_Rela *rel;
5106 const Elf_Internal_Rela *rel_end;
5108 asection **opd_sym_map;
5109 struct elf_link_hash_entry *tga, *dottga;
5111 if (info->relocatable)
5114 /* Don't do anything special with non-loaded, non-alloced sections.
5115 In particular, any relocs in such sections should not affect GOT
5116 and PLT reference counting (ie. we don't allow them to create GOT
5117 or PLT entries), there's no possibility or desire to optimize TLS
5118 relocs, and there's not much point in propagating relocs to shared
5119 libs that the dynamic linker won't relocate. */
5120 if ((sec->flags & SEC_ALLOC) == 0)
5123 BFD_ASSERT (is_ppc64_elf (abfd));
5125 htab = ppc_hash_table (info);
5129 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5130 FALSE, FALSE, TRUE);
5131 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5132 FALSE, FALSE, TRUE);
5133 symtab_hdr = &elf_symtab_hdr (abfd);
5134 sym_hashes = elf_sym_hashes (abfd);
5137 if (strcmp (sec->name, ".opd") == 0)
5139 /* Garbage collection needs some extra help with .opd sections.
5140 We don't want to necessarily keep everything referenced by
5141 relocs in .opd, as that would keep all functions. Instead,
5142 if we reference an .opd symbol (a function descriptor), we
5143 want to keep the function code symbol's section. This is
5144 easy for global symbols, but for local syms we need to keep
5145 information about the associated function section. */
5148 if (abiversion (abfd) == 0)
5149 set_abiversion (abfd, 1);
5150 else if (abiversion (abfd) == 2)
5152 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5154 bfd_set_error (bfd_error_bad_value);
5157 amt = sec->size * sizeof (*opd_sym_map) / 8;
5158 opd_sym_map = bfd_zalloc (abfd, amt);
5159 if (opd_sym_map == NULL)
5161 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5162 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5163 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5166 rel_end = relocs + sec->reloc_count;
5167 for (rel = relocs; rel < rel_end; rel++)
5169 unsigned long r_symndx;
5170 struct elf_link_hash_entry *h;
5171 enum elf_ppc64_reloc_type r_type;
5173 struct _ppc64_elf_section_data *ppc64_sec;
5174 struct plt_entry **ifunc;
5176 r_symndx = ELF64_R_SYM (rel->r_info);
5177 if (r_symndx < symtab_hdr->sh_info)
5181 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5182 h = elf_follow_link (h);
5184 /* PR15323, ref flags aren't set for references in the same
5186 h->root.non_ir_ref = 1;
5188 if (h == htab->elf.hgot)
5189 sec->has_toc_reloc = 1;
5196 if (h->type == STT_GNU_IFUNC)
5199 ifunc = &h->plt.plist;
5204 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5209 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5211 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5212 rel->r_addend, PLT_IFUNC);
5217 r_type = ELF64_R_TYPE (rel->r_info);
5218 if (is_branch_reloc (r_type))
5220 if (h != NULL && (h == tga || h == dottga))
5223 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5224 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5225 /* We have a new-style __tls_get_addr call with a marker
5229 /* Mark this section as having an old-style call. */
5230 sec->has_tls_get_addr_call = 1;
5233 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5235 && !update_plt_info (abfd, ifunc, rel->r_addend))
5243 /* These special tls relocs tie a call to __tls_get_addr with
5244 its parameter symbol. */
5247 case R_PPC64_GOT_TLSLD16:
5248 case R_PPC64_GOT_TLSLD16_LO:
5249 case R_PPC64_GOT_TLSLD16_HI:
5250 case R_PPC64_GOT_TLSLD16_HA:
5251 tls_type = TLS_TLS | TLS_LD;
5254 case R_PPC64_GOT_TLSGD16:
5255 case R_PPC64_GOT_TLSGD16_LO:
5256 case R_PPC64_GOT_TLSGD16_HI:
5257 case R_PPC64_GOT_TLSGD16_HA:
5258 tls_type = TLS_TLS | TLS_GD;
5261 case R_PPC64_GOT_TPREL16_DS:
5262 case R_PPC64_GOT_TPREL16_LO_DS:
5263 case R_PPC64_GOT_TPREL16_HI:
5264 case R_PPC64_GOT_TPREL16_HA:
5265 if (!info->executable)
5266 info->flags |= DF_STATIC_TLS;
5267 tls_type = TLS_TLS | TLS_TPREL;
5270 case R_PPC64_GOT_DTPREL16_DS:
5271 case R_PPC64_GOT_DTPREL16_LO_DS:
5272 case R_PPC64_GOT_DTPREL16_HI:
5273 case R_PPC64_GOT_DTPREL16_HA:
5274 tls_type = TLS_TLS | TLS_DTPREL;
5276 sec->has_tls_reloc = 1;
5280 case R_PPC64_GOT16_DS:
5281 case R_PPC64_GOT16_HA:
5282 case R_PPC64_GOT16_HI:
5283 case R_PPC64_GOT16_LO:
5284 case R_PPC64_GOT16_LO_DS:
5285 /* This symbol requires a global offset table entry. */
5286 sec->has_toc_reloc = 1;
5287 if (r_type == R_PPC64_GOT_TLSLD16
5288 || r_type == R_PPC64_GOT_TLSGD16
5289 || r_type == R_PPC64_GOT_TPREL16_DS
5290 || r_type == R_PPC64_GOT_DTPREL16_DS
5291 || r_type == R_PPC64_GOT16
5292 || r_type == R_PPC64_GOT16_DS)
5294 htab->do_multi_toc = 1;
5295 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5298 if (ppc64_elf_tdata (abfd)->got == NULL
5299 && !create_got_section (abfd, info))
5304 struct ppc_link_hash_entry *eh;
5305 struct got_entry *ent;
5307 eh = (struct ppc_link_hash_entry *) h;
5308 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5309 if (ent->addend == rel->r_addend
5310 && ent->owner == abfd
5311 && ent->tls_type == tls_type)
5315 bfd_size_type amt = sizeof (*ent);
5316 ent = bfd_alloc (abfd, amt);
5319 ent->next = eh->elf.got.glist;
5320 ent->addend = rel->r_addend;
5322 ent->tls_type = tls_type;
5323 ent->is_indirect = FALSE;
5324 ent->got.refcount = 0;
5325 eh->elf.got.glist = ent;
5327 ent->got.refcount += 1;
5328 eh->tls_mask |= tls_type;
5331 /* This is a global offset table entry for a local symbol. */
5332 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5333 rel->r_addend, tls_type))
5336 /* We may also need a plt entry if the symbol turns out to be
5338 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5340 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5345 case R_PPC64_PLT16_HA:
5346 case R_PPC64_PLT16_HI:
5347 case R_PPC64_PLT16_LO:
5350 /* This symbol requires a procedure linkage table entry. We
5351 actually build the entry in adjust_dynamic_symbol,
5352 because this might be a case of linking PIC code without
5353 linking in any dynamic objects, in which case we don't
5354 need to generate a procedure linkage table after all. */
5357 /* It does not make sense to have a procedure linkage
5358 table entry for a local symbol. */
5359 bfd_set_error (bfd_error_bad_value);
5364 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5367 if (h->root.root.string[0] == '.'
5368 && h->root.root.string[1] != '\0')
5369 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5373 /* The following relocations don't need to propagate the
5374 relocation if linking a shared object since they are
5375 section relative. */
5376 case R_PPC64_SECTOFF:
5377 case R_PPC64_SECTOFF_LO:
5378 case R_PPC64_SECTOFF_HI:
5379 case R_PPC64_SECTOFF_HA:
5380 case R_PPC64_SECTOFF_DS:
5381 case R_PPC64_SECTOFF_LO_DS:
5382 case R_PPC64_DTPREL16:
5383 case R_PPC64_DTPREL16_LO:
5384 case R_PPC64_DTPREL16_HI:
5385 case R_PPC64_DTPREL16_HA:
5386 case R_PPC64_DTPREL16_DS:
5387 case R_PPC64_DTPREL16_LO_DS:
5388 case R_PPC64_DTPREL16_HIGH:
5389 case R_PPC64_DTPREL16_HIGHA:
5390 case R_PPC64_DTPREL16_HIGHER:
5391 case R_PPC64_DTPREL16_HIGHERA:
5392 case R_PPC64_DTPREL16_HIGHEST:
5393 case R_PPC64_DTPREL16_HIGHESTA:
5398 case R_PPC64_REL16_LO:
5399 case R_PPC64_REL16_HI:
5400 case R_PPC64_REL16_HA:
5404 case R_PPC64_TOC16_DS:
5405 htab->do_multi_toc = 1;
5406 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5407 case R_PPC64_TOC16_LO:
5408 case R_PPC64_TOC16_HI:
5409 case R_PPC64_TOC16_HA:
5410 case R_PPC64_TOC16_LO_DS:
5411 sec->has_toc_reloc = 1;
5414 /* This relocation describes the C++ object vtable hierarchy.
5415 Reconstruct it for later use during GC. */
5416 case R_PPC64_GNU_VTINHERIT:
5417 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5421 /* This relocation describes which C++ vtable entries are actually
5422 used. Record for later use during GC. */
5423 case R_PPC64_GNU_VTENTRY:
5424 BFD_ASSERT (h != NULL);
5426 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5431 case R_PPC64_REL14_BRTAKEN:
5432 case R_PPC64_REL14_BRNTAKEN:
5434 asection *dest = NULL;
5436 /* Heuristic: If jumping outside our section, chances are
5437 we are going to need a stub. */
5440 /* If the sym is weak it may be overridden later, so
5441 don't assume we know where a weak sym lives. */
5442 if (h->root.type == bfd_link_hash_defined)
5443 dest = h->root.u.def.section;
5447 Elf_Internal_Sym *isym;
5449 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5454 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5458 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5463 if (h != NULL && ifunc == NULL)
5465 /* We may need a .plt entry if the function this reloc
5466 refers to is in a shared lib. */
5467 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5470 if (h->root.root.string[0] == '.'
5471 && h->root.root.string[1] != '\0')
5472 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5473 if (h == tga || h == dottga)
5474 sec->has_tls_reloc = 1;
5478 case R_PPC64_TPREL64:
5479 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5480 if (!info->executable)
5481 info->flags |= DF_STATIC_TLS;
5484 case R_PPC64_DTPMOD64:
5485 if (rel + 1 < rel_end
5486 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5487 && rel[1].r_offset == rel->r_offset + 8)
5488 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5490 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5493 case R_PPC64_DTPREL64:
5494 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5496 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5497 && rel[-1].r_offset == rel->r_offset - 8)
5498 /* This is the second reloc of a dtpmod, dtprel pair.
5499 Don't mark with TLS_DTPREL. */
5503 sec->has_tls_reloc = 1;
5506 struct ppc_link_hash_entry *eh;
5507 eh = (struct ppc_link_hash_entry *) h;
5508 eh->tls_mask |= tls_type;
5511 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5512 rel->r_addend, tls_type))
5515 ppc64_sec = ppc64_elf_section_data (sec);
5516 if (ppc64_sec->sec_type != sec_toc)
5520 /* One extra to simplify get_tls_mask. */
5521 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5522 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5523 if (ppc64_sec->u.toc.symndx == NULL)
5525 amt = sec->size * sizeof (bfd_vma) / 8;
5526 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5527 if (ppc64_sec->u.toc.add == NULL)
5529 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5530 ppc64_sec->sec_type = sec_toc;
5532 BFD_ASSERT (rel->r_offset % 8 == 0);
5533 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5534 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5536 /* Mark the second slot of a GD or LD entry.
5537 -1 to indicate GD and -2 to indicate LD. */
5538 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5539 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5540 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5541 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5544 case R_PPC64_TPREL16:
5545 case R_PPC64_TPREL16_LO:
5546 case R_PPC64_TPREL16_HI:
5547 case R_PPC64_TPREL16_HA:
5548 case R_PPC64_TPREL16_DS:
5549 case R_PPC64_TPREL16_LO_DS:
5550 case R_PPC64_TPREL16_HIGH:
5551 case R_PPC64_TPREL16_HIGHA:
5552 case R_PPC64_TPREL16_HIGHER:
5553 case R_PPC64_TPREL16_HIGHERA:
5554 case R_PPC64_TPREL16_HIGHEST:
5555 case R_PPC64_TPREL16_HIGHESTA:
5558 if (!info->executable)
5559 info->flags |= DF_STATIC_TLS;
5564 case R_PPC64_ADDR64:
5565 if (opd_sym_map != NULL
5566 && rel + 1 < rel_end
5567 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5571 if (h->root.root.string[0] == '.'
5572 && h->root.root.string[1] != 0
5573 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5576 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5581 Elf_Internal_Sym *isym;
5583 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5588 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5589 if (s != NULL && s != sec)
5590 opd_sym_map[rel->r_offset / 8] = s;
5595 case R_PPC64_ADDR16:
5596 case R_PPC64_ADDR16_DS:
5597 case R_PPC64_ADDR16_HA:
5598 case R_PPC64_ADDR16_HI:
5599 case R_PPC64_ADDR16_HIGH:
5600 case R_PPC64_ADDR16_HIGHA:
5601 case R_PPC64_ADDR16_HIGHER:
5602 case R_PPC64_ADDR16_HIGHERA:
5603 case R_PPC64_ADDR16_HIGHEST:
5604 case R_PPC64_ADDR16_HIGHESTA:
5605 case R_PPC64_ADDR16_LO:
5606 case R_PPC64_ADDR16_LO_DS:
5607 if (h != NULL && !info->shared && abiversion (abfd) == 2
5608 && rel->r_addend == 0)
5610 /* We may need a .plt entry if this reloc refers to a
5611 function in a shared lib. */
5612 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5614 h->pointer_equality_needed = 1;
5621 case R_PPC64_ADDR14:
5622 case R_PPC64_ADDR14_BRNTAKEN:
5623 case R_PPC64_ADDR14_BRTAKEN:
5624 case R_PPC64_ADDR24:
5625 case R_PPC64_ADDR32:
5626 case R_PPC64_UADDR16:
5627 case R_PPC64_UADDR32:
5628 case R_PPC64_UADDR64:
5630 if (h != NULL && !info->shared)
5631 /* We may need a copy reloc. */
5634 /* Don't propagate .opd relocs. */
5635 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5638 /* If we are creating a shared library, and this is a reloc
5639 against a global symbol, or a non PC relative reloc
5640 against a local symbol, then we need to copy the reloc
5641 into the shared library. However, if we are linking with
5642 -Bsymbolic, we do not need to copy a reloc against a
5643 global symbol which is defined in an object we are
5644 including in the link (i.e., DEF_REGULAR is set). At
5645 this point we have not seen all the input files, so it is
5646 possible that DEF_REGULAR is not set now but will be set
5647 later (it is never cleared). In case of a weak definition,
5648 DEF_REGULAR may be cleared later by a strong definition in
5649 a shared library. We account for that possibility below by
5650 storing information in the dyn_relocs field of the hash
5651 table entry. A similar situation occurs when creating
5652 shared libraries and symbol visibility changes render the
5655 If on the other hand, we are creating an executable, we
5656 may need to keep relocations for symbols satisfied by a
5657 dynamic library if we manage to avoid copy relocs for the
5661 && (must_be_dyn_reloc (info, r_type)
5663 && (!SYMBOLIC_BIND (info, h)
5664 || h->root.type == bfd_link_hash_defweak
5665 || !h->def_regular))))
5666 || (ELIMINATE_COPY_RELOCS
5669 && (h->root.type == bfd_link_hash_defweak
5670 || !h->def_regular))
5674 /* We must copy these reloc types into the output file.
5675 Create a reloc section in dynobj and make room for
5679 sreloc = _bfd_elf_make_dynamic_reloc_section
5680 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5686 /* If this is a global symbol, we count the number of
5687 relocations we need for this symbol. */
5690 struct elf_dyn_relocs *p;
5691 struct elf_dyn_relocs **head;
5693 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5695 if (p == NULL || p->sec != sec)
5697 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5707 if (!must_be_dyn_reloc (info, r_type))
5712 /* Track dynamic relocs needed for local syms too.
5713 We really need local syms available to do this
5715 struct ppc_dyn_relocs *p;
5716 struct ppc_dyn_relocs **head;
5717 bfd_boolean is_ifunc;
5720 Elf_Internal_Sym *isym;
5722 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5727 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5731 vpp = &elf_section_data (s)->local_dynrel;
5732 head = (struct ppc_dyn_relocs **) vpp;
5733 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5735 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5737 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5739 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5745 p->ifunc = is_ifunc;
5761 /* Merge backend specific data from an object file to the output
5762 object file when linking. */
5765 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5767 unsigned long iflags, oflags;
5769 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5772 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5775 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5778 iflags = elf_elfheader (ibfd)->e_flags;
5779 oflags = elf_elfheader (obfd)->e_flags;
5781 if (!elf_flags_init (obfd) || oflags == 0)
5783 elf_flags_init (obfd) = TRUE;
5784 elf_elfheader (obfd)->e_flags = iflags;
5786 else if (iflags == oflags || iflags == 0)
5788 else if (iflags & ~EF_PPC64_ABI)
5790 (*_bfd_error_handler)
5791 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5792 bfd_set_error (bfd_error_bad_value);
5797 (*_bfd_error_handler)
5798 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5799 ibfd, iflags, oflags);
5800 bfd_set_error (bfd_error_bad_value);
5804 /* Merge Tag_compatibility attributes and any common GNU ones. */
5805 _bfd_elf_merge_object_attributes (ibfd, obfd);
5811 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5813 /* Print normal ELF private data. */
5814 _bfd_elf_print_private_bfd_data (abfd, ptr);
5816 if (elf_elfheader (abfd)->e_flags != 0)
5820 /* xgettext:c-format */
5821 fprintf (file, _("private flags = 0x%lx:"),
5822 elf_elfheader (abfd)->e_flags);
5824 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5825 fprintf (file, _(" [abiv%ld]"),
5826 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5833 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5834 of the code entry point, and its section. */
5837 opd_entry_value (asection *opd_sec,
5839 asection **code_sec,
5841 bfd_boolean in_code_sec)
5843 bfd *opd_bfd = opd_sec->owner;
5844 Elf_Internal_Rela *relocs;
5845 Elf_Internal_Rela *lo, *hi, *look;
5848 /* No relocs implies we are linking a --just-symbols object, or looking
5849 at a final linked executable with addr2line or somesuch. */
5850 if (opd_sec->reloc_count == 0)
5852 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5854 if (contents == NULL)
5856 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5857 return (bfd_vma) -1;
5858 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5861 val = bfd_get_64 (opd_bfd, contents + offset);
5862 if (code_sec != NULL)
5864 asection *sec, *likely = NULL;
5870 && val < sec->vma + sec->size)
5876 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5878 && (sec->flags & SEC_LOAD) != 0
5879 && (sec->flags & SEC_ALLOC) != 0)
5884 if (code_off != NULL)
5885 *code_off = val - likely->vma;
5891 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5893 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5895 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5897 /* Go find the opd reloc at the sym address. */
5899 BFD_ASSERT (lo != NULL);
5900 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5904 look = lo + (hi - lo) / 2;
5905 if (look->r_offset < offset)
5907 else if (look->r_offset > offset)
5911 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5913 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5914 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5916 unsigned long symndx = ELF64_R_SYM (look->r_info);
5919 if (symndx < symtab_hdr->sh_info
5920 || elf_sym_hashes (opd_bfd) == NULL)
5922 Elf_Internal_Sym *sym;
5924 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5927 size_t symcnt = symtab_hdr->sh_info;
5928 if (elf_sym_hashes (opd_bfd) == NULL)
5929 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5930 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5931 0, NULL, NULL, NULL);
5934 symtab_hdr->contents = (bfd_byte *) sym;
5938 val = sym->st_value;
5939 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5940 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5944 struct elf_link_hash_entry **sym_hashes;
5945 struct elf_link_hash_entry *rh;
5947 sym_hashes = elf_sym_hashes (opd_bfd);
5948 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5951 rh = elf_follow_link (rh);
5952 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5953 || rh->root.type == bfd_link_hash_defweak);
5954 val = rh->root.u.def.value;
5955 sec = rh->root.u.def.section;
5959 /* Handle the odd case where we can be called
5960 during bfd_elf_link_add_symbols before the
5961 symbol hashes have been fully populated. */
5962 Elf_Internal_Sym *sym;
5964 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5965 symndx, NULL, NULL, NULL);
5969 val = sym->st_value;
5970 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5974 val += look->r_addend;
5975 if (code_off != NULL)
5977 if (code_sec != NULL)
5979 if (in_code_sec && *code_sec != sec)
5984 if (sec != NULL && sec->output_section != NULL)
5985 val += sec->output_section->vma + sec->output_offset;
5994 /* If the ELF symbol SYM might be a function in SEC, return the
5995 function size and set *CODE_OFF to the function's entry point,
5996 otherwise return zero. */
5998 static bfd_size_type
5999 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6004 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6005 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6009 if (!(sym->flags & BSF_SYNTHETIC))
6010 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6012 if (strcmp (sym->section->name, ".opd") == 0)
6014 if (opd_entry_value (sym->section, sym->value,
6015 &sec, code_off, TRUE) == (bfd_vma) -1)
6017 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6018 symbol. This size has nothing to do with the code size of the
6019 function, which is what we're supposed to return, but the
6020 code size isn't available without looking up the dot-sym.
6021 However, doing that would be a waste of time particularly
6022 since elf_find_function will look at the dot-sym anyway.
6023 Now, elf_find_function will keep the largest size of any
6024 function sym found at the code address of interest, so return
6025 1 here to avoid it incorrectly caching a larger function size
6026 for a small function. This does mean we return the wrong
6027 size for a new-ABI function of size 24, but all that does is
6028 disable caching for such functions. */
6034 if (sym->section != sec)
6036 *code_off = sym->value;
6043 /* Return true if symbol is defined in a regular object file. */
6046 is_static_defined (struct elf_link_hash_entry *h)
6048 return ((h->root.type == bfd_link_hash_defined
6049 || h->root.type == bfd_link_hash_defweak)
6050 && h->root.u.def.section != NULL
6051 && h->root.u.def.section->output_section != NULL);
6054 /* If FDH is a function descriptor symbol, return the associated code
6055 entry symbol if it is defined. Return NULL otherwise. */
6057 static struct ppc_link_hash_entry *
6058 defined_code_entry (struct ppc_link_hash_entry *fdh)
6060 if (fdh->is_func_descriptor)
6062 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6063 if (fh->elf.root.type == bfd_link_hash_defined
6064 || fh->elf.root.type == bfd_link_hash_defweak)
6070 /* If FH is a function code entry symbol, return the associated
6071 function descriptor symbol if it is defined. Return NULL otherwise. */
6073 static struct ppc_link_hash_entry *
6074 defined_func_desc (struct ppc_link_hash_entry *fh)
6077 && fh->oh->is_func_descriptor)
6079 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6080 if (fdh->elf.root.type == bfd_link_hash_defined
6081 || fdh->elf.root.type == bfd_link_hash_defweak)
6087 /* Mark all our entry sym sections, both opd and code section. */
6090 ppc64_elf_gc_keep (struct bfd_link_info *info)
6092 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6093 struct bfd_sym_chain *sym;
6098 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6100 struct ppc_link_hash_entry *eh, *fh;
6103 eh = (struct ppc_link_hash_entry *)
6104 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6107 if (eh->elf.root.type != bfd_link_hash_defined
6108 && eh->elf.root.type != bfd_link_hash_defweak)
6111 fh = defined_code_entry (eh);
6114 sec = fh->elf.root.u.def.section;
6115 sec->flags |= SEC_KEEP;
6117 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6118 && opd_entry_value (eh->elf.root.u.def.section,
6119 eh->elf.root.u.def.value,
6120 &sec, NULL, FALSE) != (bfd_vma) -1)
6121 sec->flags |= SEC_KEEP;
6123 sec = eh->elf.root.u.def.section;
6124 sec->flags |= SEC_KEEP;
6128 /* Mark sections containing dynamically referenced symbols. When
6129 building shared libraries, we must assume that any visible symbol is
6133 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6135 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6136 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6137 struct ppc_link_hash_entry *fdh;
6138 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6140 /* Dynamic linking info is on the func descriptor sym. */
6141 fdh = defined_func_desc (eh);
6145 if ((eh->elf.root.type == bfd_link_hash_defined
6146 || eh->elf.root.type == bfd_link_hash_defweak)
6147 && (eh->elf.ref_dynamic
6148 || (eh->elf.def_regular
6149 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6150 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6151 && (!info->executable
6152 || info->export_dynamic
6155 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6156 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6157 || !bfd_hide_sym_by_version (info->version_info,
6158 eh->elf.root.root.string)))))
6161 struct ppc_link_hash_entry *fh;
6163 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6165 /* Function descriptor syms cause the associated
6166 function code sym section to be marked. */
6167 fh = defined_code_entry (eh);
6170 code_sec = fh->elf.root.u.def.section;
6171 code_sec->flags |= SEC_KEEP;
6173 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6174 && opd_entry_value (eh->elf.root.u.def.section,
6175 eh->elf.root.u.def.value,
6176 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6177 code_sec->flags |= SEC_KEEP;
6183 /* Return the section that should be marked against GC for a given
6187 ppc64_elf_gc_mark_hook (asection *sec,
6188 struct bfd_link_info *info,
6189 Elf_Internal_Rela *rel,
6190 struct elf_link_hash_entry *h,
6191 Elf_Internal_Sym *sym)
6195 /* Syms return NULL if we're marking .opd, so we avoid marking all
6196 function sections, as all functions are referenced in .opd. */
6198 if (get_opd_info (sec) != NULL)
6203 enum elf_ppc64_reloc_type r_type;
6204 struct ppc_link_hash_entry *eh, *fh, *fdh;
6206 r_type = ELF64_R_TYPE (rel->r_info);
6209 case R_PPC64_GNU_VTINHERIT:
6210 case R_PPC64_GNU_VTENTRY:
6214 switch (h->root.type)
6216 case bfd_link_hash_defined:
6217 case bfd_link_hash_defweak:
6218 eh = (struct ppc_link_hash_entry *) h;
6219 fdh = defined_func_desc (eh);
6223 /* Function descriptor syms cause the associated
6224 function code sym section to be marked. */
6225 fh = defined_code_entry (eh);
6228 /* They also mark their opd section. */
6229 eh->elf.root.u.def.section->gc_mark = 1;
6231 rsec = fh->elf.root.u.def.section;
6233 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6234 && opd_entry_value (eh->elf.root.u.def.section,
6235 eh->elf.root.u.def.value,
6236 &rsec, NULL, FALSE) != (bfd_vma) -1)
6237 eh->elf.root.u.def.section->gc_mark = 1;
6239 rsec = h->root.u.def.section;
6242 case bfd_link_hash_common:
6243 rsec = h->root.u.c.p->section;
6247 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6253 struct _opd_sec_data *opd;
6255 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6256 opd = get_opd_info (rsec);
6257 if (opd != NULL && opd->func_sec != NULL)
6261 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6268 /* Update the .got, .plt. and dynamic reloc reference counts for the
6269 section being removed. */
6272 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6273 asection *sec, const Elf_Internal_Rela *relocs)
6275 struct ppc_link_hash_table *htab;
6276 Elf_Internal_Shdr *symtab_hdr;
6277 struct elf_link_hash_entry **sym_hashes;
6278 struct got_entry **local_got_ents;
6279 const Elf_Internal_Rela *rel, *relend;
6281 if (info->relocatable)
6284 if ((sec->flags & SEC_ALLOC) == 0)
6287 elf_section_data (sec)->local_dynrel = NULL;
6289 htab = ppc_hash_table (info);
6293 symtab_hdr = &elf_symtab_hdr (abfd);
6294 sym_hashes = elf_sym_hashes (abfd);
6295 local_got_ents = elf_local_got_ents (abfd);
6297 relend = relocs + sec->reloc_count;
6298 for (rel = relocs; rel < relend; rel++)
6300 unsigned long r_symndx;
6301 enum elf_ppc64_reloc_type r_type;
6302 struct elf_link_hash_entry *h = NULL;
6303 unsigned char tls_type = 0;
6305 r_symndx = ELF64_R_SYM (rel->r_info);
6306 r_type = ELF64_R_TYPE (rel->r_info);
6307 if (r_symndx >= symtab_hdr->sh_info)
6309 struct ppc_link_hash_entry *eh;
6310 struct elf_dyn_relocs **pp;
6311 struct elf_dyn_relocs *p;
6313 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6314 h = elf_follow_link (h);
6315 eh = (struct ppc_link_hash_entry *) h;
6317 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6320 /* Everything must go for SEC. */
6326 if (is_branch_reloc (r_type))
6328 struct plt_entry **ifunc = NULL;
6331 if (h->type == STT_GNU_IFUNC)
6332 ifunc = &h->plt.plist;
6334 else if (local_got_ents != NULL)
6336 struct plt_entry **local_plt = (struct plt_entry **)
6337 (local_got_ents + symtab_hdr->sh_info);
6338 unsigned char *local_got_tls_masks = (unsigned char *)
6339 (local_plt + symtab_hdr->sh_info);
6340 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6341 ifunc = local_plt + r_symndx;
6345 struct plt_entry *ent;
6347 for (ent = *ifunc; ent != NULL; ent = ent->next)
6348 if (ent->addend == rel->r_addend)
6352 if (ent->plt.refcount > 0)
6353 ent->plt.refcount -= 1;
6360 case R_PPC64_GOT_TLSLD16:
6361 case R_PPC64_GOT_TLSLD16_LO:
6362 case R_PPC64_GOT_TLSLD16_HI:
6363 case R_PPC64_GOT_TLSLD16_HA:
6364 tls_type = TLS_TLS | TLS_LD;
6367 case R_PPC64_GOT_TLSGD16:
6368 case R_PPC64_GOT_TLSGD16_LO:
6369 case R_PPC64_GOT_TLSGD16_HI:
6370 case R_PPC64_GOT_TLSGD16_HA:
6371 tls_type = TLS_TLS | TLS_GD;
6374 case R_PPC64_GOT_TPREL16_DS:
6375 case R_PPC64_GOT_TPREL16_LO_DS:
6376 case R_PPC64_GOT_TPREL16_HI:
6377 case R_PPC64_GOT_TPREL16_HA:
6378 tls_type = TLS_TLS | TLS_TPREL;
6381 case R_PPC64_GOT_DTPREL16_DS:
6382 case R_PPC64_GOT_DTPREL16_LO_DS:
6383 case R_PPC64_GOT_DTPREL16_HI:
6384 case R_PPC64_GOT_DTPREL16_HA:
6385 tls_type = TLS_TLS | TLS_DTPREL;
6389 case R_PPC64_GOT16_DS:
6390 case R_PPC64_GOT16_HA:
6391 case R_PPC64_GOT16_HI:
6392 case R_PPC64_GOT16_LO:
6393 case R_PPC64_GOT16_LO_DS:
6396 struct got_entry *ent;
6401 ent = local_got_ents[r_symndx];
6403 for (; ent != NULL; ent = ent->next)
6404 if (ent->addend == rel->r_addend
6405 && ent->owner == abfd
6406 && ent->tls_type == tls_type)
6410 if (ent->got.refcount > 0)
6411 ent->got.refcount -= 1;
6415 case R_PPC64_PLT16_HA:
6416 case R_PPC64_PLT16_HI:
6417 case R_PPC64_PLT16_LO:
6421 case R_PPC64_REL14_BRNTAKEN:
6422 case R_PPC64_REL14_BRTAKEN:
6426 struct plt_entry *ent;
6428 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6429 if (ent->addend == rel->r_addend)
6431 if (ent != NULL && ent->plt.refcount > 0)
6432 ent->plt.refcount -= 1;
6443 /* The maximum size of .sfpr. */
6444 #define SFPR_MAX (218*4)
6446 struct sfpr_def_parms
6448 const char name[12];
6449 unsigned char lo, hi;
6450 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6451 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6454 /* Auto-generate _save*, _rest* functions in .sfpr. */
6457 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6459 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6461 size_t len = strlen (parm->name);
6462 bfd_boolean writing = FALSE;
6468 memcpy (sym, parm->name, len);
6471 for (i = parm->lo; i <= parm->hi; i++)
6473 struct elf_link_hash_entry *h;
6475 sym[len + 0] = i / 10 + '0';
6476 sym[len + 1] = i % 10 + '0';
6477 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6481 h->root.type = bfd_link_hash_defined;
6482 h->root.u.def.section = htab->sfpr;
6483 h->root.u.def.value = htab->sfpr->size;
6486 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6488 if (htab->sfpr->contents == NULL)
6490 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6491 if (htab->sfpr->contents == NULL)
6497 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6499 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6501 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6502 htab->sfpr->size = p - htab->sfpr->contents;
6510 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6512 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6517 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6519 p = savegpr0 (abfd, p, r);
6520 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6522 bfd_put_32 (abfd, BLR, p);
6527 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6529 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6534 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6538 p = restgpr0 (abfd, p, r);
6539 bfd_put_32 (abfd, MTLR_R0, p);
6543 p = restgpr0 (abfd, p, 30);
6544 p = restgpr0 (abfd, p, 31);
6546 bfd_put_32 (abfd, BLR, p);
6551 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6553 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6558 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6560 p = savegpr1 (abfd, p, r);
6561 bfd_put_32 (abfd, BLR, p);
6566 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6568 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6573 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6575 p = restgpr1 (abfd, p, r);
6576 bfd_put_32 (abfd, BLR, p);
6581 savefpr (bfd *abfd, bfd_byte *p, int r)
6583 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6588 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6590 p = savefpr (abfd, p, r);
6591 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6593 bfd_put_32 (abfd, BLR, p);
6598 restfpr (bfd *abfd, bfd_byte *p, int r)
6600 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6605 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6609 p = restfpr (abfd, p, r);
6610 bfd_put_32 (abfd, MTLR_R0, p);
6614 p = restfpr (abfd, p, 30);
6615 p = restfpr (abfd, p, 31);
6617 bfd_put_32 (abfd, BLR, p);
6622 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 p = savefpr (abfd, p, r);
6625 bfd_put_32 (abfd, BLR, p);
6630 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 p = restfpr (abfd, p, r);
6633 bfd_put_32 (abfd, BLR, p);
6638 savevr (bfd *abfd, bfd_byte *p, int r)
6640 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6642 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6647 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6649 p = savevr (abfd, p, r);
6650 bfd_put_32 (abfd, BLR, p);
6655 restvr (bfd *abfd, bfd_byte *p, int r)
6657 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6659 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6664 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6666 p = restvr (abfd, p, r);
6667 bfd_put_32 (abfd, BLR, p);
6671 /* Called via elf_link_hash_traverse to transfer dynamic linking
6672 information on function code symbol entries to their corresponding
6673 function descriptor symbol entries. */
6676 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6678 struct bfd_link_info *info;
6679 struct ppc_link_hash_table *htab;
6680 struct plt_entry *ent;
6681 struct ppc_link_hash_entry *fh;
6682 struct ppc_link_hash_entry *fdh;
6683 bfd_boolean force_local;
6685 fh = (struct ppc_link_hash_entry *) h;
6686 if (fh->elf.root.type == bfd_link_hash_indirect)
6690 htab = ppc_hash_table (info);
6694 /* Resolve undefined references to dot-symbols as the value
6695 in the function descriptor, if we have one in a regular object.
6696 This is to satisfy cases like ".quad .foo". Calls to functions
6697 in dynamic objects are handled elsewhere. */
6698 if (fh->elf.root.type == bfd_link_hash_undefweak
6699 && fh->was_undefined
6700 && (fdh = defined_func_desc (fh)) != NULL
6701 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6702 && opd_entry_value (fdh->elf.root.u.def.section,
6703 fdh->elf.root.u.def.value,
6704 &fh->elf.root.u.def.section,
6705 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6707 fh->elf.root.type = fdh->elf.root.type;
6708 fh->elf.forced_local = 1;
6709 fh->elf.def_regular = fdh->elf.def_regular;
6710 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6713 /* If this is a function code symbol, transfer dynamic linking
6714 information to the function descriptor symbol. */
6718 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6719 if (ent->plt.refcount > 0)
6722 || fh->elf.root.root.string[0] != '.'
6723 || fh->elf.root.root.string[1] == '\0')
6726 /* Find the corresponding function descriptor symbol. Create it
6727 as undefined if necessary. */
6729 fdh = lookup_fdh (fh, htab);
6731 && !info->executable
6732 && (fh->elf.root.type == bfd_link_hash_undefined
6733 || fh->elf.root.type == bfd_link_hash_undefweak))
6735 fdh = make_fdh (info, fh);
6740 /* Fake function descriptors are made undefweak. If the function
6741 code symbol is strong undefined, make the fake sym the same.
6742 If the function code symbol is defined, then force the fake
6743 descriptor local; We can't support overriding of symbols in a
6744 shared library on a fake descriptor. */
6748 && fdh->elf.root.type == bfd_link_hash_undefweak)
6750 if (fh->elf.root.type == bfd_link_hash_undefined)
6752 fdh->elf.root.type = bfd_link_hash_undefined;
6753 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6755 else if (fh->elf.root.type == bfd_link_hash_defined
6756 || fh->elf.root.type == bfd_link_hash_defweak)
6758 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6763 && !fdh->elf.forced_local
6764 && (!info->executable
6765 || fdh->elf.def_dynamic
6766 || fdh->elf.ref_dynamic
6767 || (fdh->elf.root.type == bfd_link_hash_undefweak
6768 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6770 if (fdh->elf.dynindx == -1)
6771 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6773 fdh->elf.ref_regular |= fh->elf.ref_regular;
6774 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6775 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6776 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6777 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6779 move_plt_plist (fh, fdh);
6780 fdh->elf.needs_plt = 1;
6782 fdh->is_func_descriptor = 1;
6787 /* Now that the info is on the function descriptor, clear the
6788 function code sym info. Any function code syms for which we
6789 don't have a definition in a regular file, we force local.
6790 This prevents a shared library from exporting syms that have
6791 been imported from another library. Function code syms that
6792 are really in the library we must leave global to prevent the
6793 linker dragging in a definition from a static library. */
6794 force_local = (!fh->elf.def_regular
6796 || !fdh->elf.def_regular
6797 || fdh->elf.forced_local);
6798 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6803 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6804 this hook to a) provide some gcc support functions, and b) transfer
6805 dynamic linking information gathered so far on function code symbol
6806 entries, to their corresponding function descriptor symbol entries. */
6809 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6810 struct bfd_link_info *info)
6812 struct ppc_link_hash_table *htab;
6814 static const struct sfpr_def_parms funcs[] =
6816 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6817 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6818 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6819 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6820 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6821 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6822 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6823 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6824 { "._savef", 14, 31, savefpr, savefpr1_tail },
6825 { "._restf", 14, 31, restfpr, restfpr1_tail },
6826 { "_savevr_", 20, 31, savevr, savevr_tail },
6827 { "_restvr_", 20, 31, restvr, restvr_tail }
6830 htab = ppc_hash_table (info);
6834 if (!info->relocatable
6835 && htab->elf.hgot != NULL)
6837 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6838 /* Make .TOC. defined so as to prevent it being made dynamic.
6839 The wrong value here is fixed later in ppc64_elf_set_toc. */
6840 htab->elf.hgot->type = STT_OBJECT;
6841 htab->elf.hgot->root.type = bfd_link_hash_defined;
6842 htab->elf.hgot->root.u.def.value = 0;
6843 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6844 htab->elf.hgot->def_regular = 1;
6845 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6849 if (htab->sfpr == NULL)
6850 /* We don't have any relocs. */
6853 /* Provide any missing _save* and _rest* functions. */
6854 htab->sfpr->size = 0;
6855 if (!info->relocatable)
6856 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6857 if (!sfpr_define (info, &funcs[i]))
6860 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6862 if (htab->sfpr->size == 0)
6863 htab->sfpr->flags |= SEC_EXCLUDE;
6868 /* Return true if we have dynamic relocs that apply to read-only sections. */
6871 readonly_dynrelocs (struct elf_link_hash_entry *h)
6873 struct ppc_link_hash_entry *eh;
6874 struct elf_dyn_relocs *p;
6876 eh = (struct ppc_link_hash_entry *) h;
6877 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6879 asection *s = p->sec->output_section;
6881 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6887 /* Adjust a symbol defined by a dynamic object and referenced by a
6888 regular object. The current definition is in some section of the
6889 dynamic object, but we're not including those sections. We have to
6890 change the definition to something the rest of the link can
6894 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6895 struct elf_link_hash_entry *h)
6897 struct ppc_link_hash_table *htab;
6900 htab = ppc_hash_table (info);
6904 /* Deal with function syms. */
6905 if (h->type == STT_FUNC
6906 || h->type == STT_GNU_IFUNC
6909 /* Clear procedure linkage table information for any symbol that
6910 won't need a .plt entry. */
6911 struct plt_entry *ent;
6912 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6913 if (ent->plt.refcount > 0)
6916 || (h->type != STT_GNU_IFUNC
6917 && (SYMBOL_CALLS_LOCAL (info, h)
6918 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6919 && h->root.type == bfd_link_hash_undefweak))))
6921 h->plt.plist = NULL;
6924 else if (abiversion (info->output_bfd) == 2)
6926 /* After adjust_dynamic_symbol, non_got_ref set in the
6927 non-shared case means that we have allocated space in
6928 .dynbss for the symbol and thus dyn_relocs for this
6929 symbol should be discarded.
6930 If we get here we know we are making a PLT entry for this
6931 symbol, and in an executable we'd normally resolve
6932 relocations against this symbol to the PLT entry. Allow
6933 dynamic relocs if the reference is weak, and the dynamic
6934 relocs will not cause text relocation. */
6935 if (!h->ref_regular_nonweak
6937 && h->type != STT_GNU_IFUNC
6938 && !readonly_dynrelocs (h))
6941 /* If making a plt entry, then we don't need copy relocs. */
6946 h->plt.plist = NULL;
6948 /* If this is a weak symbol, and there is a real definition, the
6949 processor independent code will have arranged for us to see the
6950 real definition first, and we can just use the same value. */
6951 if (h->u.weakdef != NULL)
6953 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6954 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6955 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6956 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6957 if (ELIMINATE_COPY_RELOCS)
6958 h->non_got_ref = h->u.weakdef->non_got_ref;
6962 /* If we are creating a shared library, we must presume that the
6963 only references to the symbol are via the global offset table.
6964 For such cases we need not do anything here; the relocations will
6965 be handled correctly by relocate_section. */
6969 /* If there are no references to this symbol that do not use the
6970 GOT, we don't need to generate a copy reloc. */
6971 if (!h->non_got_ref)
6974 /* Don't generate a copy reloc for symbols defined in the executable. */
6975 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6978 /* If we didn't find any dynamic relocs in read-only sections, then
6979 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6980 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6986 if (h->plt.plist != NULL)
6988 /* We should never get here, but unfortunately there are versions
6989 of gcc out there that improperly (for this ABI) put initialized
6990 function pointers, vtable refs and suchlike in read-only
6991 sections. Allow them to proceed, but warn that this might
6992 break at runtime. */
6993 info->callbacks->einfo
6994 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6995 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6996 h->root.root.string);
6999 /* This is a reference to a symbol defined by a dynamic object which
7000 is not a function. */
7002 /* We must allocate the symbol in our .dynbss section, which will
7003 become part of the .bss section of the executable. There will be
7004 an entry for this symbol in the .dynsym section. The dynamic
7005 object will contain position independent code, so all references
7006 from the dynamic object to this symbol will go through the global
7007 offset table. The dynamic linker will use the .dynsym entry to
7008 determine the address it must put in the global offset table, so
7009 both the dynamic object and the regular object will refer to the
7010 same memory location for the variable. */
7012 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7013 to copy the initial value out of the dynamic object and into the
7014 runtime process image. We need to remember the offset into the
7015 .rela.bss section we are going to use. */
7016 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7018 htab->relbss->size += sizeof (Elf64_External_Rela);
7024 return _bfd_elf_adjust_dynamic_copy (h, s);
7027 /* If given a function descriptor symbol, hide both the function code
7028 sym and the descriptor. */
7030 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7031 struct elf_link_hash_entry *h,
7032 bfd_boolean force_local)
7034 struct ppc_link_hash_entry *eh;
7035 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7037 eh = (struct ppc_link_hash_entry *) h;
7038 if (eh->is_func_descriptor)
7040 struct ppc_link_hash_entry *fh = eh->oh;
7045 struct ppc_link_hash_table *htab;
7048 /* We aren't supposed to use alloca in BFD because on
7049 systems which do not have alloca the version in libiberty
7050 calls xmalloc, which might cause the program to crash
7051 when it runs out of memory. This function doesn't have a
7052 return status, so there's no way to gracefully return an
7053 error. So cheat. We know that string[-1] can be safely
7054 accessed; It's either a string in an ELF string table,
7055 or allocated in an objalloc structure. */
7057 p = eh->elf.root.root.string - 1;
7060 htab = ppc_hash_table (info);
7064 fh = (struct ppc_link_hash_entry *)
7065 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7068 /* Unfortunately, if it so happens that the string we were
7069 looking for was allocated immediately before this string,
7070 then we overwrote the string terminator. That's the only
7071 reason the lookup should fail. */
7074 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7075 while (q >= eh->elf.root.root.string && *q == *p)
7077 if (q < eh->elf.root.root.string && *p == '.')
7078 fh = (struct ppc_link_hash_entry *)
7079 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7088 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7093 get_sym_h (struct elf_link_hash_entry **hp,
7094 Elf_Internal_Sym **symp,
7096 unsigned char **tls_maskp,
7097 Elf_Internal_Sym **locsymsp,
7098 unsigned long r_symndx,
7101 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7103 if (r_symndx >= symtab_hdr->sh_info)
7105 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7106 struct elf_link_hash_entry *h;
7108 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7109 h = elf_follow_link (h);
7117 if (symsecp != NULL)
7119 asection *symsec = NULL;
7120 if (h->root.type == bfd_link_hash_defined
7121 || h->root.type == bfd_link_hash_defweak)
7122 symsec = h->root.u.def.section;
7126 if (tls_maskp != NULL)
7128 struct ppc_link_hash_entry *eh;
7130 eh = (struct ppc_link_hash_entry *) h;
7131 *tls_maskp = &eh->tls_mask;
7136 Elf_Internal_Sym *sym;
7137 Elf_Internal_Sym *locsyms = *locsymsp;
7139 if (locsyms == NULL)
7141 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7142 if (locsyms == NULL)
7143 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7144 symtab_hdr->sh_info,
7145 0, NULL, NULL, NULL);
7146 if (locsyms == NULL)
7148 *locsymsp = locsyms;
7150 sym = locsyms + r_symndx;
7158 if (symsecp != NULL)
7159 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7161 if (tls_maskp != NULL)
7163 struct got_entry **lgot_ents;
7164 unsigned char *tls_mask;
7167 lgot_ents = elf_local_got_ents (ibfd);
7168 if (lgot_ents != NULL)
7170 struct plt_entry **local_plt = (struct plt_entry **)
7171 (lgot_ents + symtab_hdr->sh_info);
7172 unsigned char *lgot_masks = (unsigned char *)
7173 (local_plt + symtab_hdr->sh_info);
7174 tls_mask = &lgot_masks[r_symndx];
7176 *tls_maskp = tls_mask;
7182 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7183 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7184 type suitable for optimization, and 1 otherwise. */
7187 get_tls_mask (unsigned char **tls_maskp,
7188 unsigned long *toc_symndx,
7189 bfd_vma *toc_addend,
7190 Elf_Internal_Sym **locsymsp,
7191 const Elf_Internal_Rela *rel,
7194 unsigned long r_symndx;
7196 struct elf_link_hash_entry *h;
7197 Elf_Internal_Sym *sym;
7201 r_symndx = ELF64_R_SYM (rel->r_info);
7202 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7205 if ((*tls_maskp != NULL && **tls_maskp != 0)
7207 || ppc64_elf_section_data (sec) == NULL
7208 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7211 /* Look inside a TOC section too. */
7214 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7215 off = h->root.u.def.value;
7218 off = sym->st_value;
7219 off += rel->r_addend;
7220 BFD_ASSERT (off % 8 == 0);
7221 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7222 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7223 if (toc_symndx != NULL)
7224 *toc_symndx = r_symndx;
7225 if (toc_addend != NULL)
7226 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7227 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7229 if ((h == NULL || is_static_defined (h))
7230 && (next_r == -1 || next_r == -2))
7235 /* Find (or create) an entry in the tocsave hash table. */
7237 static struct tocsave_entry *
7238 tocsave_find (struct ppc_link_hash_table *htab,
7239 enum insert_option insert,
7240 Elf_Internal_Sym **local_syms,
7241 const Elf_Internal_Rela *irela,
7244 unsigned long r_indx;
7245 struct elf_link_hash_entry *h;
7246 Elf_Internal_Sym *sym;
7247 struct tocsave_entry ent, *p;
7249 struct tocsave_entry **slot;
7251 r_indx = ELF64_R_SYM (irela->r_info);
7252 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7254 if (ent.sec == NULL || ent.sec->output_section == NULL)
7256 (*_bfd_error_handler)
7257 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7262 ent.offset = h->root.u.def.value;
7264 ent.offset = sym->st_value;
7265 ent.offset += irela->r_addend;
7267 hash = tocsave_htab_hash (&ent);
7268 slot = ((struct tocsave_entry **)
7269 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7275 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7284 /* Adjust all global syms defined in opd sections. In gcc generated
7285 code for the old ABI, these will already have been done. */
7288 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7290 struct ppc_link_hash_entry *eh;
7292 struct _opd_sec_data *opd;
7294 if (h->root.type == bfd_link_hash_indirect)
7297 if (h->root.type != bfd_link_hash_defined
7298 && h->root.type != bfd_link_hash_defweak)
7301 eh = (struct ppc_link_hash_entry *) h;
7302 if (eh->adjust_done)
7305 sym_sec = eh->elf.root.u.def.section;
7306 opd = get_opd_info (sym_sec);
7307 if (opd != NULL && opd->adjust != NULL)
7309 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7312 /* This entry has been deleted. */
7313 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7316 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7317 if (discarded_section (dsec))
7319 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7323 eh->elf.root.u.def.value = 0;
7324 eh->elf.root.u.def.section = dsec;
7327 eh->elf.root.u.def.value += adjust;
7328 eh->adjust_done = 1;
7333 /* Handles decrementing dynamic reloc counts for the reloc specified by
7334 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7335 have already been determined. */
7338 dec_dynrel_count (bfd_vma r_info,
7340 struct bfd_link_info *info,
7341 Elf_Internal_Sym **local_syms,
7342 struct elf_link_hash_entry *h,
7343 Elf_Internal_Sym *sym)
7345 enum elf_ppc64_reloc_type r_type;
7346 asection *sym_sec = NULL;
7348 /* Can this reloc be dynamic? This switch, and later tests here
7349 should be kept in sync with the code in check_relocs. */
7350 r_type = ELF64_R_TYPE (r_info);
7356 case R_PPC64_TPREL16:
7357 case R_PPC64_TPREL16_LO:
7358 case R_PPC64_TPREL16_HI:
7359 case R_PPC64_TPREL16_HA:
7360 case R_PPC64_TPREL16_DS:
7361 case R_PPC64_TPREL16_LO_DS:
7362 case R_PPC64_TPREL16_HIGH:
7363 case R_PPC64_TPREL16_HIGHA:
7364 case R_PPC64_TPREL16_HIGHER:
7365 case R_PPC64_TPREL16_HIGHERA:
7366 case R_PPC64_TPREL16_HIGHEST:
7367 case R_PPC64_TPREL16_HIGHESTA:
7371 case R_PPC64_TPREL64:
7372 case R_PPC64_DTPMOD64:
7373 case R_PPC64_DTPREL64:
7374 case R_PPC64_ADDR64:
7378 case R_PPC64_ADDR14:
7379 case R_PPC64_ADDR14_BRNTAKEN:
7380 case R_PPC64_ADDR14_BRTAKEN:
7381 case R_PPC64_ADDR16:
7382 case R_PPC64_ADDR16_DS:
7383 case R_PPC64_ADDR16_HA:
7384 case R_PPC64_ADDR16_HI:
7385 case R_PPC64_ADDR16_HIGH:
7386 case R_PPC64_ADDR16_HIGHA:
7387 case R_PPC64_ADDR16_HIGHER:
7388 case R_PPC64_ADDR16_HIGHERA:
7389 case R_PPC64_ADDR16_HIGHEST:
7390 case R_PPC64_ADDR16_HIGHESTA:
7391 case R_PPC64_ADDR16_LO:
7392 case R_PPC64_ADDR16_LO_DS:
7393 case R_PPC64_ADDR24:
7394 case R_PPC64_ADDR32:
7395 case R_PPC64_UADDR16:
7396 case R_PPC64_UADDR32:
7397 case R_PPC64_UADDR64:
7402 if (local_syms != NULL)
7404 unsigned long r_symndx;
7405 bfd *ibfd = sec->owner;
7407 r_symndx = ELF64_R_SYM (r_info);
7408 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7413 && (must_be_dyn_reloc (info, r_type)
7415 && (!SYMBOLIC_BIND (info, h)
7416 || h->root.type == bfd_link_hash_defweak
7417 || !h->def_regular))))
7418 || (ELIMINATE_COPY_RELOCS
7421 && (h->root.type == bfd_link_hash_defweak
7422 || !h->def_regular)))
7429 struct elf_dyn_relocs *p;
7430 struct elf_dyn_relocs **pp;
7431 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7433 /* elf_gc_sweep may have already removed all dyn relocs associated
7434 with local syms for a given section. Also, symbol flags are
7435 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7436 report a dynreloc miscount. */
7437 if (*pp == NULL && info->gc_sections)
7440 while ((p = *pp) != NULL)
7444 if (!must_be_dyn_reloc (info, r_type))
7456 struct ppc_dyn_relocs *p;
7457 struct ppc_dyn_relocs **pp;
7459 bfd_boolean is_ifunc;
7461 if (local_syms == NULL)
7462 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7463 if (sym_sec == NULL)
7466 vpp = &elf_section_data (sym_sec)->local_dynrel;
7467 pp = (struct ppc_dyn_relocs **) vpp;
7469 if (*pp == NULL && info->gc_sections)
7472 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7473 while ((p = *pp) != NULL)
7475 if (p->sec == sec && p->ifunc == is_ifunc)
7486 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7488 bfd_set_error (bfd_error_bad_value);
7492 /* Remove unused Official Procedure Descriptor entries. Currently we
7493 only remove those associated with functions in discarded link-once
7494 sections, or weakly defined functions that have been overridden. It
7495 would be possible to remove many more entries for statically linked
7499 ppc64_elf_edit_opd (struct bfd_link_info *info)
7502 bfd_boolean some_edited = FALSE;
7503 asection *need_pad = NULL;
7504 struct ppc_link_hash_table *htab;
7506 htab = ppc_hash_table (info);
7510 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7513 Elf_Internal_Rela *relstart, *rel, *relend;
7514 Elf_Internal_Shdr *symtab_hdr;
7515 Elf_Internal_Sym *local_syms;
7517 struct _opd_sec_data *opd;
7518 bfd_boolean need_edit, add_aux_fields;
7519 bfd_size_type cnt_16b = 0;
7521 if (!is_ppc64_elf (ibfd))
7524 sec = bfd_get_section_by_name (ibfd, ".opd");
7525 if (sec == NULL || sec->size == 0)
7528 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7531 if (sec->output_section == bfd_abs_section_ptr)
7534 /* Look through the section relocs. */
7535 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7539 symtab_hdr = &elf_symtab_hdr (ibfd);
7541 /* Read the relocations. */
7542 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7544 if (relstart == NULL)
7547 /* First run through the relocs to check they are sane, and to
7548 determine whether we need to edit this opd section. */
7552 relend = relstart + sec->reloc_count;
7553 for (rel = relstart; rel < relend; )
7555 enum elf_ppc64_reloc_type r_type;
7556 unsigned long r_symndx;
7558 struct elf_link_hash_entry *h;
7559 Elf_Internal_Sym *sym;
7561 /* .opd contains a regular array of 16 or 24 byte entries. We're
7562 only interested in the reloc pointing to a function entry
7564 if (rel->r_offset != offset
7565 || rel + 1 >= relend
7566 || (rel + 1)->r_offset != offset + 8)
7568 /* If someone messes with .opd alignment then after a
7569 "ld -r" we might have padding in the middle of .opd.
7570 Also, there's nothing to prevent someone putting
7571 something silly in .opd with the assembler. No .opd
7572 optimization for them! */
7574 (*_bfd_error_handler)
7575 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7580 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7581 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7583 (*_bfd_error_handler)
7584 (_("%B: unexpected reloc type %u in .opd section"),
7590 r_symndx = ELF64_R_SYM (rel->r_info);
7591 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7595 if (sym_sec == NULL || sym_sec->owner == NULL)
7597 const char *sym_name;
7599 sym_name = h->root.root.string;
7601 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7604 (*_bfd_error_handler)
7605 (_("%B: undefined sym `%s' in .opd section"),
7611 /* opd entries are always for functions defined in the
7612 current input bfd. If the symbol isn't defined in the
7613 input bfd, then we won't be using the function in this
7614 bfd; It must be defined in a linkonce section in another
7615 bfd, or is weak. It's also possible that we are
7616 discarding the function due to a linker script /DISCARD/,
7617 which we test for via the output_section. */
7618 if (sym_sec->owner != ibfd
7619 || sym_sec->output_section == bfd_abs_section_ptr)
7624 || (rel + 1 == relend && rel->r_offset == offset + 16))
7626 if (sec->size == offset + 24)
7631 if (rel == relend && sec->size == offset + 16)
7639 if (rel->r_offset == offset + 24)
7641 else if (rel->r_offset != offset + 16)
7643 else if (rel + 1 < relend
7644 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7645 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7650 else if (rel + 2 < relend
7651 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7652 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7661 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7663 if (need_edit || add_aux_fields)
7665 Elf_Internal_Rela *write_rel;
7666 Elf_Internal_Shdr *rel_hdr;
7667 bfd_byte *rptr, *wptr;
7668 bfd_byte *new_contents;
7673 new_contents = NULL;
7674 amt = sec->size * sizeof (long) / 8;
7675 opd = &ppc64_elf_section_data (sec)->u.opd;
7676 opd->adjust = bfd_zalloc (sec->owner, amt);
7677 if (opd->adjust == NULL)
7679 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7681 /* This seems a waste of time as input .opd sections are all
7682 zeros as generated by gcc, but I suppose there's no reason
7683 this will always be so. We might start putting something in
7684 the third word of .opd entries. */
7685 if ((sec->flags & SEC_IN_MEMORY) == 0)
7688 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7693 if (local_syms != NULL
7694 && symtab_hdr->contents != (unsigned char *) local_syms)
7696 if (elf_section_data (sec)->relocs != relstart)
7700 sec->contents = loc;
7701 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7704 elf_section_data (sec)->relocs = relstart;
7706 new_contents = sec->contents;
7709 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7710 if (new_contents == NULL)
7714 wptr = new_contents;
7715 rptr = sec->contents;
7717 write_rel = relstart;
7721 for (rel = relstart; rel < relend; rel++)
7723 unsigned long r_symndx;
7725 struct elf_link_hash_entry *h;
7726 Elf_Internal_Sym *sym;
7728 r_symndx = ELF64_R_SYM (rel->r_info);
7729 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7733 if (rel->r_offset == offset)
7735 struct ppc_link_hash_entry *fdh = NULL;
7737 /* See if the .opd entry is full 24 byte or
7738 16 byte (with fd_aux entry overlapped with next
7741 if ((rel + 2 == relend && sec->size == offset + 16)
7742 || (rel + 3 < relend
7743 && rel[2].r_offset == offset + 16
7744 && rel[3].r_offset == offset + 24
7745 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7746 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7750 && h->root.root.string[0] == '.')
7752 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7754 && fdh->elf.root.type != bfd_link_hash_defined
7755 && fdh->elf.root.type != bfd_link_hash_defweak)
7759 skip = (sym_sec->owner != ibfd
7760 || sym_sec->output_section == bfd_abs_section_ptr);
7763 if (fdh != NULL && sym_sec->owner == ibfd)
7765 /* Arrange for the function descriptor sym
7767 fdh->elf.root.u.def.value = 0;
7768 fdh->elf.root.u.def.section = sym_sec;
7770 opd->adjust[rel->r_offset / 8] = -1;
7774 /* We'll be keeping this opd entry. */
7778 /* Redefine the function descriptor symbol to
7779 this location in the opd section. It is
7780 necessary to update the value here rather
7781 than using an array of adjustments as we do
7782 for local symbols, because various places
7783 in the generic ELF code use the value
7784 stored in u.def.value. */
7785 fdh->elf.root.u.def.value = wptr - new_contents;
7786 fdh->adjust_done = 1;
7789 /* Local syms are a bit tricky. We could
7790 tweak them as they can be cached, but
7791 we'd need to look through the local syms
7792 for the function descriptor sym which we
7793 don't have at the moment. So keep an
7794 array of adjustments. */
7795 opd->adjust[rel->r_offset / 8]
7796 = (wptr - new_contents) - (rptr - sec->contents);
7799 memcpy (wptr, rptr, opd_ent_size);
7800 wptr += opd_ent_size;
7801 if (add_aux_fields && opd_ent_size == 16)
7803 memset (wptr, '\0', 8);
7807 rptr += opd_ent_size;
7808 offset += opd_ent_size;
7814 && !info->relocatable
7815 && !dec_dynrel_count (rel->r_info, sec, info,
7821 /* We need to adjust any reloc offsets to point to the
7822 new opd entries. While we're at it, we may as well
7823 remove redundant relocs. */
7824 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7825 if (write_rel != rel)
7826 memcpy (write_rel, rel, sizeof (*rel));
7831 sec->size = wptr - new_contents;
7832 sec->reloc_count = write_rel - relstart;
7835 free (sec->contents);
7836 sec->contents = new_contents;
7839 /* Fudge the header size too, as this is used later in
7840 elf_bfd_final_link if we are emitting relocs. */
7841 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7842 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7845 else if (elf_section_data (sec)->relocs != relstart)
7848 if (local_syms != NULL
7849 && symtab_hdr->contents != (unsigned char *) local_syms)
7851 if (!info->keep_memory)
7854 symtab_hdr->contents = (unsigned char *) local_syms;
7859 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7861 /* If we are doing a final link and the last .opd entry is just 16 byte
7862 long, add a 8 byte padding after it. */
7863 if (need_pad != NULL && !info->relocatable)
7867 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7869 BFD_ASSERT (need_pad->size > 0);
7871 p = bfd_malloc (need_pad->size + 8);
7875 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7876 p, 0, need_pad->size))
7879 need_pad->contents = p;
7880 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7884 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7888 need_pad->contents = p;
7891 memset (need_pad->contents + need_pad->size, 0, 8);
7892 need_pad->size += 8;
7898 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7901 ppc64_elf_tls_setup (struct bfd_link_info *info)
7903 struct ppc_link_hash_table *htab;
7905 htab = ppc_hash_table (info);
7909 if (abiversion (info->output_bfd) == 1)
7912 if (htab->params->no_multi_toc)
7913 htab->do_multi_toc = 0;
7914 else if (!htab->do_multi_toc)
7915 htab->params->no_multi_toc = 1;
7917 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7918 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7919 FALSE, FALSE, TRUE));
7920 /* Move dynamic linking info to the function descriptor sym. */
7921 if (htab->tls_get_addr != NULL)
7922 func_desc_adjust (&htab->tls_get_addr->elf, info);
7923 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7924 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7925 FALSE, FALSE, TRUE));
7926 if (!htab->params->no_tls_get_addr_opt)
7928 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7930 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7931 FALSE, FALSE, TRUE);
7933 func_desc_adjust (opt, info);
7934 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7935 FALSE, FALSE, TRUE);
7937 && (opt_fd->root.type == bfd_link_hash_defined
7938 || opt_fd->root.type == bfd_link_hash_defweak))
7940 /* If glibc supports an optimized __tls_get_addr call stub,
7941 signalled by the presence of __tls_get_addr_opt, and we'll
7942 be calling __tls_get_addr via a plt call stub, then
7943 make __tls_get_addr point to __tls_get_addr_opt. */
7944 tga_fd = &htab->tls_get_addr_fd->elf;
7945 if (htab->elf.dynamic_sections_created
7947 && (tga_fd->type == STT_FUNC
7948 || tga_fd->needs_plt)
7949 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7950 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7951 && tga_fd->root.type == bfd_link_hash_undefweak)))
7953 struct plt_entry *ent;
7955 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7956 if (ent->plt.refcount > 0)
7960 tga_fd->root.type = bfd_link_hash_indirect;
7961 tga_fd->root.u.i.link = &opt_fd->root;
7962 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7963 if (opt_fd->dynindx != -1)
7965 /* Use __tls_get_addr_opt in dynamic relocations. */
7966 opt_fd->dynindx = -1;
7967 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7968 opt_fd->dynstr_index);
7969 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7972 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7973 tga = &htab->tls_get_addr->elf;
7974 if (opt != NULL && tga != NULL)
7976 tga->root.type = bfd_link_hash_indirect;
7977 tga->root.u.i.link = &opt->root;
7978 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7979 _bfd_elf_link_hash_hide_symbol (info, opt,
7981 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7983 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7984 htab->tls_get_addr_fd->is_func_descriptor = 1;
7985 if (htab->tls_get_addr != NULL)
7987 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7988 htab->tls_get_addr->is_func = 1;
7994 htab->params->no_tls_get_addr_opt = TRUE;
7996 return _bfd_elf_tls_setup (info->output_bfd, info);
7999 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8003 branch_reloc_hash_match (const bfd *ibfd,
8004 const Elf_Internal_Rela *rel,
8005 const struct ppc_link_hash_entry *hash1,
8006 const struct ppc_link_hash_entry *hash2)
8008 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8009 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8010 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8012 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8014 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8015 struct elf_link_hash_entry *h;
8017 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8018 h = elf_follow_link (h);
8019 if (h == &hash1->elf || h == &hash2->elf)
8025 /* Run through all the TLS relocs looking for optimization
8026 opportunities. The linker has been hacked (see ppc64elf.em) to do
8027 a preliminary section layout so that we know the TLS segment
8028 offsets. We can't optimize earlier because some optimizations need
8029 to know the tp offset, and we need to optimize before allocating
8030 dynamic relocations. */
8033 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8037 struct ppc_link_hash_table *htab;
8038 unsigned char *toc_ref;
8041 if (info->relocatable || !info->executable)
8044 htab = ppc_hash_table (info);
8048 /* Make two passes over the relocs. On the first pass, mark toc
8049 entries involved with tls relocs, and check that tls relocs
8050 involved in setting up a tls_get_addr call are indeed followed by
8051 such a call. If they are not, we can't do any tls optimization.
8052 On the second pass twiddle tls_mask flags to notify
8053 relocate_section that optimization can be done, and adjust got
8054 and plt refcounts. */
8056 for (pass = 0; pass < 2; ++pass)
8057 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8059 Elf_Internal_Sym *locsyms = NULL;
8060 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8062 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8063 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8065 Elf_Internal_Rela *relstart, *rel, *relend;
8066 bfd_boolean found_tls_get_addr_arg = 0;
8068 /* Read the relocations. */
8069 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8071 if (relstart == NULL)
8077 relend = relstart + sec->reloc_count;
8078 for (rel = relstart; rel < relend; rel++)
8080 enum elf_ppc64_reloc_type r_type;
8081 unsigned long r_symndx;
8082 struct elf_link_hash_entry *h;
8083 Elf_Internal_Sym *sym;
8085 unsigned char *tls_mask;
8086 unsigned char tls_set, tls_clear, tls_type = 0;
8088 bfd_boolean ok_tprel, is_local;
8089 long toc_ref_index = 0;
8090 int expecting_tls_get_addr = 0;
8091 bfd_boolean ret = FALSE;
8093 r_symndx = ELF64_R_SYM (rel->r_info);
8094 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8098 if (elf_section_data (sec)->relocs != relstart)
8100 if (toc_ref != NULL)
8103 && (elf_symtab_hdr (ibfd).contents
8104 != (unsigned char *) locsyms))
8111 if (h->root.type == bfd_link_hash_defined
8112 || h->root.type == bfd_link_hash_defweak)
8113 value = h->root.u.def.value;
8114 else if (h->root.type == bfd_link_hash_undefweak)
8118 found_tls_get_addr_arg = 0;
8123 /* Symbols referenced by TLS relocs must be of type
8124 STT_TLS. So no need for .opd local sym adjust. */
8125 value = sym->st_value;
8134 && h->root.type == bfd_link_hash_undefweak)
8138 value += sym_sec->output_offset;
8139 value += sym_sec->output_section->vma;
8140 value -= htab->elf.tls_sec->vma;
8141 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8142 < (bfd_vma) 1 << 32);
8146 r_type = ELF64_R_TYPE (rel->r_info);
8147 /* If this section has old-style __tls_get_addr calls
8148 without marker relocs, then check that each
8149 __tls_get_addr call reloc is preceded by a reloc
8150 that conceivably belongs to the __tls_get_addr arg
8151 setup insn. If we don't find matching arg setup
8152 relocs, don't do any tls optimization. */
8154 && sec->has_tls_get_addr_call
8156 && (h == &htab->tls_get_addr->elf
8157 || h == &htab->tls_get_addr_fd->elf)
8158 && !found_tls_get_addr_arg
8159 && is_branch_reloc (r_type))
8161 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8162 "TLS optimization disabled\n"),
8163 ibfd, sec, rel->r_offset);
8168 found_tls_get_addr_arg = 0;
8171 case R_PPC64_GOT_TLSLD16:
8172 case R_PPC64_GOT_TLSLD16_LO:
8173 expecting_tls_get_addr = 1;
8174 found_tls_get_addr_arg = 1;
8177 case R_PPC64_GOT_TLSLD16_HI:
8178 case R_PPC64_GOT_TLSLD16_HA:
8179 /* These relocs should never be against a symbol
8180 defined in a shared lib. Leave them alone if
8181 that turns out to be the case. */
8188 tls_type = TLS_TLS | TLS_LD;
8191 case R_PPC64_GOT_TLSGD16:
8192 case R_PPC64_GOT_TLSGD16_LO:
8193 expecting_tls_get_addr = 1;
8194 found_tls_get_addr_arg = 1;
8197 case R_PPC64_GOT_TLSGD16_HI:
8198 case R_PPC64_GOT_TLSGD16_HA:
8204 tls_set = TLS_TLS | TLS_TPRELGD;
8206 tls_type = TLS_TLS | TLS_GD;
8209 case R_PPC64_GOT_TPREL16_DS:
8210 case R_PPC64_GOT_TPREL16_LO_DS:
8211 case R_PPC64_GOT_TPREL16_HI:
8212 case R_PPC64_GOT_TPREL16_HA:
8217 tls_clear = TLS_TPREL;
8218 tls_type = TLS_TLS | TLS_TPREL;
8225 found_tls_get_addr_arg = 1;
8230 case R_PPC64_TOC16_LO:
8231 if (sym_sec == NULL || sym_sec != toc)
8234 /* Mark this toc entry as referenced by a TLS
8235 code sequence. We can do that now in the
8236 case of R_PPC64_TLS, and after checking for
8237 tls_get_addr for the TOC16 relocs. */
8238 if (toc_ref == NULL)
8239 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8240 if (toc_ref == NULL)
8244 value = h->root.u.def.value;
8246 value = sym->st_value;
8247 value += rel->r_addend;
8248 BFD_ASSERT (value < toc->size && value % 8 == 0);
8249 toc_ref_index = (value + toc->output_offset) / 8;
8250 if (r_type == R_PPC64_TLS
8251 || r_type == R_PPC64_TLSGD
8252 || r_type == R_PPC64_TLSLD)
8254 toc_ref[toc_ref_index] = 1;
8258 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8263 expecting_tls_get_addr = 2;
8266 case R_PPC64_TPREL64:
8270 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8275 tls_set = TLS_EXPLICIT;
8276 tls_clear = TLS_TPREL;
8281 case R_PPC64_DTPMOD64:
8285 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8287 if (rel + 1 < relend
8289 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8290 && rel[1].r_offset == rel->r_offset + 8)
8294 tls_set = TLS_EXPLICIT | TLS_GD;
8297 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8306 tls_set = TLS_EXPLICIT;
8317 if (!expecting_tls_get_addr
8318 || !sec->has_tls_get_addr_call)
8321 if (rel + 1 < relend
8322 && branch_reloc_hash_match (ibfd, rel + 1,
8324 htab->tls_get_addr_fd))
8326 if (expecting_tls_get_addr == 2)
8328 /* Check for toc tls entries. */
8329 unsigned char *toc_tls;
8332 retval = get_tls_mask (&toc_tls, NULL, NULL,
8337 if (toc_tls != NULL)
8339 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8340 found_tls_get_addr_arg = 1;
8342 toc_ref[toc_ref_index] = 1;
8348 if (expecting_tls_get_addr != 1)
8351 /* Uh oh, we didn't find the expected call. We
8352 could just mark this symbol to exclude it
8353 from tls optimization but it's safer to skip
8354 the entire optimization. */
8355 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8356 "TLS optimization disabled\n"),
8357 ibfd, sec, rel->r_offset);
8362 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8364 struct plt_entry *ent;
8365 for (ent = htab->tls_get_addr->elf.plt.plist;
8368 if (ent->addend == 0)
8370 if (ent->plt.refcount > 0)
8372 ent->plt.refcount -= 1;
8373 expecting_tls_get_addr = 0;
8379 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8381 struct plt_entry *ent;
8382 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8385 if (ent->addend == 0)
8387 if (ent->plt.refcount > 0)
8388 ent->plt.refcount -= 1;
8396 if ((tls_set & TLS_EXPLICIT) == 0)
8398 struct got_entry *ent;
8400 /* Adjust got entry for this reloc. */
8404 ent = elf_local_got_ents (ibfd)[r_symndx];
8406 for (; ent != NULL; ent = ent->next)
8407 if (ent->addend == rel->r_addend
8408 && ent->owner == ibfd
8409 && ent->tls_type == tls_type)
8416 /* We managed to get rid of a got entry. */
8417 if (ent->got.refcount > 0)
8418 ent->got.refcount -= 1;
8423 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8424 we'll lose one or two dyn relocs. */
8425 if (!dec_dynrel_count (rel->r_info, sec, info,
8429 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8431 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8437 *tls_mask |= tls_set;
8438 *tls_mask &= ~tls_clear;
8441 if (elf_section_data (sec)->relocs != relstart)
8446 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8448 if (!info->keep_memory)
8451 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8455 if (toc_ref != NULL)
8460 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8461 the values of any global symbols in a toc section that has been
8462 edited. Globals in toc sections should be a rarity, so this function
8463 sets a flag if any are found in toc sections other than the one just
8464 edited, so that futher hash table traversals can be avoided. */
8466 struct adjust_toc_info
8469 unsigned long *skip;
8470 bfd_boolean global_toc_syms;
8473 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8476 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8478 struct ppc_link_hash_entry *eh;
8479 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8482 if (h->root.type != bfd_link_hash_defined
8483 && h->root.type != bfd_link_hash_defweak)
8486 eh = (struct ppc_link_hash_entry *) h;
8487 if (eh->adjust_done)
8490 if (eh->elf.root.u.def.section == toc_inf->toc)
8492 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8493 i = toc_inf->toc->rawsize >> 3;
8495 i = eh->elf.root.u.def.value >> 3;
8497 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8499 (*_bfd_error_handler)
8500 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8503 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8504 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8507 eh->elf.root.u.def.value -= toc_inf->skip[i];
8508 eh->adjust_done = 1;
8510 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8511 toc_inf->global_toc_syms = TRUE;
8516 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8519 ok_lo_toc_insn (unsigned int insn)
8521 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8522 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8523 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8524 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8525 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8526 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8527 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8528 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8529 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8530 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8531 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8532 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8533 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8534 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8535 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8537 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8538 && ((insn & 3) == 0 || (insn & 3) == 3))
8539 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8542 /* Examine all relocs referencing .toc sections in order to remove
8543 unused .toc entries. */
8546 ppc64_elf_edit_toc (struct bfd_link_info *info)
8549 struct adjust_toc_info toc_inf;
8550 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552 htab->do_toc_opt = 1;
8553 toc_inf.global_toc_syms = TRUE;
8554 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8556 asection *toc, *sec;
8557 Elf_Internal_Shdr *symtab_hdr;
8558 Elf_Internal_Sym *local_syms;
8559 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8560 unsigned long *skip, *drop;
8561 unsigned char *used;
8562 unsigned char *keep, last, some_unused;
8564 if (!is_ppc64_elf (ibfd))
8567 toc = bfd_get_section_by_name (ibfd, ".toc");
8570 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8571 || discarded_section (toc))
8576 symtab_hdr = &elf_symtab_hdr (ibfd);
8578 /* Look at sections dropped from the final link. */
8581 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8583 if (sec->reloc_count == 0
8584 || !discarded_section (sec)
8585 || get_opd_info (sec)
8586 || (sec->flags & SEC_ALLOC) == 0
8587 || (sec->flags & SEC_DEBUGGING) != 0)
8590 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8591 if (relstart == NULL)
8594 /* Run through the relocs to see which toc entries might be
8596 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8598 enum elf_ppc64_reloc_type r_type;
8599 unsigned long r_symndx;
8601 struct elf_link_hash_entry *h;
8602 Elf_Internal_Sym *sym;
8605 r_type = ELF64_R_TYPE (rel->r_info);
8612 case R_PPC64_TOC16_LO:
8613 case R_PPC64_TOC16_HI:
8614 case R_PPC64_TOC16_HA:
8615 case R_PPC64_TOC16_DS:
8616 case R_PPC64_TOC16_LO_DS:
8620 r_symndx = ELF64_R_SYM (rel->r_info);
8621 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8629 val = h->root.u.def.value;
8631 val = sym->st_value;
8632 val += rel->r_addend;
8634 if (val >= toc->size)
8637 /* Anything in the toc ought to be aligned to 8 bytes.
8638 If not, don't mark as unused. */
8644 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8649 skip[val >> 3] = ref_from_discarded;
8652 if (elf_section_data (sec)->relocs != relstart)
8656 /* For largetoc loads of address constants, we can convert
8657 . addis rx,2,addr@got@ha
8658 . ld ry,addr@got@l(rx)
8660 . addis rx,2,addr@toc@ha
8661 . addi ry,rx,addr@toc@l
8662 when addr is within 2G of the toc pointer. This then means
8663 that the word storing "addr" in the toc is no longer needed. */
8665 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8666 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8667 && toc->reloc_count != 0)
8669 /* Read toc relocs. */
8670 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8672 if (toc_relocs == NULL)
8675 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8677 enum elf_ppc64_reloc_type r_type;
8678 unsigned long r_symndx;
8680 struct elf_link_hash_entry *h;
8681 Elf_Internal_Sym *sym;
8684 r_type = ELF64_R_TYPE (rel->r_info);
8685 if (r_type != R_PPC64_ADDR64)
8688 r_symndx = ELF64_R_SYM (rel->r_info);
8689 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8694 || discarded_section (sym_sec))
8697 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8702 if (h->type == STT_GNU_IFUNC)
8704 val = h->root.u.def.value;
8708 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8710 val = sym->st_value;
8712 val += rel->r_addend;
8713 val += sym_sec->output_section->vma + sym_sec->output_offset;
8715 /* We don't yet know the exact toc pointer value, but we
8716 know it will be somewhere in the toc section. Don't
8717 optimize if the difference from any possible toc
8718 pointer is outside [ff..f80008000, 7fff7fff]. */
8719 addr = toc->output_section->vma + TOC_BASE_OFF;
8720 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8723 addr = toc->output_section->vma + toc->output_section->rawsize;
8724 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8729 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8734 skip[rel->r_offset >> 3]
8735 |= can_optimize | ((rel - toc_relocs) << 2);
8742 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8746 if (local_syms != NULL
8747 && symtab_hdr->contents != (unsigned char *) local_syms)
8751 && elf_section_data (sec)->relocs != relstart)
8753 if (toc_relocs != NULL
8754 && elf_section_data (toc)->relocs != toc_relocs)
8761 /* Now check all kept sections that might reference the toc.
8762 Check the toc itself last. */
8763 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8766 sec = (sec == toc ? NULL
8767 : sec->next == NULL ? toc
8768 : sec->next == toc && toc->next ? toc->next
8773 if (sec->reloc_count == 0
8774 || discarded_section (sec)
8775 || get_opd_info (sec)
8776 || (sec->flags & SEC_ALLOC) == 0
8777 || (sec->flags & SEC_DEBUGGING) != 0)
8780 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8782 if (relstart == NULL)
8788 /* Mark toc entries referenced as used. */
8792 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8794 enum elf_ppc64_reloc_type r_type;
8795 unsigned long r_symndx;
8797 struct elf_link_hash_entry *h;
8798 Elf_Internal_Sym *sym;
8800 enum {no_check, check_lo, check_ha} insn_check;
8802 r_type = ELF64_R_TYPE (rel->r_info);
8806 insn_check = no_check;
8809 case R_PPC64_GOT_TLSLD16_HA:
8810 case R_PPC64_GOT_TLSGD16_HA:
8811 case R_PPC64_GOT_TPREL16_HA:
8812 case R_PPC64_GOT_DTPREL16_HA:
8813 case R_PPC64_GOT16_HA:
8814 case R_PPC64_TOC16_HA:
8815 insn_check = check_ha;
8818 case R_PPC64_GOT_TLSLD16_LO:
8819 case R_PPC64_GOT_TLSGD16_LO:
8820 case R_PPC64_GOT_TPREL16_LO_DS:
8821 case R_PPC64_GOT_DTPREL16_LO_DS:
8822 case R_PPC64_GOT16_LO:
8823 case R_PPC64_GOT16_LO_DS:
8824 case R_PPC64_TOC16_LO:
8825 case R_PPC64_TOC16_LO_DS:
8826 insn_check = check_lo;
8830 if (insn_check != no_check)
8832 bfd_vma off = rel->r_offset & ~3;
8833 unsigned char buf[4];
8836 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8841 insn = bfd_get_32 (ibfd, buf);
8842 if (insn_check == check_lo
8843 ? !ok_lo_toc_insn (insn)
8844 : ((insn & ((0x3f << 26) | 0x1f << 16))
8845 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8849 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8850 sprintf (str, "%#08x", insn);
8851 info->callbacks->einfo
8852 (_("%P: %H: toc optimization is not supported for"
8853 " %s instruction.\n"),
8854 ibfd, sec, rel->r_offset & ~3, str);
8861 case R_PPC64_TOC16_LO:
8862 case R_PPC64_TOC16_HI:
8863 case R_PPC64_TOC16_HA:
8864 case R_PPC64_TOC16_DS:
8865 case R_PPC64_TOC16_LO_DS:
8866 /* In case we're taking addresses of toc entries. */
8867 case R_PPC64_ADDR64:
8874 r_symndx = ELF64_R_SYM (rel->r_info);
8875 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8886 val = h->root.u.def.value;
8888 val = sym->st_value;
8889 val += rel->r_addend;
8891 if (val >= toc->size)
8894 if ((skip[val >> 3] & can_optimize) != 0)
8901 case R_PPC64_TOC16_HA:
8904 case R_PPC64_TOC16_LO_DS:
8905 off = rel->r_offset;
8906 off += (bfd_big_endian (ibfd) ? -2 : 3);
8907 if (!bfd_get_section_contents (ibfd, sec, &opc,
8913 if ((opc & (0x3f << 2)) == (58u << 2))
8918 /* Wrong sort of reloc, or not a ld. We may
8919 as well clear ref_from_discarded too. */
8926 /* For the toc section, we only mark as used if this
8927 entry itself isn't unused. */
8928 else if ((used[rel->r_offset >> 3]
8929 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8932 /* Do all the relocs again, to catch reference
8941 if (elf_section_data (sec)->relocs != relstart)
8945 /* Merge the used and skip arrays. Assume that TOC
8946 doublewords not appearing as either used or unused belong
8947 to to an entry more than one doubleword in size. */
8948 for (drop = skip, keep = used, last = 0, some_unused = 0;
8949 drop < skip + (toc->size + 7) / 8;
8954 *drop &= ~ref_from_discarded;
8955 if ((*drop & can_optimize) != 0)
8959 else if ((*drop & ref_from_discarded) != 0)
8962 last = ref_from_discarded;
8972 bfd_byte *contents, *src;
8974 Elf_Internal_Sym *sym;
8975 bfd_boolean local_toc_syms = FALSE;
8977 /* Shuffle the toc contents, and at the same time convert the
8978 skip array from booleans into offsets. */
8979 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8982 elf_section_data (toc)->this_hdr.contents = contents;
8984 for (src = contents, off = 0, drop = skip;
8985 src < contents + toc->size;
8988 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8993 memcpy (src - off, src, 8);
8997 toc->rawsize = toc->size;
8998 toc->size = src - contents - off;
9000 /* Adjust addends for relocs against the toc section sym,
9001 and optimize any accesses we can. */
9002 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9004 if (sec->reloc_count == 0
9005 || discarded_section (sec))
9008 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9010 if (relstart == NULL)
9013 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9015 enum elf_ppc64_reloc_type r_type;
9016 unsigned long r_symndx;
9018 struct elf_link_hash_entry *h;
9021 r_type = ELF64_R_TYPE (rel->r_info);
9028 case R_PPC64_TOC16_LO:
9029 case R_PPC64_TOC16_HI:
9030 case R_PPC64_TOC16_HA:
9031 case R_PPC64_TOC16_DS:
9032 case R_PPC64_TOC16_LO_DS:
9033 case R_PPC64_ADDR64:
9037 r_symndx = ELF64_R_SYM (rel->r_info);
9038 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9046 val = h->root.u.def.value;
9049 val = sym->st_value;
9051 local_toc_syms = TRUE;
9054 val += rel->r_addend;
9056 if (val > toc->rawsize)
9058 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9060 else if ((skip[val >> 3] & can_optimize) != 0)
9062 Elf_Internal_Rela *tocrel
9063 = toc_relocs + (skip[val >> 3] >> 2);
9064 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9068 case R_PPC64_TOC16_HA:
9069 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9072 case R_PPC64_TOC16_LO_DS:
9073 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9077 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9079 info->callbacks->einfo
9080 (_("%P: %H: %s references "
9081 "optimized away TOC entry\n"),
9082 ibfd, sec, rel->r_offset,
9083 ppc64_elf_howto_table[r_type]->name);
9084 bfd_set_error (bfd_error_bad_value);
9087 rel->r_addend = tocrel->r_addend;
9088 elf_section_data (sec)->relocs = relstart;
9092 if (h != NULL || sym->st_value != 0)
9095 rel->r_addend -= skip[val >> 3];
9096 elf_section_data (sec)->relocs = relstart;
9099 if (elf_section_data (sec)->relocs != relstart)
9103 /* We shouldn't have local or global symbols defined in the TOC,
9104 but handle them anyway. */
9105 if (local_syms != NULL)
9106 for (sym = local_syms;
9107 sym < local_syms + symtab_hdr->sh_info;
9109 if (sym->st_value != 0
9110 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9114 if (sym->st_value > toc->rawsize)
9115 i = toc->rawsize >> 3;
9117 i = sym->st_value >> 3;
9119 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9122 (*_bfd_error_handler)
9123 (_("%s defined on removed toc entry"),
9124 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9127 while ((skip[i] & (ref_from_discarded | can_optimize)));
9128 sym->st_value = (bfd_vma) i << 3;
9131 sym->st_value -= skip[i];
9132 symtab_hdr->contents = (unsigned char *) local_syms;
9135 /* Adjust any global syms defined in this toc input section. */
9136 if (toc_inf.global_toc_syms)
9139 toc_inf.skip = skip;
9140 toc_inf.global_toc_syms = FALSE;
9141 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9145 if (toc->reloc_count != 0)
9147 Elf_Internal_Shdr *rel_hdr;
9148 Elf_Internal_Rela *wrel;
9151 /* Remove unused toc relocs, and adjust those we keep. */
9152 if (toc_relocs == NULL)
9153 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9155 if (toc_relocs == NULL)
9159 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9160 if ((skip[rel->r_offset >> 3]
9161 & (ref_from_discarded | can_optimize)) == 0)
9163 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9164 wrel->r_info = rel->r_info;
9165 wrel->r_addend = rel->r_addend;
9168 else if (!dec_dynrel_count (rel->r_info, toc, info,
9169 &local_syms, NULL, NULL))
9172 elf_section_data (toc)->relocs = toc_relocs;
9173 toc->reloc_count = wrel - toc_relocs;
9174 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9175 sz = rel_hdr->sh_entsize;
9176 rel_hdr->sh_size = toc->reloc_count * sz;
9179 else if (toc_relocs != NULL
9180 && elf_section_data (toc)->relocs != toc_relocs)
9183 if (local_syms != NULL
9184 && symtab_hdr->contents != (unsigned char *) local_syms)
9186 if (!info->keep_memory)
9189 symtab_hdr->contents = (unsigned char *) local_syms;
9197 /* Return true iff input section I references the TOC using
9198 instructions limited to +/-32k offsets. */
9201 ppc64_elf_has_small_toc_reloc (asection *i)
9203 return (is_ppc64_elf (i->owner)
9204 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9207 /* Allocate space for one GOT entry. */
9210 allocate_got (struct elf_link_hash_entry *h,
9211 struct bfd_link_info *info,
9212 struct got_entry *gent)
9214 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9216 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9217 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9219 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9220 ? 2 : 1) * sizeof (Elf64_External_Rela);
9221 asection *got = ppc64_elf_tdata (gent->owner)->got;
9223 gent->got.offset = got->size;
9224 got->size += entsize;
9226 dyn = htab->elf.dynamic_sections_created;
9227 if (h->type == STT_GNU_IFUNC)
9229 htab->elf.irelplt->size += rentsize;
9230 htab->got_reli_size += rentsize;
9232 else if ((info->shared
9233 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9234 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9235 || h->root.type != bfd_link_hash_undefweak))
9237 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9238 relgot->size += rentsize;
9242 /* This function merges got entries in the same toc group. */
9245 merge_got_entries (struct got_entry **pent)
9247 struct got_entry *ent, *ent2;
9249 for (ent = *pent; ent != NULL; ent = ent->next)
9250 if (!ent->is_indirect)
9251 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9252 if (!ent2->is_indirect
9253 && ent2->addend == ent->addend
9254 && ent2->tls_type == ent->tls_type
9255 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9257 ent2->is_indirect = TRUE;
9258 ent2->got.ent = ent;
9262 /* Allocate space in .plt, .got and associated reloc sections for
9266 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9268 struct bfd_link_info *info;
9269 struct ppc_link_hash_table *htab;
9271 struct ppc_link_hash_entry *eh;
9272 struct elf_dyn_relocs *p;
9273 struct got_entry **pgent, *gent;
9275 if (h->root.type == bfd_link_hash_indirect)
9278 info = (struct bfd_link_info *) inf;
9279 htab = ppc_hash_table (info);
9283 if ((htab->elf.dynamic_sections_created
9285 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9286 || h->type == STT_GNU_IFUNC)
9288 struct plt_entry *pent;
9289 bfd_boolean doneone = FALSE;
9290 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9291 if (pent->plt.refcount > 0)
9293 if (!htab->elf.dynamic_sections_created
9294 || h->dynindx == -1)
9297 pent->plt.offset = s->size;
9298 s->size += PLT_ENTRY_SIZE (htab);
9299 s = htab->elf.irelplt;
9303 /* If this is the first .plt entry, make room for the special
9307 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9309 pent->plt.offset = s->size;
9311 /* Make room for this entry. */
9312 s->size += PLT_ENTRY_SIZE (htab);
9314 /* Make room for the .glink code. */
9317 s->size += GLINK_CALL_STUB_SIZE;
9320 /* We need bigger stubs past index 32767. */
9321 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9328 /* We also need to make an entry in the .rela.plt section. */
9329 s = htab->elf.srelplt;
9331 s->size += sizeof (Elf64_External_Rela);
9335 pent->plt.offset = (bfd_vma) -1;
9338 h->plt.plist = NULL;
9344 h->plt.plist = NULL;
9348 eh = (struct ppc_link_hash_entry *) h;
9349 /* Run through the TLS GD got entries first if we're changing them
9351 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9352 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9353 if (gent->got.refcount > 0
9354 && (gent->tls_type & TLS_GD) != 0)
9356 /* This was a GD entry that has been converted to TPREL. If
9357 there happens to be a TPREL entry we can use that one. */
9358 struct got_entry *ent;
9359 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9360 if (ent->got.refcount > 0
9361 && (ent->tls_type & TLS_TPREL) != 0
9362 && ent->addend == gent->addend
9363 && ent->owner == gent->owner)
9365 gent->got.refcount = 0;
9369 /* If not, then we'll be using our own TPREL entry. */
9370 if (gent->got.refcount != 0)
9371 gent->tls_type = TLS_TLS | TLS_TPREL;
9374 /* Remove any list entry that won't generate a word in the GOT before
9375 we call merge_got_entries. Otherwise we risk merging to empty
9377 pgent = &h->got.glist;
9378 while ((gent = *pgent) != NULL)
9379 if (gent->got.refcount > 0)
9381 if ((gent->tls_type & TLS_LD) != 0
9384 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9385 *pgent = gent->next;
9388 pgent = &gent->next;
9391 *pgent = gent->next;
9393 if (!htab->do_multi_toc)
9394 merge_got_entries (&h->got.glist);
9396 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9397 if (!gent->is_indirect)
9399 /* Make sure this symbol is output as a dynamic symbol.
9400 Undefined weak syms won't yet be marked as dynamic,
9401 nor will all TLS symbols. */
9402 if (h->dynindx == -1
9404 && h->type != STT_GNU_IFUNC
9405 && htab->elf.dynamic_sections_created)
9407 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9411 if (!is_ppc64_elf (gent->owner))
9414 allocate_got (h, info, gent);
9417 if (eh->dyn_relocs == NULL
9418 || (!htab->elf.dynamic_sections_created
9419 && h->type != STT_GNU_IFUNC))
9422 /* In the shared -Bsymbolic case, discard space allocated for
9423 dynamic pc-relative relocs against symbols which turn out to be
9424 defined in regular objects. For the normal shared case, discard
9425 space for relocs that have become local due to symbol visibility
9430 /* Relocs that use pc_count are those that appear on a call insn,
9431 or certain REL relocs (see must_be_dyn_reloc) that can be
9432 generated via assembly. We want calls to protected symbols to
9433 resolve directly to the function rather than going via the plt.
9434 If people want function pointer comparisons to work as expected
9435 then they should avoid writing weird assembly. */
9436 if (SYMBOL_CALLS_LOCAL (info, h))
9438 struct elf_dyn_relocs **pp;
9440 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9442 p->count -= p->pc_count;
9451 /* Also discard relocs on undefined weak syms with non-default
9453 if (eh->dyn_relocs != NULL
9454 && h->root.type == bfd_link_hash_undefweak)
9456 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9457 eh->dyn_relocs = NULL;
9459 /* Make sure this symbol is output as a dynamic symbol.
9460 Undefined weak syms won't yet be marked as dynamic. */
9461 else if (h->dynindx == -1
9462 && !h->forced_local)
9464 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9469 else if (h->type == STT_GNU_IFUNC)
9471 if (!h->non_got_ref)
9472 eh->dyn_relocs = NULL;
9474 else if (ELIMINATE_COPY_RELOCS)
9476 /* For the non-shared case, discard space for relocs against
9477 symbols which turn out to need copy relocs or are not
9483 /* Make sure this symbol is output as a dynamic symbol.
9484 Undefined weak syms won't yet be marked as dynamic. */
9485 if (h->dynindx == -1
9486 && !h->forced_local)
9488 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9492 /* If that succeeded, we know we'll be keeping all the
9494 if (h->dynindx != -1)
9498 eh->dyn_relocs = NULL;
9503 /* Finally, allocate space. */
9504 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9506 asection *sreloc = elf_section_data (p->sec)->sreloc;
9507 if (eh->elf.type == STT_GNU_IFUNC)
9508 sreloc = htab->elf.irelplt;
9509 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9515 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9516 to set up space for global entry stubs. These are put in glink,
9517 after the branch table. */
9520 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9522 struct bfd_link_info *info;
9523 struct ppc_link_hash_table *htab;
9524 struct plt_entry *pent;
9527 if (h->root.type == bfd_link_hash_indirect)
9530 if (!h->pointer_equality_needed)
9537 htab = ppc_hash_table (info);
9542 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9543 if (pent->plt.offset != (bfd_vma) -1
9544 && pent->addend == 0)
9546 /* For ELFv2, if this symbol is not defined in a regular file
9547 and we are not generating a shared library or pie, then we
9548 need to define the symbol in the executable on a call stub.
9549 This is to avoid text relocations. */
9550 s->size = (s->size + 15) & -16;
9551 h->root.u.def.section = s;
9552 h->root.u.def.value = s->size;
9559 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9560 read-only sections. */
9563 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9565 if (h->root.type == bfd_link_hash_indirect)
9568 if (readonly_dynrelocs (h))
9570 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9572 /* Not an error, just cut short the traversal. */
9578 /* Set the sizes of the dynamic sections. */
9581 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9582 struct bfd_link_info *info)
9584 struct ppc_link_hash_table *htab;
9589 struct got_entry *first_tlsld;
9591 htab = ppc_hash_table (info);
9595 dynobj = htab->elf.dynobj;
9599 if (htab->elf.dynamic_sections_created)
9601 /* Set the contents of the .interp section to the interpreter. */
9602 if (info->executable)
9604 s = bfd_get_linker_section (dynobj, ".interp");
9607 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9608 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9612 /* Set up .got offsets for local syms, and space for local dynamic
9614 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9616 struct got_entry **lgot_ents;
9617 struct got_entry **end_lgot_ents;
9618 struct plt_entry **local_plt;
9619 struct plt_entry **end_local_plt;
9620 unsigned char *lgot_masks;
9621 bfd_size_type locsymcount;
9622 Elf_Internal_Shdr *symtab_hdr;
9624 if (!is_ppc64_elf (ibfd))
9627 for (s = ibfd->sections; s != NULL; s = s->next)
9629 struct ppc_dyn_relocs *p;
9631 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9633 if (!bfd_is_abs_section (p->sec)
9634 && bfd_is_abs_section (p->sec->output_section))
9636 /* Input section has been discarded, either because
9637 it is a copy of a linkonce section or due to
9638 linker script /DISCARD/, so we'll be discarding
9641 else if (p->count != 0)
9643 asection *srel = elf_section_data (p->sec)->sreloc;
9645 srel = htab->elf.irelplt;
9646 srel->size += p->count * sizeof (Elf64_External_Rela);
9647 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9648 info->flags |= DF_TEXTREL;
9653 lgot_ents = elf_local_got_ents (ibfd);
9657 symtab_hdr = &elf_symtab_hdr (ibfd);
9658 locsymcount = symtab_hdr->sh_info;
9659 end_lgot_ents = lgot_ents + locsymcount;
9660 local_plt = (struct plt_entry **) end_lgot_ents;
9661 end_local_plt = local_plt + locsymcount;
9662 lgot_masks = (unsigned char *) end_local_plt;
9663 s = ppc64_elf_tdata (ibfd)->got;
9664 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9666 struct got_entry **pent, *ent;
9669 while ((ent = *pent) != NULL)
9670 if (ent->got.refcount > 0)
9672 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9674 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9679 unsigned int ent_size = 8;
9680 unsigned int rel_size = sizeof (Elf64_External_Rela);
9682 ent->got.offset = s->size;
9683 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9688 s->size += ent_size;
9689 if ((*lgot_masks & PLT_IFUNC) != 0)
9691 htab->elf.irelplt->size += rel_size;
9692 htab->got_reli_size += rel_size;
9694 else if (info->shared)
9696 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9697 srel->size += rel_size;
9706 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9707 for (; local_plt < end_local_plt; ++local_plt)
9709 struct plt_entry *ent;
9711 for (ent = *local_plt; ent != NULL; ent = ent->next)
9712 if (ent->plt.refcount > 0)
9715 ent->plt.offset = s->size;
9716 s->size += PLT_ENTRY_SIZE (htab);
9718 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9721 ent->plt.offset = (bfd_vma) -1;
9725 /* Allocate global sym .plt and .got entries, and space for global
9726 sym dynamic relocs. */
9727 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9728 /* Stash the end of glink branch table. */
9729 if (htab->glink != NULL)
9730 htab->glink->rawsize = htab->glink->size;
9732 if (!htab->opd_abi && !info->shared)
9733 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9736 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9738 struct got_entry *ent;
9740 if (!is_ppc64_elf (ibfd))
9743 ent = ppc64_tlsld_got (ibfd);
9744 if (ent->got.refcount > 0)
9746 if (!htab->do_multi_toc && first_tlsld != NULL)
9748 ent->is_indirect = TRUE;
9749 ent->got.ent = first_tlsld;
9753 if (first_tlsld == NULL)
9755 s = ppc64_elf_tdata (ibfd)->got;
9756 ent->got.offset = s->size;
9761 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9762 srel->size += sizeof (Elf64_External_Rela);
9767 ent->got.offset = (bfd_vma) -1;
9770 /* We now have determined the sizes of the various dynamic sections.
9771 Allocate memory for them. */
9773 for (s = dynobj->sections; s != NULL; s = s->next)
9775 if ((s->flags & SEC_LINKER_CREATED) == 0)
9778 if (s == htab->brlt || s == htab->relbrlt)
9779 /* These haven't been allocated yet; don't strip. */
9781 else if (s == htab->elf.sgot
9782 || s == htab->elf.splt
9783 || s == htab->elf.iplt
9785 || s == htab->dynbss)
9787 /* Strip this section if we don't need it; see the
9790 else if (s == htab->glink_eh_frame)
9792 if (!bfd_is_abs_section (s->output_section))
9793 /* Not sized yet. */
9796 else if (CONST_STRNEQ (s->name, ".rela"))
9800 if (s != htab->elf.srelplt)
9803 /* We use the reloc_count field as a counter if we need
9804 to copy relocs into the output file. */
9810 /* It's not one of our sections, so don't allocate space. */
9816 /* If we don't need this section, strip it from the
9817 output file. This is mostly to handle .rela.bss and
9818 .rela.plt. We must create both sections in
9819 create_dynamic_sections, because they must be created
9820 before the linker maps input sections to output
9821 sections. The linker does that before
9822 adjust_dynamic_symbol is called, and it is that
9823 function which decides whether anything needs to go
9824 into these sections. */
9825 s->flags |= SEC_EXCLUDE;
9829 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9832 /* Allocate memory for the section contents. We use bfd_zalloc
9833 here in case unused entries are not reclaimed before the
9834 section's contents are written out. This should not happen,
9835 but this way if it does we get a R_PPC64_NONE reloc in .rela
9836 sections instead of garbage.
9837 We also rely on the section contents being zero when writing
9839 s->contents = bfd_zalloc (dynobj, s->size);
9840 if (s->contents == NULL)
9844 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9846 if (!is_ppc64_elf (ibfd))
9849 s = ppc64_elf_tdata (ibfd)->got;
9850 if (s != NULL && s != htab->elf.sgot)
9853 s->flags |= SEC_EXCLUDE;
9856 s->contents = bfd_zalloc (ibfd, s->size);
9857 if (s->contents == NULL)
9861 s = ppc64_elf_tdata (ibfd)->relgot;
9865 s->flags |= SEC_EXCLUDE;
9868 s->contents = bfd_zalloc (ibfd, s->size);
9869 if (s->contents == NULL)
9877 if (htab->elf.dynamic_sections_created)
9879 bfd_boolean tls_opt;
9881 /* Add some entries to the .dynamic section. We fill in the
9882 values later, in ppc64_elf_finish_dynamic_sections, but we
9883 must add the entries now so that we get the correct size for
9884 the .dynamic section. The DT_DEBUG entry is filled in by the
9885 dynamic linker and used by the debugger. */
9886 #define add_dynamic_entry(TAG, VAL) \
9887 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9889 if (info->executable)
9891 if (!add_dynamic_entry (DT_DEBUG, 0))
9895 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9897 if (!add_dynamic_entry (DT_PLTGOT, 0)
9898 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9899 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9900 || !add_dynamic_entry (DT_JMPREL, 0)
9901 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9905 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9907 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9908 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9912 tls_opt = (!htab->params->no_tls_get_addr_opt
9913 && htab->tls_get_addr_fd != NULL
9914 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9915 if (tls_opt || !htab->opd_abi)
9917 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9923 if (!add_dynamic_entry (DT_RELA, 0)
9924 || !add_dynamic_entry (DT_RELASZ, 0)
9925 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9928 /* If any dynamic relocs apply to a read-only section,
9929 then we need a DT_TEXTREL entry. */
9930 if ((info->flags & DF_TEXTREL) == 0)
9931 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9933 if ((info->flags & DF_TEXTREL) != 0)
9935 if (!add_dynamic_entry (DT_TEXTREL, 0))
9940 #undef add_dynamic_entry
9945 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9948 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9950 if (h->plt.plist != NULL
9952 && !h->pointer_equality_needed)
9955 return _bfd_elf_hash_symbol (h);
9958 /* Determine the type of stub needed, if any, for a call. */
9960 static inline enum ppc_stub_type
9961 ppc_type_of_stub (asection *input_sec,
9962 const Elf_Internal_Rela *rel,
9963 struct ppc_link_hash_entry **hash,
9964 struct plt_entry **plt_ent,
9965 bfd_vma destination,
9966 unsigned long local_off)
9968 struct ppc_link_hash_entry *h = *hash;
9970 bfd_vma branch_offset;
9971 bfd_vma max_branch_offset;
9972 enum elf_ppc64_reloc_type r_type;
9976 struct plt_entry *ent;
9977 struct ppc_link_hash_entry *fdh = h;
9979 && h->oh->is_func_descriptor)
9981 fdh = ppc_follow_link (h->oh);
9985 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9986 if (ent->addend == rel->r_addend
9987 && ent->plt.offset != (bfd_vma) -1)
9990 return ppc_stub_plt_call;
9993 /* Here, we know we don't have a plt entry. If we don't have a
9994 either a defined function descriptor or a defined entry symbol
9995 in a regular object file, then it is pointless trying to make
9996 any other type of stub. */
9997 if (!is_static_defined (&fdh->elf)
9998 && !is_static_defined (&h->elf))
9999 return ppc_stub_none;
10001 else if (elf_local_got_ents (input_sec->owner) != NULL)
10003 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10004 struct plt_entry **local_plt = (struct plt_entry **)
10005 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10006 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10008 if (local_plt[r_symndx] != NULL)
10010 struct plt_entry *ent;
10012 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10013 if (ent->addend == rel->r_addend
10014 && ent->plt.offset != (bfd_vma) -1)
10017 return ppc_stub_plt_call;
10022 /* Determine where the call point is. */
10023 location = (input_sec->output_offset
10024 + input_sec->output_section->vma
10027 branch_offset = destination - location;
10028 r_type = ELF64_R_TYPE (rel->r_info);
10030 /* Determine if a long branch stub is needed. */
10031 max_branch_offset = 1 << 25;
10032 if (r_type != R_PPC64_REL24)
10033 max_branch_offset = 1 << 15;
10035 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10036 /* We need a stub. Figure out whether a long_branch or plt_branch
10037 is needed later. */
10038 return ppc_stub_long_branch;
10040 return ppc_stub_none;
10043 /* With power7 weakly ordered memory model, it is possible for ld.so
10044 to update a plt entry in one thread and have another thread see a
10045 stale zero toc entry. To avoid this we need some sort of acquire
10046 barrier in the call stub. One solution is to make the load of the
10047 toc word seem to appear to depend on the load of the function entry
10048 word. Another solution is to test for r2 being zero, and branch to
10049 the appropriate glink entry if so.
10051 . fake dep barrier compare
10052 . ld 12,xxx(2) ld 12,xxx(2)
10053 . mtctr 12 mtctr 12
10054 . xor 11,12,12 ld 2,xxx+8(2)
10055 . add 2,2,11 cmpldi 2,0
10056 . ld 2,xxx+8(2) bnectr+
10057 . bctr b <glink_entry>
10059 The solution involving the compare turns out to be faster, so
10060 that's what we use unless the branch won't reach. */
10062 #define ALWAYS_USE_FAKE_DEP 0
10063 #define ALWAYS_EMIT_R2SAVE 0
10065 #define PPC_LO(v) ((v) & 0xffff)
10066 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10067 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10069 static inline unsigned int
10070 plt_stub_size (struct ppc_link_hash_table *htab,
10071 struct ppc_stub_hash_entry *stub_entry,
10074 unsigned size = 12;
10076 if (ALWAYS_EMIT_R2SAVE
10077 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10079 if (PPC_HA (off) != 0)
10084 if (htab->params->plt_static_chain)
10086 if (htab->params->plt_thread_safe)
10088 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10091 if (stub_entry->h != NULL
10092 && (stub_entry->h == htab->tls_get_addr_fd
10093 || stub_entry->h == htab->tls_get_addr)
10094 && !htab->params->no_tls_get_addr_opt)
10099 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10100 then return the padding needed to do so. */
10101 static inline unsigned int
10102 plt_stub_pad (struct ppc_link_hash_table *htab,
10103 struct ppc_stub_hash_entry *stub_entry,
10106 int stub_align = 1 << htab->params->plt_stub_align;
10107 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10108 bfd_vma stub_off = stub_entry->stub_sec->size;
10110 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10111 > (stub_size & -stub_align))
10112 return stub_align - (stub_off & (stub_align - 1));
10116 /* Build a .plt call stub. */
10118 static inline bfd_byte *
10119 build_plt_stub (struct ppc_link_hash_table *htab,
10120 struct ppc_stub_hash_entry *stub_entry,
10121 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10123 bfd *obfd = htab->params->stub_bfd;
10124 bfd_boolean plt_load_toc = htab->opd_abi;
10125 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10126 bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10127 bfd_boolean use_fake_dep = plt_thread_safe;
10128 bfd_vma cmp_branch_off = 0;
10130 if (!ALWAYS_USE_FAKE_DEP
10133 && !(stub_entry->h != NULL
10134 && (stub_entry->h == htab->tls_get_addr_fd
10135 || stub_entry->h == htab->tls_get_addr)
10136 && !htab->params->no_tls_get_addr_opt))
10138 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10139 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10140 / PLT_ENTRY_SIZE (htab));
10141 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10144 if (pltindex > 32768)
10145 glinkoff += (pltindex - 32768) * 4;
10147 + htab->glink->output_offset
10148 + htab->glink->output_section->vma);
10149 from = (p - stub_entry->stub_sec->contents
10150 + 4 * (ALWAYS_EMIT_R2SAVE
10151 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10152 + 4 * (PPC_HA (offset) != 0)
10153 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10154 != PPC_HA (offset))
10155 + 4 * (plt_static_chain != 0)
10157 + stub_entry->stub_sec->output_offset
10158 + stub_entry->stub_sec->output_section->vma);
10159 cmp_branch_off = to - from;
10160 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10163 if (PPC_HA (offset) != 0)
10167 if (ALWAYS_EMIT_R2SAVE
10168 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10169 r[0].r_offset += 4;
10170 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10171 r[1].r_offset = r[0].r_offset + 4;
10172 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10173 r[1].r_addend = r[0].r_addend;
10176 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10178 r[2].r_offset = r[1].r_offset + 4;
10179 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10180 r[2].r_addend = r[0].r_addend;
10184 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10185 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10186 r[2].r_addend = r[0].r_addend + 8;
10187 if (plt_static_chain)
10189 r[3].r_offset = r[2].r_offset + 4;
10190 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10191 r[3].r_addend = r[0].r_addend + 16;
10196 if (ALWAYS_EMIT_R2SAVE
10197 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10198 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10199 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10200 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10202 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10204 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10207 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10212 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10213 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10215 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10216 if (plt_static_chain)
10217 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10224 if (ALWAYS_EMIT_R2SAVE
10225 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10226 r[0].r_offset += 4;
10227 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10230 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10232 r[1].r_offset = r[0].r_offset + 4;
10233 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10234 r[1].r_addend = r[0].r_addend;
10238 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10239 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10240 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10241 if (plt_static_chain)
10243 r[2].r_offset = r[1].r_offset + 4;
10244 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10245 r[2].r_addend = r[0].r_addend + 8;
10250 if (ALWAYS_EMIT_R2SAVE
10251 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10252 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10253 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10255 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10257 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10260 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10265 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10266 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10268 if (plt_static_chain)
10269 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10270 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10273 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10275 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10276 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10277 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10280 bfd_put_32 (obfd, BCTR, p), p += 4;
10284 /* Build a special .plt call stub for __tls_get_addr. */
10286 #define LD_R11_0R3 0xe9630000
10287 #define LD_R12_0R3 0xe9830000
10288 #define MR_R0_R3 0x7c601b78
10289 #define CMPDI_R11_0 0x2c2b0000
10290 #define ADD_R3_R12_R13 0x7c6c6a14
10291 #define BEQLR 0x4d820020
10292 #define MR_R3_R0 0x7c030378
10293 #define STD_R11_0R1 0xf9610000
10294 #define BCTRL 0x4e800421
10295 #define LD_R11_0R1 0xe9610000
10296 #define MTLR_R11 0x7d6803a6
10298 static inline bfd_byte *
10299 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10300 struct ppc_stub_hash_entry *stub_entry,
10301 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10303 bfd *obfd = htab->params->stub_bfd;
10305 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10306 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10307 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10308 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10309 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10310 bfd_put_32 (obfd, BEQLR, p), p += 4;
10311 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10312 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10313 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10316 r[0].r_offset += 9 * 4;
10317 p = build_plt_stub (htab, stub_entry, p, offset, r);
10318 bfd_put_32 (obfd, BCTRL, p - 4);
10320 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10321 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10322 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10323 bfd_put_32 (obfd, BLR, p), p += 4;
10328 static Elf_Internal_Rela *
10329 get_relocs (asection *sec, int count)
10331 Elf_Internal_Rela *relocs;
10332 struct bfd_elf_section_data *elfsec_data;
10334 elfsec_data = elf_section_data (sec);
10335 relocs = elfsec_data->relocs;
10336 if (relocs == NULL)
10338 bfd_size_type relsize;
10339 relsize = sec->reloc_count * sizeof (*relocs);
10340 relocs = bfd_alloc (sec->owner, relsize);
10341 if (relocs == NULL)
10343 elfsec_data->relocs = relocs;
10344 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10345 sizeof (Elf_Internal_Shdr));
10346 if (elfsec_data->rela.hdr == NULL)
10348 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10349 * sizeof (Elf64_External_Rela));
10350 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10351 sec->reloc_count = 0;
10353 relocs += sec->reloc_count;
10354 sec->reloc_count += count;
10359 get_r2off (struct bfd_link_info *info,
10360 struct ppc_stub_hash_entry *stub_entry)
10362 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10363 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10367 /* Support linking -R objects. Get the toc pointer from the
10370 if (!htab->opd_abi)
10372 asection *opd = stub_entry->h->elf.root.u.def.section;
10373 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10375 if (strcmp (opd->name, ".opd") != 0
10376 || opd->reloc_count != 0)
10378 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10379 stub_entry->h->elf.root.root.string);
10380 bfd_set_error (bfd_error_bad_value);
10383 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10385 r2off = bfd_get_64 (opd->owner, buf);
10386 r2off -= elf_gp (info->output_bfd);
10388 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10393 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10395 struct ppc_stub_hash_entry *stub_entry;
10396 struct ppc_branch_hash_entry *br_entry;
10397 struct bfd_link_info *info;
10398 struct ppc_link_hash_table *htab;
10403 Elf_Internal_Rela *r;
10406 /* Massage our args to the form they really have. */
10407 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10410 htab = ppc_hash_table (info);
10414 /* Make a note of the offset within the stubs for this entry. */
10415 stub_entry->stub_offset = stub_entry->stub_sec->size;
10416 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10418 htab->stub_count[stub_entry->stub_type - 1] += 1;
10419 switch (stub_entry->stub_type)
10421 case ppc_stub_long_branch:
10422 case ppc_stub_long_branch_r2off:
10423 /* Branches are relative. This is where we are going to. */
10424 dest = (stub_entry->target_value
10425 + stub_entry->target_section->output_offset
10426 + stub_entry->target_section->output_section->vma);
10427 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10430 /* And this is where we are coming from. */
10431 off -= (stub_entry->stub_offset
10432 + stub_entry->stub_sec->output_offset
10433 + stub_entry->stub_sec->output_section->vma);
10436 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10438 bfd_vma r2off = get_r2off (info, stub_entry);
10442 htab->stub_error = TRUE;
10445 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10448 if (PPC_HA (r2off) != 0)
10451 bfd_put_32 (htab->params->stub_bfd,
10452 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10455 bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10459 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10461 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10463 info->callbacks->einfo
10464 (_("%P: long branch stub `%s' offset overflow\n"),
10465 stub_entry->root.string);
10466 htab->stub_error = TRUE;
10470 if (info->emitrelocations)
10472 r = get_relocs (stub_entry->stub_sec, 1);
10475 r->r_offset = loc - stub_entry->stub_sec->contents;
10476 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10477 r->r_addend = dest;
10478 if (stub_entry->h != NULL)
10480 struct elf_link_hash_entry **hashes;
10481 unsigned long symndx;
10482 struct ppc_link_hash_entry *h;
10484 hashes = elf_sym_hashes (htab->params->stub_bfd);
10485 if (hashes == NULL)
10487 bfd_size_type hsize;
10489 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10490 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10491 if (hashes == NULL)
10493 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10494 htab->stub_globals = 1;
10496 symndx = htab->stub_globals++;
10498 hashes[symndx] = &h->elf;
10499 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10500 if (h->oh != NULL && h->oh->is_func)
10501 h = ppc_follow_link (h->oh);
10502 if (h->elf.root.u.def.section != stub_entry->target_section)
10503 /* H is an opd symbol. The addend must be zero. */
10507 off = (h->elf.root.u.def.value
10508 + h->elf.root.u.def.section->output_offset
10509 + h->elf.root.u.def.section->output_section->vma);
10510 r->r_addend -= off;
10516 case ppc_stub_plt_branch:
10517 case ppc_stub_plt_branch_r2off:
10518 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10519 stub_entry->root.string + 9,
10521 if (br_entry == NULL)
10523 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10524 stub_entry->root.string);
10525 htab->stub_error = TRUE;
10529 dest = (stub_entry->target_value
10530 + stub_entry->target_section->output_offset
10531 + stub_entry->target_section->output_section->vma);
10532 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10533 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10535 bfd_put_64 (htab->brlt->owner, dest,
10536 htab->brlt->contents + br_entry->offset);
10538 if (br_entry->iter == htab->stub_iteration)
10540 br_entry->iter = 0;
10542 if (htab->relbrlt != NULL)
10544 /* Create a reloc for the branch lookup table entry. */
10545 Elf_Internal_Rela rela;
10548 rela.r_offset = (br_entry->offset
10549 + htab->brlt->output_offset
10550 + htab->brlt->output_section->vma);
10551 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10552 rela.r_addend = dest;
10554 rl = htab->relbrlt->contents;
10555 rl += (htab->relbrlt->reloc_count++
10556 * sizeof (Elf64_External_Rela));
10557 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10559 else if (info->emitrelocations)
10561 r = get_relocs (htab->brlt, 1);
10564 /* brlt, being SEC_LINKER_CREATED does not go through the
10565 normal reloc processing. Symbols and offsets are not
10566 translated from input file to output file form, so
10567 set up the offset per the output file. */
10568 r->r_offset = (br_entry->offset
10569 + htab->brlt->output_offset
10570 + htab->brlt->output_section->vma);
10571 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10572 r->r_addend = dest;
10576 dest = (br_entry->offset
10577 + htab->brlt->output_offset
10578 + htab->brlt->output_section->vma);
10581 - elf_gp (htab->brlt->output_section->owner)
10582 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10584 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10586 info->callbacks->einfo
10587 (_("%P: linkage table error against `%T'\n"),
10588 stub_entry->root.string);
10589 bfd_set_error (bfd_error_bad_value);
10590 htab->stub_error = TRUE;
10594 if (info->emitrelocations)
10596 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10599 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10600 if (bfd_big_endian (info->output_bfd))
10601 r[0].r_offset += 2;
10602 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10603 r[0].r_offset += 4;
10604 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10605 r[0].r_addend = dest;
10606 if (PPC_HA (off) != 0)
10608 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10609 r[1].r_offset = r[0].r_offset + 4;
10610 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10611 r[1].r_addend = r[0].r_addend;
10615 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10617 if (PPC_HA (off) != 0)
10620 bfd_put_32 (htab->params->stub_bfd,
10621 ADDIS_R11_R2 | PPC_HA (off), loc);
10623 bfd_put_32 (htab->params->stub_bfd,
10624 LD_R12_0R11 | PPC_LO (off), loc);
10629 bfd_put_32 (htab->params->stub_bfd,
10630 LD_R12_0R2 | PPC_LO (off), loc);
10635 bfd_vma r2off = get_r2off (info, stub_entry);
10637 if (r2off == 0 && htab->opd_abi)
10639 htab->stub_error = TRUE;
10643 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10646 if (PPC_HA (off) != 0)
10649 bfd_put_32 (htab->params->stub_bfd,
10650 ADDIS_R11_R2 | PPC_HA (off), loc);
10652 bfd_put_32 (htab->params->stub_bfd,
10653 LD_R12_0R11 | PPC_LO (off), loc);
10656 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10658 if (PPC_HA (r2off) != 0)
10662 bfd_put_32 (htab->params->stub_bfd,
10663 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10665 if (PPC_LO (r2off) != 0)
10669 bfd_put_32 (htab->params->stub_bfd,
10670 ADDI_R2_R2 | PPC_LO (r2off), loc);
10674 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10676 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10679 case ppc_stub_plt_call:
10680 case ppc_stub_plt_call_r2save:
10681 if (stub_entry->h != NULL
10682 && stub_entry->h->is_func_descriptor
10683 && stub_entry->h->oh != NULL)
10685 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10687 /* If the old-ABI "dot-symbol" is undefined make it weak so
10688 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10689 FIXME: We used to define the symbol on one of the call
10690 stubs instead, which is why we test symbol section id
10691 against htab->top_id in various places. Likely all
10692 these checks could now disappear. */
10693 if (fh->elf.root.type == bfd_link_hash_undefined)
10694 fh->elf.root.type = bfd_link_hash_undefweak;
10695 /* Stop undo_symbol_twiddle changing it back to undefined. */
10696 fh->was_undefined = 0;
10699 /* Now build the stub. */
10700 dest = stub_entry->plt_ent->plt.offset & ~1;
10701 if (dest >= (bfd_vma) -2)
10704 plt = htab->elf.splt;
10705 if (!htab->elf.dynamic_sections_created
10706 || stub_entry->h == NULL
10707 || stub_entry->h->elf.dynindx == -1)
10708 plt = htab->elf.iplt;
10710 dest += plt->output_offset + plt->output_section->vma;
10712 if (stub_entry->h == NULL
10713 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10715 Elf_Internal_Rela rela;
10718 rela.r_offset = dest;
10720 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10722 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10723 rela.r_addend = (stub_entry->target_value
10724 + stub_entry->target_section->output_offset
10725 + stub_entry->target_section->output_section->vma);
10727 rl = (htab->elf.irelplt->contents
10728 + (htab->elf.irelplt->reloc_count++
10729 * sizeof (Elf64_External_Rela)));
10730 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10731 stub_entry->plt_ent->plt.offset |= 1;
10735 - elf_gp (plt->output_section->owner)
10736 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10738 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10740 info->callbacks->einfo
10741 (_("%P: linkage table error against `%T'\n"),
10742 stub_entry->h != NULL
10743 ? stub_entry->h->elf.root.root.string
10745 bfd_set_error (bfd_error_bad_value);
10746 htab->stub_error = TRUE;
10750 if (htab->params->plt_stub_align != 0)
10752 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10754 stub_entry->stub_sec->size += pad;
10755 stub_entry->stub_offset = stub_entry->stub_sec->size;
10760 if (info->emitrelocations)
10762 r = get_relocs (stub_entry->stub_sec,
10763 ((PPC_HA (off) != 0)
10765 ? 2 + (htab->params->plt_static_chain
10766 && PPC_HA (off + 16) == PPC_HA (off))
10770 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10771 if (bfd_big_endian (info->output_bfd))
10772 r[0].r_offset += 2;
10773 r[0].r_addend = dest;
10775 if (stub_entry->h != NULL
10776 && (stub_entry->h == htab->tls_get_addr_fd
10777 || stub_entry->h == htab->tls_get_addr)
10778 && !htab->params->no_tls_get_addr_opt)
10779 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10781 p = build_plt_stub (htab, stub_entry, loc, off, r);
10790 stub_entry->stub_sec->size += size;
10792 if (htab->params->emit_stub_syms)
10794 struct elf_link_hash_entry *h;
10797 const char *const stub_str[] = { "long_branch",
10798 "long_branch_r2off",
10800 "plt_branch_r2off",
10804 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10805 len2 = strlen (stub_entry->root.string);
10806 name = bfd_malloc (len1 + len2 + 2);
10809 memcpy (name, stub_entry->root.string, 9);
10810 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10811 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10812 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10815 if (h->root.type == bfd_link_hash_new)
10817 h->root.type = bfd_link_hash_defined;
10818 h->root.u.def.section = stub_entry->stub_sec;
10819 h->root.u.def.value = stub_entry->stub_offset;
10820 h->ref_regular = 1;
10821 h->def_regular = 1;
10822 h->ref_regular_nonweak = 1;
10823 h->forced_local = 1;
10831 /* As above, but don't actually build the stub. Just bump offset so
10832 we know stub section sizes, and select plt_branch stubs where
10833 long_branch stubs won't do. */
10836 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10838 struct ppc_stub_hash_entry *stub_entry;
10839 struct bfd_link_info *info;
10840 struct ppc_link_hash_table *htab;
10844 /* Massage our args to the form they really have. */
10845 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10848 htab = ppc_hash_table (info);
10852 if (stub_entry->stub_type == ppc_stub_plt_call
10853 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10856 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10857 if (off >= (bfd_vma) -2)
10859 plt = htab->elf.splt;
10860 if (!htab->elf.dynamic_sections_created
10861 || stub_entry->h == NULL
10862 || stub_entry->h->elf.dynindx == -1)
10863 plt = htab->elf.iplt;
10864 off += (plt->output_offset
10865 + plt->output_section->vma
10866 - elf_gp (plt->output_section->owner)
10867 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10869 size = plt_stub_size (htab, stub_entry, off);
10870 if (htab->params->plt_stub_align)
10871 size += plt_stub_pad (htab, stub_entry, off);
10872 if (info->emitrelocations)
10874 stub_entry->stub_sec->reloc_count
10875 += ((PPC_HA (off) != 0)
10877 ? 2 + (htab->params->plt_static_chain
10878 && PPC_HA (off + 16) == PPC_HA (off))
10880 stub_entry->stub_sec->flags |= SEC_RELOC;
10885 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10888 bfd_vma local_off = 0;
10890 off = (stub_entry->target_value
10891 + stub_entry->target_section->output_offset
10892 + stub_entry->target_section->output_section->vma);
10893 off -= (stub_entry->stub_sec->size
10894 + stub_entry->stub_sec->output_offset
10895 + stub_entry->stub_sec->output_section->vma);
10897 /* Reset the stub type from the plt variant in case we now
10898 can reach with a shorter stub. */
10899 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10900 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10903 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10905 r2off = get_r2off (info, stub_entry);
10906 if (r2off == 0 && htab->opd_abi)
10908 htab->stub_error = TRUE;
10912 if (PPC_HA (r2off) != 0)
10917 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10919 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10920 Do the same for -R objects without function descriptors. */
10921 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10922 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10925 struct ppc_branch_hash_entry *br_entry;
10927 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10928 stub_entry->root.string + 9,
10930 if (br_entry == NULL)
10932 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10933 stub_entry->root.string);
10934 htab->stub_error = TRUE;
10938 if (br_entry->iter != htab->stub_iteration)
10940 br_entry->iter = htab->stub_iteration;
10941 br_entry->offset = htab->brlt->size;
10942 htab->brlt->size += 8;
10944 if (htab->relbrlt != NULL)
10945 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10946 else if (info->emitrelocations)
10948 htab->brlt->reloc_count += 1;
10949 htab->brlt->flags |= SEC_RELOC;
10953 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10954 off = (br_entry->offset
10955 + htab->brlt->output_offset
10956 + htab->brlt->output_section->vma
10957 - elf_gp (htab->brlt->output_section->owner)
10958 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10960 if (info->emitrelocations)
10962 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10963 stub_entry->stub_sec->flags |= SEC_RELOC;
10966 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10969 if (PPC_HA (off) != 0)
10975 if (PPC_HA (off) != 0)
10978 if (PPC_HA (r2off) != 0)
10980 if (PPC_LO (r2off) != 0)
10984 else if (info->emitrelocations)
10986 stub_entry->stub_sec->reloc_count += 1;
10987 stub_entry->stub_sec->flags |= SEC_RELOC;
10991 stub_entry->stub_sec->size += size;
10995 /* Set up various things so that we can make a list of input sections
10996 for each output section included in the link. Returns -1 on error,
10997 0 when no stubs will be needed, and 1 on success. */
11000 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11003 int top_id, top_index, id;
11005 asection **input_list;
11007 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11012 /* Find the top input section id. */
11013 for (input_bfd = info->input_bfds, top_id = 3;
11015 input_bfd = input_bfd->link_next)
11017 for (section = input_bfd->sections;
11019 section = section->next)
11021 if (top_id < section->id)
11022 top_id = section->id;
11026 htab->top_id = top_id;
11027 amt = sizeof (struct map_stub) * (top_id + 1);
11028 htab->stub_group = bfd_zmalloc (amt);
11029 if (htab->stub_group == NULL)
11032 /* Set toc_off for com, und, abs and ind sections. */
11033 for (id = 0; id < 3; id++)
11034 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11036 /* We can't use output_bfd->section_count here to find the top output
11037 section index as some sections may have been removed, and
11038 strip_excluded_output_sections doesn't renumber the indices. */
11039 for (section = info->output_bfd->sections, top_index = 0;
11041 section = section->next)
11043 if (top_index < section->index)
11044 top_index = section->index;
11047 htab->top_index = top_index;
11048 amt = sizeof (asection *) * (top_index + 1);
11049 input_list = bfd_zmalloc (amt);
11050 htab->input_list = input_list;
11051 if (input_list == NULL)
11057 /* Set up for first pass at multitoc partitioning. */
11060 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11062 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11064 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11065 htab->toc_bfd = NULL;
11066 htab->toc_first_sec = NULL;
11069 /* The linker repeatedly calls this function for each TOC input section
11070 and linker generated GOT section. Group input bfds such that the toc
11071 within a group is less than 64k in size. */
11074 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11076 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11077 bfd_vma addr, off, limit;
11082 if (!htab->second_toc_pass)
11084 /* Keep track of the first .toc or .got section for this input bfd. */
11085 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11089 htab->toc_bfd = isec->owner;
11090 htab->toc_first_sec = isec;
11093 addr = isec->output_offset + isec->output_section->vma;
11094 off = addr - htab->toc_curr;
11095 limit = 0x80008000;
11096 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11098 if (off + isec->size > limit)
11100 addr = (htab->toc_first_sec->output_offset
11101 + htab->toc_first_sec->output_section->vma);
11102 htab->toc_curr = addr;
11105 /* toc_curr is the base address of this toc group. Set elf_gp
11106 for the input section to be the offset relative to the
11107 output toc base plus 0x8000. Making the input elf_gp an
11108 offset allows us to move the toc as a whole without
11109 recalculating input elf_gp. */
11110 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11111 off += TOC_BASE_OFF;
11113 /* Die if someone uses a linker script that doesn't keep input
11114 file .toc and .got together. */
11116 && elf_gp (isec->owner) != 0
11117 && elf_gp (isec->owner) != off)
11120 elf_gp (isec->owner) = off;
11124 /* During the second pass toc_first_sec points to the start of
11125 a toc group, and toc_curr is used to track the old elf_gp.
11126 We use toc_bfd to ensure we only look at each bfd once. */
11127 if (htab->toc_bfd == isec->owner)
11129 htab->toc_bfd = isec->owner;
11131 if (htab->toc_first_sec == NULL
11132 || htab->toc_curr != elf_gp (isec->owner))
11134 htab->toc_curr = elf_gp (isec->owner);
11135 htab->toc_first_sec = isec;
11137 addr = (htab->toc_first_sec->output_offset
11138 + htab->toc_first_sec->output_section->vma);
11139 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11140 elf_gp (isec->owner) = off;
11145 /* Called via elf_link_hash_traverse to merge GOT entries for global
11149 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11151 if (h->root.type == bfd_link_hash_indirect)
11154 merge_got_entries (&h->got.glist);
11159 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11163 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11165 struct got_entry *gent;
11167 if (h->root.type == bfd_link_hash_indirect)
11170 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11171 if (!gent->is_indirect)
11172 allocate_got (h, (struct bfd_link_info *) inf, gent);
11176 /* Called on the first multitoc pass after the last call to
11177 ppc64_elf_next_toc_section. This function removes duplicate GOT
11181 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11183 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11184 struct bfd *ibfd, *ibfd2;
11185 bfd_boolean done_something;
11187 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11189 if (!htab->do_multi_toc)
11192 /* Merge global sym got entries within a toc group. */
11193 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11195 /* And tlsld_got. */
11196 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11198 struct got_entry *ent, *ent2;
11200 if (!is_ppc64_elf (ibfd))
11203 ent = ppc64_tlsld_got (ibfd);
11204 if (!ent->is_indirect
11205 && ent->got.offset != (bfd_vma) -1)
11207 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11209 if (!is_ppc64_elf (ibfd2))
11212 ent2 = ppc64_tlsld_got (ibfd2);
11213 if (!ent2->is_indirect
11214 && ent2->got.offset != (bfd_vma) -1
11215 && elf_gp (ibfd2) == elf_gp (ibfd))
11217 ent2->is_indirect = TRUE;
11218 ent2->got.ent = ent;
11224 /* Zap sizes of got sections. */
11225 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11226 htab->elf.irelplt->size -= htab->got_reli_size;
11227 htab->got_reli_size = 0;
11229 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11231 asection *got, *relgot;
11233 if (!is_ppc64_elf (ibfd))
11236 got = ppc64_elf_tdata (ibfd)->got;
11239 got->rawsize = got->size;
11241 relgot = ppc64_elf_tdata (ibfd)->relgot;
11242 relgot->rawsize = relgot->size;
11247 /* Now reallocate the got, local syms first. We don't need to
11248 allocate section contents again since we never increase size. */
11249 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11251 struct got_entry **lgot_ents;
11252 struct got_entry **end_lgot_ents;
11253 struct plt_entry **local_plt;
11254 struct plt_entry **end_local_plt;
11255 unsigned char *lgot_masks;
11256 bfd_size_type locsymcount;
11257 Elf_Internal_Shdr *symtab_hdr;
11260 if (!is_ppc64_elf (ibfd))
11263 lgot_ents = elf_local_got_ents (ibfd);
11267 symtab_hdr = &elf_symtab_hdr (ibfd);
11268 locsymcount = symtab_hdr->sh_info;
11269 end_lgot_ents = lgot_ents + locsymcount;
11270 local_plt = (struct plt_entry **) end_lgot_ents;
11271 end_local_plt = local_plt + locsymcount;
11272 lgot_masks = (unsigned char *) end_local_plt;
11273 s = ppc64_elf_tdata (ibfd)->got;
11274 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11276 struct got_entry *ent;
11278 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11280 unsigned int ent_size = 8;
11281 unsigned int rel_size = sizeof (Elf64_External_Rela);
11283 ent->got.offset = s->size;
11284 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11289 s->size += ent_size;
11290 if ((*lgot_masks & PLT_IFUNC) != 0)
11292 htab->elf.irelplt->size += rel_size;
11293 htab->got_reli_size += rel_size;
11295 else if (info->shared)
11297 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11298 srel->size += rel_size;
11304 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11306 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11308 struct got_entry *ent;
11310 if (!is_ppc64_elf (ibfd))
11313 ent = ppc64_tlsld_got (ibfd);
11314 if (!ent->is_indirect
11315 && ent->got.offset != (bfd_vma) -1)
11317 asection *s = ppc64_elf_tdata (ibfd)->got;
11318 ent->got.offset = s->size;
11322 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11323 srel->size += sizeof (Elf64_External_Rela);
11328 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11329 if (!done_something)
11330 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11334 if (!is_ppc64_elf (ibfd))
11337 got = ppc64_elf_tdata (ibfd)->got;
11340 done_something = got->rawsize != got->size;
11341 if (done_something)
11346 if (done_something)
11347 (*htab->params->layout_sections_again) ();
11349 /* Set up for second pass over toc sections to recalculate elf_gp
11350 on input sections. */
11351 htab->toc_bfd = NULL;
11352 htab->toc_first_sec = NULL;
11353 htab->second_toc_pass = TRUE;
11354 return done_something;
11357 /* Called after second pass of multitoc partitioning. */
11360 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11362 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11364 /* After the second pass, toc_curr tracks the TOC offset used
11365 for code sections below in ppc64_elf_next_input_section. */
11366 htab->toc_curr = TOC_BASE_OFF;
11369 /* No toc references were found in ISEC. If the code in ISEC makes no
11370 calls, then there's no need to use toc adjusting stubs when branching
11371 into ISEC. Actually, indirect calls from ISEC are OK as they will
11372 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11373 needed, and 2 if a cyclical call-graph was found but no other reason
11374 for a stub was detected. If called from the top level, a return of
11375 2 means the same as a return of 0. */
11378 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11382 /* Mark this section as checked. */
11383 isec->call_check_done = 1;
11385 /* We know none of our code bearing sections will need toc stubs. */
11386 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11389 if (isec->size == 0)
11392 if (isec->output_section == NULL)
11396 if (isec->reloc_count != 0)
11398 Elf_Internal_Rela *relstart, *rel;
11399 Elf_Internal_Sym *local_syms;
11400 struct ppc_link_hash_table *htab;
11402 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11403 info->keep_memory);
11404 if (relstart == NULL)
11407 /* Look for branches to outside of this section. */
11409 htab = ppc_hash_table (info);
11413 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11415 enum elf_ppc64_reloc_type r_type;
11416 unsigned long r_symndx;
11417 struct elf_link_hash_entry *h;
11418 struct ppc_link_hash_entry *eh;
11419 Elf_Internal_Sym *sym;
11421 struct _opd_sec_data *opd;
11425 r_type = ELF64_R_TYPE (rel->r_info);
11426 if (r_type != R_PPC64_REL24
11427 && r_type != R_PPC64_REL14
11428 && r_type != R_PPC64_REL14_BRTAKEN
11429 && r_type != R_PPC64_REL14_BRNTAKEN)
11432 r_symndx = ELF64_R_SYM (rel->r_info);
11433 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11440 /* Calls to dynamic lib functions go through a plt call stub
11442 eh = (struct ppc_link_hash_entry *) h;
11444 && (eh->elf.plt.plist != NULL
11446 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11452 if (sym_sec == NULL)
11453 /* Ignore other undefined symbols. */
11456 /* Assume branches to other sections not included in the
11457 link need stubs too, to cover -R and absolute syms. */
11458 if (sym_sec->output_section == NULL)
11465 sym_value = sym->st_value;
11468 if (h->root.type != bfd_link_hash_defined
11469 && h->root.type != bfd_link_hash_defweak)
11471 sym_value = h->root.u.def.value;
11473 sym_value += rel->r_addend;
11475 /* If this branch reloc uses an opd sym, find the code section. */
11476 opd = get_opd_info (sym_sec);
11479 if (h == NULL && opd->adjust != NULL)
11483 adjust = opd->adjust[sym->st_value / 8];
11485 /* Assume deleted functions won't ever be called. */
11487 sym_value += adjust;
11490 dest = opd_entry_value (sym_sec, sym_value,
11491 &sym_sec, NULL, FALSE);
11492 if (dest == (bfd_vma) -1)
11497 + sym_sec->output_offset
11498 + sym_sec->output_section->vma);
11500 /* Ignore branch to self. */
11501 if (sym_sec == isec)
11504 /* If the called function uses the toc, we need a stub. */
11505 if (sym_sec->has_toc_reloc
11506 || sym_sec->makes_toc_func_call)
11512 /* Assume any branch that needs a long branch stub might in fact
11513 need a plt_branch stub. A plt_branch stub uses r2. */
11514 else if (dest - (isec->output_offset
11515 + isec->output_section->vma
11516 + rel->r_offset) + (1 << 25)
11517 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11525 /* If calling back to a section in the process of being
11526 tested, we can't say for sure that no toc adjusting stubs
11527 are needed, so don't return zero. */
11528 else if (sym_sec->call_check_in_progress)
11531 /* Branches to another section that itself doesn't have any TOC
11532 references are OK. Recursively call ourselves to check. */
11533 else if (!sym_sec->call_check_done)
11537 /* Mark current section as indeterminate, so that other
11538 sections that call back to current won't be marked as
11540 isec->call_check_in_progress = 1;
11541 recur = toc_adjusting_stub_needed (info, sym_sec);
11542 isec->call_check_in_progress = 0;
11553 if (local_syms != NULL
11554 && (elf_symtab_hdr (isec->owner).contents
11555 != (unsigned char *) local_syms))
11557 if (elf_section_data (isec)->relocs != relstart)
11562 && isec->map_head.s != NULL
11563 && (strcmp (isec->output_section->name, ".init") == 0
11564 || strcmp (isec->output_section->name, ".fini") == 0))
11566 if (isec->map_head.s->has_toc_reloc
11567 || isec->map_head.s->makes_toc_func_call)
11569 else if (!isec->map_head.s->call_check_done)
11572 isec->call_check_in_progress = 1;
11573 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11574 isec->call_check_in_progress = 0;
11581 isec->makes_toc_func_call = 1;
11586 /* The linker repeatedly calls this function for each input section,
11587 in the order that input sections are linked into output sections.
11588 Build lists of input sections to determine groupings between which
11589 we may insert linker stubs. */
11592 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11594 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11599 if ((isec->output_section->flags & SEC_CODE) != 0
11600 && isec->output_section->index <= htab->top_index)
11602 asection **list = htab->input_list + isec->output_section->index;
11603 /* Steal the link_sec pointer for our list. */
11604 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11605 /* This happens to make the list in reverse order,
11606 which is what we want. */
11607 PREV_SEC (isec) = *list;
11611 if (htab->multi_toc_needed)
11613 /* Analyse sections that aren't already flagged as needing a
11614 valid toc pointer. Exclude .fixup for the linux kernel.
11615 .fixup contains branches, but only back to the function that
11616 hit an exception. */
11617 if (!(isec->has_toc_reloc
11618 || (isec->flags & SEC_CODE) == 0
11619 || strcmp (isec->name, ".fixup") == 0
11620 || isec->call_check_done))
11622 if (toc_adjusting_stub_needed (info, isec) < 0)
11625 /* Make all sections use the TOC assigned for this object file.
11626 This will be wrong for pasted sections; We fix that in
11627 check_pasted_section(). */
11628 if (elf_gp (isec->owner) != 0)
11629 htab->toc_curr = elf_gp (isec->owner);
11632 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11636 /* Check that all .init and .fini sections use the same toc, if they
11637 have toc relocs. */
11640 check_pasted_section (struct bfd_link_info *info, const char *name)
11642 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11646 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11647 bfd_vma toc_off = 0;
11650 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11651 if (i->has_toc_reloc)
11654 toc_off = htab->stub_group[i->id].toc_off;
11655 else if (toc_off != htab->stub_group[i->id].toc_off)
11660 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11661 if (i->makes_toc_func_call)
11663 toc_off = htab->stub_group[i->id].toc_off;
11667 /* Make sure the whole pasted function uses the same toc offset. */
11669 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11670 htab->stub_group[i->id].toc_off = toc_off;
11676 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11678 return (check_pasted_section (info, ".init")
11679 & check_pasted_section (info, ".fini"));
11682 /* See whether we can group stub sections together. Grouping stub
11683 sections may result in fewer stubs. More importantly, we need to
11684 put all .init* and .fini* stubs at the beginning of the .init or
11685 .fini output sections respectively, because glibc splits the
11686 _init and _fini functions into multiple parts. Putting a stub in
11687 the middle of a function is not a good idea. */
11690 group_sections (struct ppc_link_hash_table *htab,
11691 bfd_size_type stub_group_size,
11692 bfd_boolean stubs_always_before_branch)
11695 bfd_size_type stub14_group_size;
11696 bfd_boolean suppress_size_errors;
11698 suppress_size_errors = FALSE;
11699 stub14_group_size = stub_group_size;
11700 if (stub_group_size == 1)
11702 /* Default values. */
11703 if (stubs_always_before_branch)
11705 stub_group_size = 0x1e00000;
11706 stub14_group_size = 0x7800;
11710 stub_group_size = 0x1c00000;
11711 stub14_group_size = 0x7000;
11713 suppress_size_errors = TRUE;
11716 list = htab->input_list + htab->top_index;
11719 asection *tail = *list;
11720 while (tail != NULL)
11724 bfd_size_type total;
11725 bfd_boolean big_sec;
11729 total = tail->size;
11730 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11731 && ppc64_elf_section_data (tail)->has_14bit_branch
11732 ? stub14_group_size : stub_group_size);
11733 if (big_sec && !suppress_size_errors)
11734 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11735 tail->owner, tail);
11736 curr_toc = htab->stub_group[tail->id].toc_off;
11738 while ((prev = PREV_SEC (curr)) != NULL
11739 && ((total += curr->output_offset - prev->output_offset)
11740 < (ppc64_elf_section_data (prev) != NULL
11741 && ppc64_elf_section_data (prev)->has_14bit_branch
11742 ? stub14_group_size : stub_group_size))
11743 && htab->stub_group[prev->id].toc_off == curr_toc)
11746 /* OK, the size from the start of CURR to the end is less
11747 than stub_group_size and thus can be handled by one stub
11748 section. (or the tail section is itself larger than
11749 stub_group_size, in which case we may be toast.) We
11750 should really be keeping track of the total size of stubs
11751 added here, as stubs contribute to the final output
11752 section size. That's a little tricky, and this way will
11753 only break if stubs added make the total size more than
11754 2^25, ie. for the default stub_group_size, if stubs total
11755 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11758 prev = PREV_SEC (tail);
11759 /* Set up this stub group. */
11760 htab->stub_group[tail->id].link_sec = curr;
11762 while (tail != curr && (tail = prev) != NULL);
11764 /* But wait, there's more! Input sections up to stub_group_size
11765 bytes before the stub section can be handled by it too.
11766 Don't do this if we have a really large section after the
11767 stubs, as adding more stubs increases the chance that
11768 branches may not reach into the stub section. */
11769 if (!stubs_always_before_branch && !big_sec)
11772 while (prev != NULL
11773 && ((total += tail->output_offset - prev->output_offset)
11774 < (ppc64_elf_section_data (prev) != NULL
11775 && ppc64_elf_section_data (prev)->has_14bit_branch
11776 ? stub14_group_size : stub_group_size))
11777 && htab->stub_group[prev->id].toc_off == curr_toc)
11780 prev = PREV_SEC (tail);
11781 htab->stub_group[tail->id].link_sec = curr;
11787 while (list-- != htab->input_list);
11788 free (htab->input_list);
11792 static const unsigned char glink_eh_frame_cie[] =
11794 0, 0, 0, 16, /* length. */
11795 0, 0, 0, 0, /* id. */
11796 1, /* CIE version. */
11797 'z', 'R', 0, /* Augmentation string. */
11798 4, /* Code alignment. */
11799 0x78, /* Data alignment. */
11801 1, /* Augmentation size. */
11802 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11803 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11806 /* Stripping output sections is normally done before dynamic section
11807 symbols have been allocated. This function is called later, and
11808 handles cases like htab->brlt which is mapped to its own output
11812 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11814 if (isec->size == 0
11815 && isec->output_section->size == 0
11816 && !(isec->output_section->flags & SEC_KEEP)
11817 && !bfd_section_removed_from_list (info->output_bfd,
11818 isec->output_section)
11819 && elf_section_data (isec->output_section)->dynindx == 0)
11821 isec->output_section->flags |= SEC_EXCLUDE;
11822 bfd_section_list_remove (info->output_bfd, isec->output_section);
11823 info->output_bfd->section_count--;
11827 /* Determine and set the size of the stub section for a final link.
11829 The basic idea here is to examine all the relocations looking for
11830 PC-relative calls to a target that is unreachable with a "bl"
11834 ppc64_elf_size_stubs (struct bfd_link_info *info)
11836 bfd_size_type stub_group_size;
11837 bfd_boolean stubs_always_before_branch;
11838 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11843 if (htab->params->plt_thread_safe == -1 && !info->executable)
11844 htab->params->plt_thread_safe = 1;
11845 if (!htab->opd_abi)
11846 htab->params->plt_thread_safe = 0;
11847 else if (htab->params->plt_thread_safe == -1)
11849 static const char *const thread_starter[] =
11853 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11855 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11856 "mq_notify", "create_timer",
11860 "GOMP_parallel_start",
11861 "GOMP_parallel_loop_static_start",
11862 "GOMP_parallel_loop_dynamic_start",
11863 "GOMP_parallel_loop_guided_start",
11864 "GOMP_parallel_loop_runtime_start",
11865 "GOMP_parallel_sections_start",
11869 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11871 struct elf_link_hash_entry *h;
11872 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11873 FALSE, FALSE, TRUE);
11874 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11875 if (htab->params->plt_thread_safe)
11879 stubs_always_before_branch = htab->params->group_size < 0;
11880 if (htab->params->group_size < 0)
11881 stub_group_size = -htab->params->group_size;
11883 stub_group_size = htab->params->group_size;
11885 group_sections (htab, stub_group_size, stubs_always_before_branch);
11890 unsigned int bfd_indx;
11891 asection *stub_sec;
11893 htab->stub_iteration += 1;
11895 for (input_bfd = info->input_bfds, bfd_indx = 0;
11897 input_bfd = input_bfd->link_next, bfd_indx++)
11899 Elf_Internal_Shdr *symtab_hdr;
11901 Elf_Internal_Sym *local_syms = NULL;
11903 if (!is_ppc64_elf (input_bfd))
11906 /* We'll need the symbol table in a second. */
11907 symtab_hdr = &elf_symtab_hdr (input_bfd);
11908 if (symtab_hdr->sh_info == 0)
11911 /* Walk over each section attached to the input bfd. */
11912 for (section = input_bfd->sections;
11914 section = section->next)
11916 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11918 /* If there aren't any relocs, then there's nothing more
11920 if ((section->flags & SEC_RELOC) == 0
11921 || (section->flags & SEC_ALLOC) == 0
11922 || (section->flags & SEC_LOAD) == 0
11923 || (section->flags & SEC_CODE) == 0
11924 || section->reloc_count == 0)
11927 /* If this section is a link-once section that will be
11928 discarded, then don't create any stubs. */
11929 if (section->output_section == NULL
11930 || section->output_section->owner != info->output_bfd)
11933 /* Get the relocs. */
11935 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11936 info->keep_memory);
11937 if (internal_relocs == NULL)
11938 goto error_ret_free_local;
11940 /* Now examine each relocation. */
11941 irela = internal_relocs;
11942 irelaend = irela + section->reloc_count;
11943 for (; irela < irelaend; irela++)
11945 enum elf_ppc64_reloc_type r_type;
11946 unsigned int r_indx;
11947 enum ppc_stub_type stub_type;
11948 struct ppc_stub_hash_entry *stub_entry;
11949 asection *sym_sec, *code_sec;
11950 bfd_vma sym_value, code_value;
11951 bfd_vma destination;
11952 unsigned long local_off;
11953 bfd_boolean ok_dest;
11954 struct ppc_link_hash_entry *hash;
11955 struct ppc_link_hash_entry *fdh;
11956 struct elf_link_hash_entry *h;
11957 Elf_Internal_Sym *sym;
11959 const asection *id_sec;
11960 struct _opd_sec_data *opd;
11961 struct plt_entry *plt_ent;
11963 r_type = ELF64_R_TYPE (irela->r_info);
11964 r_indx = ELF64_R_SYM (irela->r_info);
11966 if (r_type >= R_PPC64_max)
11968 bfd_set_error (bfd_error_bad_value);
11969 goto error_ret_free_internal;
11972 /* Only look for stubs on branch instructions. */
11973 if (r_type != R_PPC64_REL24
11974 && r_type != R_PPC64_REL14
11975 && r_type != R_PPC64_REL14_BRTAKEN
11976 && r_type != R_PPC64_REL14_BRNTAKEN)
11979 /* Now determine the call target, its name, value,
11981 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11982 r_indx, input_bfd))
11983 goto error_ret_free_internal;
11984 hash = (struct ppc_link_hash_entry *) h;
11991 sym_value = sym->st_value;
11994 else if (hash->elf.root.type == bfd_link_hash_defined
11995 || hash->elf.root.type == bfd_link_hash_defweak)
11997 sym_value = hash->elf.root.u.def.value;
11998 if (sym_sec->output_section != NULL)
12001 else if (hash->elf.root.type == bfd_link_hash_undefweak
12002 || hash->elf.root.type == bfd_link_hash_undefined)
12004 /* Recognise an old ABI func code entry sym, and
12005 use the func descriptor sym instead if it is
12007 if (hash->elf.root.root.string[0] == '.'
12008 && (fdh = lookup_fdh (hash, htab)) != NULL)
12010 if (fdh->elf.root.type == bfd_link_hash_defined
12011 || fdh->elf.root.type == bfd_link_hash_defweak)
12013 sym_sec = fdh->elf.root.u.def.section;
12014 sym_value = fdh->elf.root.u.def.value;
12015 if (sym_sec->output_section != NULL)
12024 bfd_set_error (bfd_error_bad_value);
12025 goto error_ret_free_internal;
12032 sym_value += irela->r_addend;
12033 destination = (sym_value
12034 + sym_sec->output_offset
12035 + sym_sec->output_section->vma);
12036 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12041 code_sec = sym_sec;
12042 code_value = sym_value;
12043 opd = get_opd_info (sym_sec);
12048 if (hash == NULL && opd->adjust != NULL)
12050 long adjust = opd->adjust[sym_value / 8];
12053 code_value += adjust;
12054 sym_value += adjust;
12056 dest = opd_entry_value (sym_sec, sym_value,
12057 &code_sec, &code_value, FALSE);
12058 if (dest != (bfd_vma) -1)
12060 destination = dest;
12063 /* Fixup old ABI sym to point at code
12065 hash->elf.root.type = bfd_link_hash_defweak;
12066 hash->elf.root.u.def.section = code_sec;
12067 hash->elf.root.u.def.value = code_value;
12072 /* Determine what (if any) linker stub is needed. */
12074 stub_type = ppc_type_of_stub (section, irela, &hash,
12075 &plt_ent, destination,
12078 if (stub_type != ppc_stub_plt_call)
12080 /* Check whether we need a TOC adjusting stub.
12081 Since the linker pastes together pieces from
12082 different object files when creating the
12083 _init and _fini functions, it may be that a
12084 call to what looks like a local sym is in
12085 fact a call needing a TOC adjustment. */
12086 if (code_sec != NULL
12087 && code_sec->output_section != NULL
12088 && (htab->stub_group[code_sec->id].toc_off
12089 != htab->stub_group[section->id].toc_off)
12090 && (code_sec->has_toc_reloc
12091 || code_sec->makes_toc_func_call))
12092 stub_type = ppc_stub_long_branch_r2off;
12095 if (stub_type == ppc_stub_none)
12098 /* __tls_get_addr calls might be eliminated. */
12099 if (stub_type != ppc_stub_plt_call
12101 && (hash == htab->tls_get_addr
12102 || hash == htab->tls_get_addr_fd)
12103 && section->has_tls_reloc
12104 && irela != internal_relocs)
12106 /* Get tls info. */
12107 unsigned char *tls_mask;
12109 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12110 irela - 1, input_bfd))
12111 goto error_ret_free_internal;
12112 if (*tls_mask != 0)
12116 if (stub_type == ppc_stub_plt_call
12117 && irela + 1 < irelaend
12118 && irela[1].r_offset == irela->r_offset + 4
12119 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12121 if (!tocsave_find (htab, INSERT,
12122 &local_syms, irela + 1, input_bfd))
12123 goto error_ret_free_internal;
12125 else if (stub_type == ppc_stub_plt_call)
12126 stub_type = ppc_stub_plt_call_r2save;
12128 /* Support for grouping stub sections. */
12129 id_sec = htab->stub_group[section->id].link_sec;
12131 /* Get the name of this stub. */
12132 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12134 goto error_ret_free_internal;
12136 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12137 stub_name, FALSE, FALSE);
12138 if (stub_entry != NULL)
12140 /* The proper stub has already been created. */
12142 if (stub_type == ppc_stub_plt_call_r2save)
12143 stub_entry->stub_type = stub_type;
12147 stub_entry = ppc_add_stub (stub_name, section, info);
12148 if (stub_entry == NULL)
12151 error_ret_free_internal:
12152 if (elf_section_data (section)->relocs == NULL)
12153 free (internal_relocs);
12154 error_ret_free_local:
12155 if (local_syms != NULL
12156 && (symtab_hdr->contents
12157 != (unsigned char *) local_syms))
12162 stub_entry->stub_type = stub_type;
12163 if (stub_type != ppc_stub_plt_call
12164 && stub_type != ppc_stub_plt_call_r2save)
12166 stub_entry->target_value = code_value;
12167 stub_entry->target_section = code_sec;
12171 stub_entry->target_value = sym_value;
12172 stub_entry->target_section = sym_sec;
12174 stub_entry->h = hash;
12175 stub_entry->plt_ent = plt_ent;
12176 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12178 if (stub_entry->h != NULL)
12179 htab->stub_globals += 1;
12182 /* We're done with the internal relocs, free them. */
12183 if (elf_section_data (section)->relocs != internal_relocs)
12184 free (internal_relocs);
12187 if (local_syms != NULL
12188 && symtab_hdr->contents != (unsigned char *) local_syms)
12190 if (!info->keep_memory)
12193 symtab_hdr->contents = (unsigned char *) local_syms;
12197 /* We may have added some stubs. Find out the new size of the
12199 for (stub_sec = htab->params->stub_bfd->sections;
12201 stub_sec = stub_sec->next)
12202 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12204 stub_sec->rawsize = stub_sec->size;
12205 stub_sec->size = 0;
12206 stub_sec->reloc_count = 0;
12207 stub_sec->flags &= ~SEC_RELOC;
12210 htab->brlt->size = 0;
12211 htab->brlt->reloc_count = 0;
12212 htab->brlt->flags &= ~SEC_RELOC;
12213 if (htab->relbrlt != NULL)
12214 htab->relbrlt->size = 0;
12216 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12218 if (info->emitrelocations
12219 && htab->glink != NULL && htab->glink->size != 0)
12221 htab->glink->reloc_count = 1;
12222 htab->glink->flags |= SEC_RELOC;
12225 if (htab->glink_eh_frame != NULL
12226 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12227 && htab->glink_eh_frame->output_section->size != 0)
12229 size_t size = 0, align;
12231 for (stub_sec = htab->params->stub_bfd->sections;
12233 stub_sec = stub_sec->next)
12234 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12236 if (htab->glink != NULL && htab->glink->size != 0)
12239 size += sizeof (glink_eh_frame_cie);
12241 align <<= htab->glink_eh_frame->output_section->alignment_power;
12243 size = (size + align) & ~align;
12244 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12245 htab->glink_eh_frame->size = size;
12248 if (htab->params->plt_stub_align != 0)
12249 for (stub_sec = htab->params->stub_bfd->sections;
12251 stub_sec = stub_sec->next)
12252 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12253 stub_sec->size = ((stub_sec->size
12254 + (1 << htab->params->plt_stub_align) - 1)
12255 & (-1 << htab->params->plt_stub_align));
12257 for (stub_sec = htab->params->stub_bfd->sections;
12259 stub_sec = stub_sec->next)
12260 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12261 && stub_sec->rawsize != stub_sec->size)
12264 /* Exit from this loop when no stubs have been added, and no stubs
12265 have changed size. */
12266 if (stub_sec == NULL
12267 && (htab->glink_eh_frame == NULL
12268 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12271 /* Ask the linker to do its stuff. */
12272 (*htab->params->layout_sections_again) ();
12275 maybe_strip_output (info, htab->brlt);
12276 if (htab->glink_eh_frame != NULL)
12277 maybe_strip_output (info, htab->glink_eh_frame);
12282 /* Called after we have determined section placement. If sections
12283 move, we'll be called again. Provide a value for TOCstart. */
12286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12291 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12292 order. The TOC starts where the first of these sections starts. */
12293 s = bfd_get_section_by_name (obfd, ".got");
12294 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12295 s = bfd_get_section_by_name (obfd, ".toc");
12296 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12297 s = bfd_get_section_by_name (obfd, ".tocbss");
12298 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12299 s = bfd_get_section_by_name (obfd, ".plt");
12300 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12302 /* This may happen for
12303 o references to TOC base (SYM@toc / TOC[tc0]) without a
12305 o bad linker script
12306 o --gc-sections and empty TOC sections
12308 FIXME: Warn user? */
12310 /* Look for a likely section. We probably won't even be
12312 for (s = obfd->sections; s != NULL; s = s->next)
12313 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12315 == (SEC_ALLOC | SEC_SMALL_DATA))
12318 for (s = obfd->sections; s != NULL; s = s->next)
12319 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12320 == (SEC_ALLOC | SEC_SMALL_DATA))
12323 for (s = obfd->sections; s != NULL; s = s->next)
12324 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12328 for (s = obfd->sections; s != NULL; s = s->next)
12329 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12335 TOCstart = s->output_section->vma + s->output_offset;
12337 _bfd_set_gp_value (obfd, TOCstart);
12339 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12341 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12344 && htab->elf.hgot != NULL)
12346 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12347 htab->elf.hgot->root.u.def.section = s;
12353 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12354 write out any global entry stubs. */
12357 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12359 struct bfd_link_info *info;
12360 struct ppc_link_hash_table *htab;
12361 struct plt_entry *pent;
12364 if (h->root.type == bfd_link_hash_indirect)
12367 if (!h->pointer_equality_needed)
12370 if (h->def_regular)
12374 htab = ppc_hash_table (info);
12379 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12380 if (pent->plt.offset != (bfd_vma) -1
12381 && pent->addend == 0)
12387 p = s->contents + h->root.u.def.value;
12388 plt = htab->elf.splt;
12389 if (!htab->elf.dynamic_sections_created
12390 || h->dynindx == -1)
12391 plt = htab->elf.iplt;
12392 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12393 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12395 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12397 info->callbacks->einfo
12398 (_("%P: linkage table error against `%T'\n"),
12399 h->root.root.string);
12400 bfd_set_error (bfd_error_bad_value);
12401 htab->stub_error = TRUE;
12404 if (PPC_HA (off) != 0)
12406 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12409 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12411 bfd_put_32 (s->owner, MTCTR_R12, p);
12413 bfd_put_32 (s->owner, BCTR, p);
12419 /* Build all the stubs associated with the current output file.
12420 The stubs are kept in a hash table attached to the main linker
12421 hash table. This function is called via gldelf64ppc_finish. */
12424 ppc64_elf_build_stubs (struct bfd_link_info *info,
12427 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12428 asection *stub_sec;
12430 int stub_sec_count = 0;
12435 /* Allocate memory to hold the linker stubs. */
12436 for (stub_sec = htab->params->stub_bfd->sections;
12438 stub_sec = stub_sec->next)
12439 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12440 && stub_sec->size != 0)
12442 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12443 if (stub_sec->contents == NULL)
12445 /* We want to check that built size is the same as calculated
12446 size. rawsize is a convenient location to use. */
12447 stub_sec->rawsize = stub_sec->size;
12448 stub_sec->size = 0;
12451 if (htab->glink != NULL && htab->glink->size != 0)
12456 /* Build the .glink plt call stub. */
12457 if (htab->params->emit_stub_syms)
12459 struct elf_link_hash_entry *h;
12460 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12461 TRUE, FALSE, FALSE);
12464 if (h->root.type == bfd_link_hash_new)
12466 h->root.type = bfd_link_hash_defined;
12467 h->root.u.def.section = htab->glink;
12468 h->root.u.def.value = 8;
12469 h->ref_regular = 1;
12470 h->def_regular = 1;
12471 h->ref_regular_nonweak = 1;
12472 h->forced_local = 1;
12476 plt0 = (htab->elf.splt->output_section->vma
12477 + htab->elf.splt->output_offset
12479 if (info->emitrelocations)
12481 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12484 r->r_offset = (htab->glink->output_offset
12485 + htab->glink->output_section->vma);
12486 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12487 r->r_addend = plt0;
12489 p = htab->glink->contents;
12490 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12491 bfd_put_64 (htab->glink->owner, plt0, p);
12495 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12497 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12499 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12501 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12503 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12505 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12507 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12509 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12511 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12513 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12518 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12520 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12522 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12524 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12526 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12528 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12530 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12532 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12534 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12536 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12538 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12540 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12543 bfd_put_32 (htab->glink->owner, BCTR, p);
12545 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12547 bfd_put_32 (htab->glink->owner, NOP, p);
12551 /* Build the .glink lazy link call stubs. */
12553 while (p < htab->glink->contents + htab->glink->rawsize)
12559 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12564 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12566 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12571 bfd_put_32 (htab->glink->owner,
12572 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12577 /* Build .glink global entry stubs. */
12578 if (htab->glink->size > htab->glink->rawsize)
12579 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12582 if (htab->brlt->size != 0)
12584 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12586 if (htab->brlt->contents == NULL)
12589 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12591 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12592 htab->relbrlt->size);
12593 if (htab->relbrlt->contents == NULL)
12597 if (htab->glink_eh_frame != NULL
12598 && htab->glink_eh_frame->size != 0)
12601 bfd_byte *last_fde;
12602 size_t last_fde_len, size, align, pad;
12604 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12607 htab->glink_eh_frame->contents = p;
12610 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12612 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12613 /* CIE length (rewrite in case little-endian). */
12614 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12615 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12616 p += sizeof (glink_eh_frame_cie);
12618 for (stub_sec = htab->params->stub_bfd->sections;
12620 stub_sec = stub_sec->next)
12621 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12626 bfd_put_32 (htab->elf.dynobj, 16, p);
12629 val = p - htab->glink_eh_frame->contents;
12630 bfd_put_32 (htab->elf.dynobj, val, p);
12632 /* Offset to stub section. */
12633 val = (stub_sec->output_section->vma
12634 + stub_sec->output_offset);
12635 val -= (htab->glink_eh_frame->output_section->vma
12636 + htab->glink_eh_frame->output_offset);
12637 val -= p - htab->glink_eh_frame->contents;
12638 if (val + 0x80000000 > 0xffffffff)
12640 info->callbacks->einfo
12641 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12645 bfd_put_32 (htab->elf.dynobj, val, p);
12647 /* stub section size. */
12648 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12650 /* Augmentation. */
12655 if (htab->glink != NULL && htab->glink->size != 0)
12660 bfd_put_32 (htab->elf.dynobj, 20, p);
12663 val = p - htab->glink_eh_frame->contents;
12664 bfd_put_32 (htab->elf.dynobj, val, p);
12666 /* Offset to .glink. */
12667 val = (htab->glink->output_section->vma
12668 + htab->glink->output_offset
12670 val -= (htab->glink_eh_frame->output_section->vma
12671 + htab->glink_eh_frame->output_offset);
12672 val -= p - htab->glink_eh_frame->contents;
12673 if (val + 0x80000000 > 0xffffffff)
12675 info->callbacks->einfo
12676 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12677 htab->glink->name);
12680 bfd_put_32 (htab->elf.dynobj, val, p);
12683 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12685 /* Augmentation. */
12688 *p++ = DW_CFA_advance_loc + 1;
12689 *p++ = DW_CFA_register;
12692 *p++ = DW_CFA_advance_loc + 4;
12693 *p++ = DW_CFA_restore_extended;
12696 /* Subsume any padding into the last FDE if user .eh_frame
12697 sections are aligned more than glink_eh_frame. Otherwise any
12698 zero padding will be seen as a terminator. */
12699 size = p - htab->glink_eh_frame->contents;
12701 align <<= htab->glink_eh_frame->output_section->alignment_power;
12703 pad = ((size + align) & ~align) - size;
12704 htab->glink_eh_frame->size = size + pad;
12705 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12708 /* Build the stubs as directed by the stub hash table. */
12709 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12711 if (htab->relbrlt != NULL)
12712 htab->relbrlt->reloc_count = 0;
12714 if (htab->params->plt_stub_align != 0)
12715 for (stub_sec = htab->params->stub_bfd->sections;
12717 stub_sec = stub_sec->next)
12718 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12719 stub_sec->size = ((stub_sec->size
12720 + (1 << htab->params->plt_stub_align) - 1)
12721 & (-1 << htab->params->plt_stub_align));
12723 for (stub_sec = htab->params->stub_bfd->sections;
12725 stub_sec = stub_sec->next)
12726 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12728 stub_sec_count += 1;
12729 if (stub_sec->rawsize != stub_sec->size)
12733 if (stub_sec != NULL
12734 || (htab->glink_eh_frame != NULL
12735 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12737 htab->stub_error = TRUE;
12738 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12741 if (htab->stub_error)
12746 *stats = bfd_malloc (500);
12747 if (*stats == NULL)
12750 sprintf (*stats, _("linker stubs in %u group%s\n"
12752 " toc adjust %lu\n"
12753 " long branch %lu\n"
12754 " long toc adj %lu\n"
12756 " plt call toc %lu"),
12758 stub_sec_count == 1 ? "" : "s",
12759 htab->stub_count[ppc_stub_long_branch - 1],
12760 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12761 htab->stub_count[ppc_stub_plt_branch - 1],
12762 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12763 htab->stub_count[ppc_stub_plt_call - 1],
12764 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12769 /* This function undoes the changes made by add_symbol_adjust. */
12772 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12774 struct ppc_link_hash_entry *eh;
12776 if (h->root.type == bfd_link_hash_indirect)
12779 eh = (struct ppc_link_hash_entry *) h;
12780 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12783 eh->elf.root.type = bfd_link_hash_undefined;
12788 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12790 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12793 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12796 /* What to do when ld finds relocations against symbols defined in
12797 discarded sections. */
12799 static unsigned int
12800 ppc64_elf_action_discarded (asection *sec)
12802 if (strcmp (".opd", sec->name) == 0)
12805 if (strcmp (".toc", sec->name) == 0)
12808 if (strcmp (".toc1", sec->name) == 0)
12811 return _bfd_elf_default_action_discarded (sec);
12814 /* The RELOCATE_SECTION function is called by the ELF backend linker
12815 to handle the relocations for a section.
12817 The relocs are always passed as Rela structures; if the section
12818 actually uses Rel structures, the r_addend field will always be
12821 This function is responsible for adjust the section contents as
12822 necessary, and (if using Rela relocs and generating a
12823 relocatable output file) adjusting the reloc addend as
12826 This function does not have to worry about setting the reloc
12827 address or the reloc symbol index.
12829 LOCAL_SYMS is a pointer to the swapped in local symbols.
12831 LOCAL_SECTIONS is an array giving the section in the input file
12832 corresponding to the st_shndx field of each local symbol.
12834 The global hash table entry for the global symbols can be found
12835 via elf_sym_hashes (input_bfd).
12837 When generating relocatable output, this function must handle
12838 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12839 going to be the section symbol corresponding to the output
12840 section, which means that the addend must be adjusted
12844 ppc64_elf_relocate_section (bfd *output_bfd,
12845 struct bfd_link_info *info,
12847 asection *input_section,
12848 bfd_byte *contents,
12849 Elf_Internal_Rela *relocs,
12850 Elf_Internal_Sym *local_syms,
12851 asection **local_sections)
12853 struct ppc_link_hash_table *htab;
12854 Elf_Internal_Shdr *symtab_hdr;
12855 struct elf_link_hash_entry **sym_hashes;
12856 Elf_Internal_Rela *rel;
12857 Elf_Internal_Rela *relend;
12858 Elf_Internal_Rela outrel;
12860 struct got_entry **local_got_ents;
12862 bfd_boolean ret = TRUE;
12863 bfd_boolean is_opd;
12864 /* Assume 'at' branch hints. */
12865 bfd_boolean is_isa_v2 = TRUE;
12866 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12868 /* Initialize howto table if needed. */
12869 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12872 htab = ppc_hash_table (info);
12876 /* Don't relocate stub sections. */
12877 if (input_section->owner == htab->params->stub_bfd)
12880 BFD_ASSERT (is_ppc64_elf (input_bfd));
12882 local_got_ents = elf_local_got_ents (input_bfd);
12883 TOCstart = elf_gp (output_bfd);
12884 symtab_hdr = &elf_symtab_hdr (input_bfd);
12885 sym_hashes = elf_sym_hashes (input_bfd);
12886 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12889 relend = relocs + input_section->reloc_count;
12890 for (; rel < relend; rel++)
12892 enum elf_ppc64_reloc_type r_type;
12894 bfd_reloc_status_type r;
12895 Elf_Internal_Sym *sym;
12897 struct elf_link_hash_entry *h_elf;
12898 struct ppc_link_hash_entry *h;
12899 struct ppc_link_hash_entry *fdh;
12900 const char *sym_name;
12901 unsigned long r_symndx, toc_symndx;
12902 bfd_vma toc_addend;
12903 unsigned char tls_mask, tls_gd, tls_type;
12904 unsigned char sym_type;
12905 bfd_vma relocation;
12906 bfd_boolean unresolved_reloc;
12907 bfd_boolean warned;
12908 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12911 struct ppc_stub_hash_entry *stub_entry;
12912 bfd_vma max_br_offset;
12914 const Elf_Internal_Rela orig_rel = *rel;
12916 r_type = ELF64_R_TYPE (rel->r_info);
12917 r_symndx = ELF64_R_SYM (rel->r_info);
12919 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12920 symbol of the previous ADDR64 reloc. The symbol gives us the
12921 proper TOC base to use. */
12922 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12924 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12926 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12932 unresolved_reloc = FALSE;
12935 if (r_symndx < symtab_hdr->sh_info)
12937 /* It's a local symbol. */
12938 struct _opd_sec_data *opd;
12940 sym = local_syms + r_symndx;
12941 sec = local_sections[r_symndx];
12942 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12943 sym_type = ELF64_ST_TYPE (sym->st_info);
12944 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12945 opd = get_opd_info (sec);
12946 if (opd != NULL && opd->adjust != NULL)
12948 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12953 /* If this is a relocation against the opd section sym
12954 and we have edited .opd, adjust the reloc addend so
12955 that ld -r and ld --emit-relocs output is correct.
12956 If it is a reloc against some other .opd symbol,
12957 then the symbol value will be adjusted later. */
12958 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12959 rel->r_addend += adjust;
12961 relocation += adjust;
12967 bfd_boolean ignored;
12969 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12970 r_symndx, symtab_hdr, sym_hashes,
12971 h_elf, sec, relocation,
12972 unresolved_reloc, warned, ignored);
12973 sym_name = h_elf->root.root.string;
12974 sym_type = h_elf->type;
12976 && sec->owner == output_bfd
12977 && strcmp (sec->name, ".opd") == 0)
12979 /* This is a symbol defined in a linker script. All
12980 such are defined in output sections, even those
12981 defined by simple assignment from a symbol defined in
12982 an input section. Transfer the symbol to an
12983 appropriate input .opd section, so that a branch to
12984 this symbol will be mapped to the location specified
12985 by the opd entry. */
12986 struct bfd_link_order *lo;
12987 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12988 if (lo->type == bfd_indirect_link_order)
12990 asection *isec = lo->u.indirect.section;
12991 if (h_elf->root.u.def.value >= isec->output_offset
12992 && h_elf->root.u.def.value < (isec->output_offset
12995 h_elf->root.u.def.value -= isec->output_offset;
12996 h_elf->root.u.def.section = isec;
13003 h = (struct ppc_link_hash_entry *) h_elf;
13005 if (sec != NULL && discarded_section (sec))
13006 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13008 ppc64_elf_howto_table[r_type], 0,
13011 if (info->relocatable)
13014 if (h != NULL && &h->elf == htab->elf.hgot)
13016 relocation = (TOCstart
13017 + htab->stub_group[input_section->id].toc_off);
13018 sec = bfd_abs_section_ptr;
13019 unresolved_reloc = FALSE;
13022 /* TLS optimizations. Replace instruction sequences and relocs
13023 based on information we collected in tls_optimize. We edit
13024 RELOCS so that --emit-relocs will output something sensible
13025 for the final instruction stream. */
13030 tls_mask = h->tls_mask;
13031 else if (local_got_ents != NULL)
13033 struct plt_entry **local_plt = (struct plt_entry **)
13034 (local_got_ents + symtab_hdr->sh_info);
13035 unsigned char *lgot_masks = (unsigned char *)
13036 (local_plt + symtab_hdr->sh_info);
13037 tls_mask = lgot_masks[r_symndx];
13040 && (r_type == R_PPC64_TLS
13041 || r_type == R_PPC64_TLSGD
13042 || r_type == R_PPC64_TLSLD))
13044 /* Check for toc tls entries. */
13045 unsigned char *toc_tls;
13047 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13048 &local_syms, rel, input_bfd))
13052 tls_mask = *toc_tls;
13055 /* Check that tls relocs are used with tls syms, and non-tls
13056 relocs are used with non-tls syms. */
13057 if (r_symndx != STN_UNDEF
13058 && r_type != R_PPC64_NONE
13060 || h->elf.root.type == bfd_link_hash_defined
13061 || h->elf.root.type == bfd_link_hash_defweak)
13062 && (IS_PPC64_TLS_RELOC (r_type)
13063 != (sym_type == STT_TLS
13064 || (sym_type == STT_SECTION
13065 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13068 && (r_type == R_PPC64_TLS
13069 || r_type == R_PPC64_TLSGD
13070 || r_type == R_PPC64_TLSLD))
13071 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13074 info->callbacks->einfo
13075 (!IS_PPC64_TLS_RELOC (r_type)
13076 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13077 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13078 input_bfd, input_section, rel->r_offset,
13079 ppc64_elf_howto_table[r_type]->name,
13083 /* Ensure reloc mapping code below stays sane. */
13084 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13085 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13086 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13087 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13088 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13089 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13090 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13091 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13092 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13093 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13101 case R_PPC64_LO_DS_OPT:
13102 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13103 if ((insn & (0x3f << 26)) != 58u << 26)
13105 insn += (14u << 26) - (58u << 26);
13106 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13107 r_type = R_PPC64_TOC16_LO;
13108 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13111 case R_PPC64_TOC16:
13112 case R_PPC64_TOC16_LO:
13113 case R_PPC64_TOC16_DS:
13114 case R_PPC64_TOC16_LO_DS:
13116 /* Check for toc tls entries. */
13117 unsigned char *toc_tls;
13120 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13121 &local_syms, rel, input_bfd);
13127 tls_mask = *toc_tls;
13128 if (r_type == R_PPC64_TOC16_DS
13129 || r_type == R_PPC64_TOC16_LO_DS)
13132 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13137 /* If we found a GD reloc pair, then we might be
13138 doing a GD->IE transition. */
13141 tls_gd = TLS_TPRELGD;
13142 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13145 else if (retval == 3)
13147 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13155 case R_PPC64_GOT_TPREL16_HI:
13156 case R_PPC64_GOT_TPREL16_HA:
13158 && (tls_mask & TLS_TPREL) == 0)
13160 rel->r_offset -= d_offset;
13161 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13162 r_type = R_PPC64_NONE;
13163 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13167 case R_PPC64_GOT_TPREL16_DS:
13168 case R_PPC64_GOT_TPREL16_LO_DS:
13170 && (tls_mask & TLS_TPREL) == 0)
13173 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13175 insn |= 0x3c0d0000; /* addis 0,13,0 */
13176 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13177 r_type = R_PPC64_TPREL16_HA;
13178 if (toc_symndx != 0)
13180 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13181 rel->r_addend = toc_addend;
13182 /* We changed the symbol. Start over in order to
13183 get h, sym, sec etc. right. */
13188 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13194 && (tls_mask & TLS_TPREL) == 0)
13196 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13197 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13200 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13201 /* Was PPC64_TLS which sits on insn boundary, now
13202 PPC64_TPREL16_LO which is at low-order half-word. */
13203 rel->r_offset += d_offset;
13204 r_type = R_PPC64_TPREL16_LO;
13205 if (toc_symndx != 0)
13207 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13208 rel->r_addend = toc_addend;
13209 /* We changed the symbol. Start over in order to
13210 get h, sym, sec etc. right. */
13215 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13219 case R_PPC64_GOT_TLSGD16_HI:
13220 case R_PPC64_GOT_TLSGD16_HA:
13221 tls_gd = TLS_TPRELGD;
13222 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13226 case R_PPC64_GOT_TLSLD16_HI:
13227 case R_PPC64_GOT_TLSLD16_HA:
13228 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13231 if ((tls_mask & tls_gd) != 0)
13232 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13233 + R_PPC64_GOT_TPREL16_DS);
13236 rel->r_offset -= d_offset;
13237 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13238 r_type = R_PPC64_NONE;
13240 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13244 case R_PPC64_GOT_TLSGD16:
13245 case R_PPC64_GOT_TLSGD16_LO:
13246 tls_gd = TLS_TPRELGD;
13247 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13251 case R_PPC64_GOT_TLSLD16:
13252 case R_PPC64_GOT_TLSLD16_LO:
13253 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13255 unsigned int insn1, insn2, insn3;
13259 offset = (bfd_vma) -1;
13260 /* If not using the newer R_PPC64_TLSGD/LD to mark
13261 __tls_get_addr calls, we must trust that the call
13262 stays with its arg setup insns, ie. that the next
13263 reloc is the __tls_get_addr call associated with
13264 the current reloc. Edit both insns. */
13265 if (input_section->has_tls_get_addr_call
13266 && rel + 1 < relend
13267 && branch_reloc_hash_match (input_bfd, rel + 1,
13268 htab->tls_get_addr,
13269 htab->tls_get_addr_fd))
13270 offset = rel[1].r_offset;
13271 if ((tls_mask & tls_gd) != 0)
13274 insn1 = bfd_get_32 (output_bfd,
13275 contents + rel->r_offset - d_offset);
13276 insn1 &= (1 << 26) - (1 << 2);
13277 insn1 |= 58 << 26; /* ld */
13278 insn2 = 0x7c636a14; /* add 3,3,13 */
13279 if (offset != (bfd_vma) -1)
13280 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13281 if ((tls_mask & TLS_EXPLICIT) == 0)
13282 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13283 + R_PPC64_GOT_TPREL16_DS);
13285 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13286 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13291 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13292 insn2 = 0x38630000; /* addi 3,3,0 */
13295 /* Was an LD reloc. */
13297 sec = local_sections[toc_symndx];
13299 r_symndx < symtab_hdr->sh_info;
13301 if (local_sections[r_symndx] == sec)
13303 if (r_symndx >= symtab_hdr->sh_info)
13304 r_symndx = STN_UNDEF;
13305 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13306 if (r_symndx != STN_UNDEF)
13307 rel->r_addend -= (local_syms[r_symndx].st_value
13308 + sec->output_offset
13309 + sec->output_section->vma);
13311 else if (toc_symndx != 0)
13313 r_symndx = toc_symndx;
13314 rel->r_addend = toc_addend;
13316 r_type = R_PPC64_TPREL16_HA;
13317 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13318 if (offset != (bfd_vma) -1)
13320 rel[1].r_info = ELF64_R_INFO (r_symndx,
13321 R_PPC64_TPREL16_LO);
13322 rel[1].r_offset = offset + d_offset;
13323 rel[1].r_addend = rel->r_addend;
13326 bfd_put_32 (output_bfd, insn1,
13327 contents + rel->r_offset - d_offset);
13328 if (offset != (bfd_vma) -1)
13330 insn3 = bfd_get_32 (output_bfd,
13331 contents + offset + 4);
13333 || insn3 == CROR_151515 || insn3 == CROR_313131)
13335 rel[1].r_offset += 4;
13336 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13339 bfd_put_32 (output_bfd, insn2, contents + offset);
13341 if ((tls_mask & tls_gd) == 0
13342 && (tls_gd == 0 || toc_symndx != 0))
13344 /* We changed the symbol. Start over in order
13345 to get h, sym, sec etc. right. */
13352 case R_PPC64_TLSGD:
13353 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13355 unsigned int insn2, insn3;
13356 bfd_vma offset = rel->r_offset;
13358 if ((tls_mask & TLS_TPRELGD) != 0)
13361 r_type = R_PPC64_NONE;
13362 insn2 = 0x7c636a14; /* add 3,3,13 */
13367 if (toc_symndx != 0)
13369 r_symndx = toc_symndx;
13370 rel->r_addend = toc_addend;
13372 r_type = R_PPC64_TPREL16_LO;
13373 rel->r_offset = offset + d_offset;
13374 insn2 = 0x38630000; /* addi 3,3,0 */
13376 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13377 /* Zap the reloc on the _tls_get_addr call too. */
13378 BFD_ASSERT (offset == rel[1].r_offset);
13379 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13380 insn3 = bfd_get_32 (output_bfd,
13381 contents + offset + 4);
13383 || insn3 == CROR_151515 || insn3 == CROR_313131)
13385 rel->r_offset += 4;
13386 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13389 bfd_put_32 (output_bfd, insn2, contents + offset);
13390 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13398 case R_PPC64_TLSLD:
13399 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13401 unsigned int insn2, insn3;
13402 bfd_vma offset = rel->r_offset;
13405 sec = local_sections[toc_symndx];
13407 r_symndx < symtab_hdr->sh_info;
13409 if (local_sections[r_symndx] == sec)
13411 if (r_symndx >= symtab_hdr->sh_info)
13412 r_symndx = STN_UNDEF;
13413 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13414 if (r_symndx != STN_UNDEF)
13415 rel->r_addend -= (local_syms[r_symndx].st_value
13416 + sec->output_offset
13417 + sec->output_section->vma);
13419 r_type = R_PPC64_TPREL16_LO;
13420 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13421 rel->r_offset = offset + d_offset;
13422 /* Zap the reloc on the _tls_get_addr call too. */
13423 BFD_ASSERT (offset == rel[1].r_offset);
13424 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13425 insn2 = 0x38630000; /* addi 3,3,0 */
13426 insn3 = bfd_get_32 (output_bfd,
13427 contents + offset + 4);
13429 || insn3 == CROR_151515 || insn3 == CROR_313131)
13431 rel->r_offset += 4;
13432 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13435 bfd_put_32 (output_bfd, insn2, contents + offset);
13441 case R_PPC64_DTPMOD64:
13442 if (rel + 1 < relend
13443 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13444 && rel[1].r_offset == rel->r_offset + 8)
13446 if ((tls_mask & TLS_GD) == 0)
13448 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13449 if ((tls_mask & TLS_TPRELGD) != 0)
13450 r_type = R_PPC64_TPREL64;
13453 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13454 r_type = R_PPC64_NONE;
13456 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13461 if ((tls_mask & TLS_LD) == 0)
13463 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13464 r_type = R_PPC64_NONE;
13465 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13470 case R_PPC64_TPREL64:
13471 if ((tls_mask & TLS_TPREL) == 0)
13473 r_type = R_PPC64_NONE;
13474 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13478 case R_PPC64_REL16_HA:
13479 /* If we are generating a non-PIC executable, edit
13480 . 0: addis 2,12,.TOC.-0b@ha
13481 . addi 2,2,.TOC.-0b@l
13482 used by ELFv2 global entry points to set up r2, to
13485 if .TOC. is in range. */
13487 && h != NULL && &h->elf == htab->elf.hgot
13488 && rel + 1 < relend
13489 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13490 && rel[1].r_offset == rel->r_offset + 4
13491 && rel[1].r_addend == rel->r_addend + 4
13492 && relocation + 0x80008000 <= 0xffffffff)
13494 unsigned int insn1, insn2;
13495 bfd_vma offset = rel->r_offset - d_offset;
13496 insn1 = bfd_get_32 (output_bfd, contents + offset);
13497 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13498 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13499 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13501 r_type = R_PPC64_ADDR16_HA;
13502 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13503 rel->r_addend -= d_offset;
13504 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13505 rel[1].r_addend -= d_offset + 4;
13506 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13512 /* Handle other relocations that tweak non-addend part of insn. */
13514 max_br_offset = 1 << 25;
13515 addend = rel->r_addend;
13516 reloc_dest = DEST_NORMAL;
13522 case R_PPC64_TOCSAVE:
13523 if (relocation + addend == (rel->r_offset
13524 + input_section->output_offset
13525 + input_section->output_section->vma)
13526 && tocsave_find (htab, NO_INSERT,
13527 &local_syms, rel, input_bfd))
13529 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13531 || insn == CROR_151515 || insn == CROR_313131)
13532 bfd_put_32 (input_bfd,
13533 STD_R2_0R1 + STK_TOC (htab),
13534 contents + rel->r_offset);
13538 /* Branch taken prediction relocations. */
13539 case R_PPC64_ADDR14_BRTAKEN:
13540 case R_PPC64_REL14_BRTAKEN:
13541 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13544 /* Branch not taken prediction relocations. */
13545 case R_PPC64_ADDR14_BRNTAKEN:
13546 case R_PPC64_REL14_BRNTAKEN:
13547 insn |= bfd_get_32 (output_bfd,
13548 contents + rel->r_offset) & ~(0x01 << 21);
13551 case R_PPC64_REL14:
13552 max_br_offset = 1 << 15;
13555 case R_PPC64_REL24:
13556 /* Calls to functions with a different TOC, such as calls to
13557 shared objects, need to alter the TOC pointer. This is
13558 done using a linkage stub. A REL24 branching to these
13559 linkage stubs needs to be followed by a nop, as the nop
13560 will be replaced with an instruction to restore the TOC
13565 && h->oh->is_func_descriptor)
13566 fdh = ppc_follow_link (h->oh);
13567 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13569 if (stub_entry != NULL
13570 && (stub_entry->stub_type == ppc_stub_plt_call
13571 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13572 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13573 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13575 bfd_boolean can_plt_call = FALSE;
13577 /* All of these stubs will modify r2, so there must be a
13578 branch and link followed by a nop. The nop is
13579 replaced by an insn to restore r2. */
13580 if (rel->r_offset + 8 <= input_section->size)
13584 br = bfd_get_32 (input_bfd,
13585 contents + rel->r_offset);
13590 nop = bfd_get_32 (input_bfd,
13591 contents + rel->r_offset + 4);
13593 || nop == CROR_151515 || nop == CROR_313131)
13596 && (h == htab->tls_get_addr_fd
13597 || h == htab->tls_get_addr)
13598 && !htab->params->no_tls_get_addr_opt)
13600 /* Special stub used, leave nop alone. */
13603 bfd_put_32 (input_bfd,
13604 LD_R2_0R1 + STK_TOC (htab),
13605 contents + rel->r_offset + 4);
13606 can_plt_call = TRUE;
13611 if (!can_plt_call && h != NULL)
13613 const char *name = h->elf.root.root.string;
13618 if (strncmp (name, "__libc_start_main", 17) == 0
13619 && (name[17] == 0 || name[17] == '@'))
13621 /* Allow crt1 branch to go via a toc adjusting
13622 stub. Other calls that never return could do
13623 the same, if we could detect such. */
13624 can_plt_call = TRUE;
13630 /* g++ as of 20130507 emits self-calls without a
13631 following nop. This is arguably wrong since we
13632 have conflicting information. On the one hand a
13633 global symbol and on the other a local call
13634 sequence, but don't error for this special case.
13635 It isn't possible to cheaply verify we have
13636 exactly such a call. Allow all calls to the same
13638 asection *code_sec = sec;
13640 if (get_opd_info (sec) != NULL)
13642 bfd_vma off = (relocation + addend
13643 - sec->output_section->vma
13644 - sec->output_offset);
13646 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13648 if (code_sec == input_section)
13649 can_plt_call = TRUE;
13654 info->callbacks->einfo
13655 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13656 "recompile with -fPIC\n"),
13657 input_bfd, input_section, rel->r_offset, sym_name);
13659 bfd_set_error (bfd_error_bad_value);
13664 && (stub_entry->stub_type == ppc_stub_plt_call
13665 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13666 unresolved_reloc = FALSE;
13669 if ((stub_entry == NULL
13670 || stub_entry->stub_type == ppc_stub_long_branch
13671 || stub_entry->stub_type == ppc_stub_plt_branch)
13672 && get_opd_info (sec) != NULL)
13674 /* The branch destination is the value of the opd entry. */
13675 bfd_vma off = (relocation + addend
13676 - sec->output_section->vma
13677 - sec->output_offset);
13678 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13679 if (dest != (bfd_vma) -1)
13683 reloc_dest = DEST_OPD;
13687 /* If the branch is out of reach we ought to have a long
13689 from = (rel->r_offset
13690 + input_section->output_offset
13691 + input_section->output_section->vma);
13693 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13697 if (stub_entry != NULL
13698 && (stub_entry->stub_type == ppc_stub_long_branch
13699 || stub_entry->stub_type == ppc_stub_plt_branch)
13700 && (r_type == R_PPC64_ADDR14_BRTAKEN
13701 || r_type == R_PPC64_ADDR14_BRNTAKEN
13702 || (relocation + addend - from + max_br_offset
13703 < 2 * max_br_offset)))
13704 /* Don't use the stub if this branch is in range. */
13707 if (stub_entry != NULL)
13709 /* Munge up the value and addend so that we call the stub
13710 rather than the procedure directly. */
13711 relocation = (stub_entry->stub_offset
13712 + stub_entry->stub_sec->output_offset
13713 + stub_entry->stub_sec->output_section->vma);
13715 reloc_dest = DEST_STUB;
13717 if ((stub_entry->stub_type == ppc_stub_plt_call
13718 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13719 && (ALWAYS_EMIT_R2SAVE
13720 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13721 && rel + 1 < relend
13722 && rel[1].r_offset == rel->r_offset + 4
13723 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13731 /* Set 'a' bit. This is 0b00010 in BO field for branch
13732 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13733 for branch on CTR insns (BO == 1a00t or 1a01t). */
13734 if ((insn & (0x14 << 21)) == (0x04 << 21))
13735 insn |= 0x02 << 21;
13736 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13737 insn |= 0x08 << 21;
13743 /* Invert 'y' bit if not the default. */
13744 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13745 insn ^= 0x01 << 21;
13748 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13751 /* NOP out calls to undefined weak functions.
13752 We can thus call a weak function without first
13753 checking whether the function is defined. */
13755 && h->elf.root.type == bfd_link_hash_undefweak
13756 && h->elf.dynindx == -1
13757 && r_type == R_PPC64_REL24
13761 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13767 /* Set `addend'. */
13772 info->callbacks->einfo
13773 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13774 input_bfd, (int) r_type, sym_name);
13776 bfd_set_error (bfd_error_bad_value);
13782 case R_PPC64_TLSGD:
13783 case R_PPC64_TLSLD:
13784 case R_PPC64_TOCSAVE:
13785 case R_PPC64_GNU_VTINHERIT:
13786 case R_PPC64_GNU_VTENTRY:
13789 /* GOT16 relocations. Like an ADDR16 using the symbol's
13790 address in the GOT as relocation value instead of the
13791 symbol's value itself. Also, create a GOT entry for the
13792 symbol and put the symbol value there. */
13793 case R_PPC64_GOT_TLSGD16:
13794 case R_PPC64_GOT_TLSGD16_LO:
13795 case R_PPC64_GOT_TLSGD16_HI:
13796 case R_PPC64_GOT_TLSGD16_HA:
13797 tls_type = TLS_TLS | TLS_GD;
13800 case R_PPC64_GOT_TLSLD16:
13801 case R_PPC64_GOT_TLSLD16_LO:
13802 case R_PPC64_GOT_TLSLD16_HI:
13803 case R_PPC64_GOT_TLSLD16_HA:
13804 tls_type = TLS_TLS | TLS_LD;
13807 case R_PPC64_GOT_TPREL16_DS:
13808 case R_PPC64_GOT_TPREL16_LO_DS:
13809 case R_PPC64_GOT_TPREL16_HI:
13810 case R_PPC64_GOT_TPREL16_HA:
13811 tls_type = TLS_TLS | TLS_TPREL;
13814 case R_PPC64_GOT_DTPREL16_DS:
13815 case R_PPC64_GOT_DTPREL16_LO_DS:
13816 case R_PPC64_GOT_DTPREL16_HI:
13817 case R_PPC64_GOT_DTPREL16_HA:
13818 tls_type = TLS_TLS | TLS_DTPREL;
13821 case R_PPC64_GOT16:
13822 case R_PPC64_GOT16_LO:
13823 case R_PPC64_GOT16_HI:
13824 case R_PPC64_GOT16_HA:
13825 case R_PPC64_GOT16_DS:
13826 case R_PPC64_GOT16_LO_DS:
13829 /* Relocation is to the entry for this symbol in the global
13834 unsigned long indx = 0;
13835 struct got_entry *ent;
13837 if (tls_type == (TLS_TLS | TLS_LD)
13839 || !h->elf.def_dynamic))
13840 ent = ppc64_tlsld_got (input_bfd);
13846 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13847 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13850 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13851 /* This is actually a static link, or it is a
13852 -Bsymbolic link and the symbol is defined
13853 locally, or the symbol was forced to be local
13854 because of a version file. */
13858 BFD_ASSERT (h->elf.dynindx != -1);
13859 indx = h->elf.dynindx;
13860 unresolved_reloc = FALSE;
13862 ent = h->elf.got.glist;
13866 if (local_got_ents == NULL)
13868 ent = local_got_ents[r_symndx];
13871 for (; ent != NULL; ent = ent->next)
13872 if (ent->addend == orig_rel.r_addend
13873 && ent->owner == input_bfd
13874 && ent->tls_type == tls_type)
13880 if (ent->is_indirect)
13881 ent = ent->got.ent;
13882 offp = &ent->got.offset;
13883 got = ppc64_elf_tdata (ent->owner)->got;
13887 /* The offset must always be a multiple of 8. We use the
13888 least significant bit to record whether we have already
13889 processed this entry. */
13891 if ((off & 1) != 0)
13895 /* Generate relocs for the dynamic linker, except in
13896 the case of TLSLD where we'll use one entry per
13904 ? h->elf.type == STT_GNU_IFUNC
13905 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13907 relgot = htab->elf.irelplt;
13908 else if ((info->shared || indx != 0)
13910 || (tls_type == (TLS_TLS | TLS_LD)
13911 && !h->elf.def_dynamic)
13912 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13913 || h->elf.root.type != bfd_link_hash_undefweak))
13914 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13915 if (relgot != NULL)
13917 outrel.r_offset = (got->output_section->vma
13918 + got->output_offset
13920 outrel.r_addend = addend;
13921 if (tls_type & (TLS_LD | TLS_GD))
13923 outrel.r_addend = 0;
13924 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13925 if (tls_type == (TLS_TLS | TLS_GD))
13927 loc = relgot->contents;
13928 loc += (relgot->reloc_count++
13929 * sizeof (Elf64_External_Rela));
13930 bfd_elf64_swap_reloca_out (output_bfd,
13932 outrel.r_offset += 8;
13933 outrel.r_addend = addend;
13935 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13938 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13939 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13940 else if (tls_type == (TLS_TLS | TLS_TPREL))
13941 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13942 else if (indx != 0)
13943 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13947 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13949 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13951 /* Write the .got section contents for the sake
13953 loc = got->contents + off;
13954 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13958 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13960 outrel.r_addend += relocation;
13961 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13962 outrel.r_addend -= htab->elf.tls_sec->vma;
13964 loc = relgot->contents;
13965 loc += (relgot->reloc_count++
13966 * sizeof (Elf64_External_Rela));
13967 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13970 /* Init the .got section contents here if we're not
13971 emitting a reloc. */
13974 relocation += addend;
13975 if (tls_type == (TLS_TLS | TLS_LD))
13977 else if (tls_type != 0)
13979 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13980 if (tls_type == (TLS_TLS | TLS_TPREL))
13981 relocation += DTP_OFFSET - TP_OFFSET;
13983 if (tls_type == (TLS_TLS | TLS_GD))
13985 bfd_put_64 (output_bfd, relocation,
13986 got->contents + off + 8);
13991 bfd_put_64 (output_bfd, relocation,
13992 got->contents + off);
13996 if (off >= (bfd_vma) -2)
13999 relocation = got->output_section->vma + got->output_offset + off;
14000 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14004 case R_PPC64_PLT16_HA:
14005 case R_PPC64_PLT16_HI:
14006 case R_PPC64_PLT16_LO:
14007 case R_PPC64_PLT32:
14008 case R_PPC64_PLT64:
14009 /* Relocation is to the entry for this symbol in the
14010 procedure linkage table. */
14012 /* Resolve a PLT reloc against a local symbol directly,
14013 without using the procedure linkage table. */
14017 /* It's possible that we didn't make a PLT entry for this
14018 symbol. This happens when statically linking PIC code,
14019 or when using -Bsymbolic. Go find a match if there is a
14021 if (htab->elf.splt != NULL)
14023 struct plt_entry *ent;
14024 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14025 if (ent->plt.offset != (bfd_vma) -1
14026 && ent->addend == orig_rel.r_addend)
14028 relocation = (htab->elf.splt->output_section->vma
14029 + htab->elf.splt->output_offset
14030 + ent->plt.offset);
14031 unresolved_reloc = FALSE;
14038 /* Relocation value is TOC base. */
14039 relocation = TOCstart;
14040 if (r_symndx == STN_UNDEF)
14041 relocation += htab->stub_group[input_section->id].toc_off;
14042 else if (unresolved_reloc)
14044 else if (sec != NULL && sec->id <= htab->top_id)
14045 relocation += htab->stub_group[sec->id].toc_off;
14047 unresolved_reloc = TRUE;
14050 /* TOC16 relocs. We want the offset relative to the TOC base,
14051 which is the address of the start of the TOC plus 0x8000.
14052 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14054 case R_PPC64_TOC16:
14055 case R_PPC64_TOC16_LO:
14056 case R_PPC64_TOC16_HI:
14057 case R_PPC64_TOC16_DS:
14058 case R_PPC64_TOC16_LO_DS:
14059 case R_PPC64_TOC16_HA:
14060 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14063 /* Relocate against the beginning of the section. */
14064 case R_PPC64_SECTOFF:
14065 case R_PPC64_SECTOFF_LO:
14066 case R_PPC64_SECTOFF_HI:
14067 case R_PPC64_SECTOFF_DS:
14068 case R_PPC64_SECTOFF_LO_DS:
14069 case R_PPC64_SECTOFF_HA:
14071 addend -= sec->output_section->vma;
14074 case R_PPC64_REL16:
14075 case R_PPC64_REL16_LO:
14076 case R_PPC64_REL16_HI:
14077 case R_PPC64_REL16_HA:
14080 case R_PPC64_REL14:
14081 case R_PPC64_REL14_BRNTAKEN:
14082 case R_PPC64_REL14_BRTAKEN:
14083 case R_PPC64_REL24:
14086 case R_PPC64_TPREL16:
14087 case R_PPC64_TPREL16_LO:
14088 case R_PPC64_TPREL16_HI:
14089 case R_PPC64_TPREL16_HA:
14090 case R_PPC64_TPREL16_DS:
14091 case R_PPC64_TPREL16_LO_DS:
14092 case R_PPC64_TPREL16_HIGH:
14093 case R_PPC64_TPREL16_HIGHA:
14094 case R_PPC64_TPREL16_HIGHER:
14095 case R_PPC64_TPREL16_HIGHERA:
14096 case R_PPC64_TPREL16_HIGHEST:
14097 case R_PPC64_TPREL16_HIGHESTA:
14099 && h->elf.root.type == bfd_link_hash_undefweak
14100 && h->elf.dynindx == -1)
14102 /* Make this relocation against an undefined weak symbol
14103 resolve to zero. This is really just a tweak, since
14104 code using weak externs ought to check that they are
14105 defined before using them. */
14106 bfd_byte *p = contents + rel->r_offset - d_offset;
14108 insn = bfd_get_32 (output_bfd, p);
14109 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14111 bfd_put_32 (output_bfd, insn, p);
14114 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14116 /* The TPREL16 relocs shouldn't really be used in shared
14117 libs as they will result in DT_TEXTREL being set, but
14118 support them anyway. */
14122 case R_PPC64_DTPREL16:
14123 case R_PPC64_DTPREL16_LO:
14124 case R_PPC64_DTPREL16_HI:
14125 case R_PPC64_DTPREL16_HA:
14126 case R_PPC64_DTPREL16_DS:
14127 case R_PPC64_DTPREL16_LO_DS:
14128 case R_PPC64_DTPREL16_HIGH:
14129 case R_PPC64_DTPREL16_HIGHA:
14130 case R_PPC64_DTPREL16_HIGHER:
14131 case R_PPC64_DTPREL16_HIGHERA:
14132 case R_PPC64_DTPREL16_HIGHEST:
14133 case R_PPC64_DTPREL16_HIGHESTA:
14134 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14137 case R_PPC64_DTPMOD64:
14142 case R_PPC64_TPREL64:
14143 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146 case R_PPC64_DTPREL64:
14147 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14150 /* Relocations that may need to be propagated if this is a
14152 case R_PPC64_REL30:
14153 case R_PPC64_REL32:
14154 case R_PPC64_REL64:
14155 case R_PPC64_ADDR14:
14156 case R_PPC64_ADDR14_BRNTAKEN:
14157 case R_PPC64_ADDR14_BRTAKEN:
14158 case R_PPC64_ADDR16:
14159 case R_PPC64_ADDR16_DS:
14160 case R_PPC64_ADDR16_HA:
14161 case R_PPC64_ADDR16_HI:
14162 case R_PPC64_ADDR16_HIGH:
14163 case R_PPC64_ADDR16_HIGHA:
14164 case R_PPC64_ADDR16_HIGHER:
14165 case R_PPC64_ADDR16_HIGHERA:
14166 case R_PPC64_ADDR16_HIGHEST:
14167 case R_PPC64_ADDR16_HIGHESTA:
14168 case R_PPC64_ADDR16_LO:
14169 case R_PPC64_ADDR16_LO_DS:
14170 case R_PPC64_ADDR24:
14171 case R_PPC64_ADDR32:
14172 case R_PPC64_ADDR64:
14173 case R_PPC64_UADDR16:
14174 case R_PPC64_UADDR32:
14175 case R_PPC64_UADDR64:
14177 if ((input_section->flags & SEC_ALLOC) == 0)
14180 if (NO_OPD_RELOCS && is_opd)
14185 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14186 || h->elf.root.type != bfd_link_hash_undefweak)
14187 && (must_be_dyn_reloc (info, r_type)
14188 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14189 || (ELIMINATE_COPY_RELOCS
14192 && h->elf.dynindx != -1
14193 && !h->elf.non_got_ref
14194 && !h->elf.def_regular)
14197 ? h->elf.type == STT_GNU_IFUNC
14198 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14200 bfd_boolean skip, relocate;
14204 /* When generating a dynamic object, these relocations
14205 are copied into the output file to be resolved at run
14211 out_off = _bfd_elf_section_offset (output_bfd, info,
14212 input_section, rel->r_offset);
14213 if (out_off == (bfd_vma) -1)
14215 else if (out_off == (bfd_vma) -2)
14216 skip = TRUE, relocate = TRUE;
14217 out_off += (input_section->output_section->vma
14218 + input_section->output_offset);
14219 outrel.r_offset = out_off;
14220 outrel.r_addend = rel->r_addend;
14222 /* Optimize unaligned reloc use. */
14223 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14224 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14225 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14226 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14227 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14228 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14229 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14230 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14231 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14234 memset (&outrel, 0, sizeof outrel);
14235 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14237 && r_type != R_PPC64_TOC)
14239 BFD_ASSERT (h->elf.dynindx != -1);
14240 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14244 /* This symbol is local, or marked to become local,
14245 or this is an opd section reloc which must point
14246 at a local function. */
14247 outrel.r_addend += relocation;
14248 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14250 if (is_opd && h != NULL)
14252 /* Lie about opd entries. This case occurs
14253 when building shared libraries and we
14254 reference a function in another shared
14255 lib. The same thing happens for a weak
14256 definition in an application that's
14257 overridden by a strong definition in a
14258 shared lib. (I believe this is a generic
14259 bug in binutils handling of weak syms.)
14260 In these cases we won't use the opd
14261 entry in this lib. */
14262 unresolved_reloc = FALSE;
14265 && r_type == R_PPC64_ADDR64
14267 ? h->elf.type == STT_GNU_IFUNC
14268 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14269 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14272 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14274 /* We need to relocate .opd contents for ld.so.
14275 Prelink also wants simple and consistent rules
14276 for relocs. This make all RELATIVE relocs have
14277 *r_offset equal to r_addend. */
14286 ? h->elf.type == STT_GNU_IFUNC
14287 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14289 info->callbacks->einfo
14290 (_("%P: %H: %s for indirect "
14291 "function `%T' unsupported\n"),
14292 input_bfd, input_section, rel->r_offset,
14293 ppc64_elf_howto_table[r_type]->name,
14297 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14299 else if (sec == NULL || sec->owner == NULL)
14301 bfd_set_error (bfd_error_bad_value);
14308 osec = sec->output_section;
14309 indx = elf_section_data (osec)->dynindx;
14313 if ((osec->flags & SEC_READONLY) == 0
14314 && htab->elf.data_index_section != NULL)
14315 osec = htab->elf.data_index_section;
14317 osec = htab->elf.text_index_section;
14318 indx = elf_section_data (osec)->dynindx;
14320 BFD_ASSERT (indx != 0);
14322 /* We are turning this relocation into one
14323 against a section symbol, so subtract out
14324 the output section's address but not the
14325 offset of the input section in the output
14327 outrel.r_addend -= osec->vma;
14330 outrel.r_info = ELF64_R_INFO (indx, r_type);
14334 sreloc = elf_section_data (input_section)->sreloc;
14336 ? h->elf.type == STT_GNU_IFUNC
14337 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14338 sreloc = htab->elf.irelplt;
14339 if (sreloc == NULL)
14342 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14345 loc = sreloc->contents;
14346 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14347 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14349 /* If this reloc is against an external symbol, it will
14350 be computed at runtime, so there's no need to do
14351 anything now. However, for the sake of prelink ensure
14352 that the section contents are a known value. */
14355 unresolved_reloc = FALSE;
14356 /* The value chosen here is quite arbitrary as ld.so
14357 ignores section contents except for the special
14358 case of .opd where the contents might be accessed
14359 before relocation. Choose zero, as that won't
14360 cause reloc overflow. */
14363 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14364 to improve backward compatibility with older
14366 if (r_type == R_PPC64_ADDR64)
14367 addend = outrel.r_addend;
14368 /* Adjust pc_relative relocs to have zero in *r_offset. */
14369 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14370 addend = (input_section->output_section->vma
14371 + input_section->output_offset
14378 case R_PPC64_GLOB_DAT:
14379 case R_PPC64_JMP_SLOT:
14380 case R_PPC64_JMP_IREL:
14381 case R_PPC64_RELATIVE:
14382 /* We shouldn't ever see these dynamic relocs in relocatable
14384 /* Fall through. */
14386 case R_PPC64_PLTGOT16:
14387 case R_PPC64_PLTGOT16_DS:
14388 case R_PPC64_PLTGOT16_HA:
14389 case R_PPC64_PLTGOT16_HI:
14390 case R_PPC64_PLTGOT16_LO:
14391 case R_PPC64_PLTGOT16_LO_DS:
14392 case R_PPC64_PLTREL32:
14393 case R_PPC64_PLTREL64:
14394 /* These ones haven't been implemented yet. */
14396 info->callbacks->einfo
14397 (_("%P: %B: %s is not supported for `%T'\n"),
14399 ppc64_elf_howto_table[r_type]->name, sym_name);
14401 bfd_set_error (bfd_error_invalid_operation);
14406 /* Multi-instruction sequences that access the TOC can be
14407 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14408 to nop; addi rb,r2,x; */
14414 case R_PPC64_GOT_TLSLD16_HI:
14415 case R_PPC64_GOT_TLSGD16_HI:
14416 case R_PPC64_GOT_TPREL16_HI:
14417 case R_PPC64_GOT_DTPREL16_HI:
14418 case R_PPC64_GOT16_HI:
14419 case R_PPC64_TOC16_HI:
14420 /* These relocs would only be useful if building up an
14421 offset to later add to r2, perhaps in an indexed
14422 addressing mode instruction. Don't try to optimize.
14423 Unfortunately, the possibility of someone building up an
14424 offset like this or even with the HA relocs, means that
14425 we need to check the high insn when optimizing the low
14429 case R_PPC64_GOT_TLSLD16_HA:
14430 case R_PPC64_GOT_TLSGD16_HA:
14431 case R_PPC64_GOT_TPREL16_HA:
14432 case R_PPC64_GOT_DTPREL16_HA:
14433 case R_PPC64_GOT16_HA:
14434 case R_PPC64_TOC16_HA:
14435 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14436 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14438 bfd_byte *p = contents + (rel->r_offset & ~3);
14439 bfd_put_32 (input_bfd, NOP, p);
14443 case R_PPC64_GOT_TLSLD16_LO:
14444 case R_PPC64_GOT_TLSGD16_LO:
14445 case R_PPC64_GOT_TPREL16_LO_DS:
14446 case R_PPC64_GOT_DTPREL16_LO_DS:
14447 case R_PPC64_GOT16_LO:
14448 case R_PPC64_GOT16_LO_DS:
14449 case R_PPC64_TOC16_LO:
14450 case R_PPC64_TOC16_LO_DS:
14451 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14452 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14454 bfd_byte *p = contents + (rel->r_offset & ~3);
14455 insn = bfd_get_32 (input_bfd, p);
14456 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14458 /* Transform addic to addi when we change reg. */
14459 insn &= ~((0x3f << 26) | (0x1f << 16));
14460 insn |= (14u << 26) | (2 << 16);
14464 insn &= ~(0x1f << 16);
14467 bfd_put_32 (input_bfd, insn, p);
14472 /* Do any further special processing. */
14478 case R_PPC64_REL16_HA:
14479 case R_PPC64_ADDR16_HA:
14480 case R_PPC64_ADDR16_HIGHA:
14481 case R_PPC64_ADDR16_HIGHERA:
14482 case R_PPC64_ADDR16_HIGHESTA:
14483 case R_PPC64_TOC16_HA:
14484 case R_PPC64_SECTOFF_HA:
14485 case R_PPC64_TPREL16_HA:
14486 case R_PPC64_TPREL16_HIGHA:
14487 case R_PPC64_TPREL16_HIGHERA:
14488 case R_PPC64_TPREL16_HIGHESTA:
14489 case R_PPC64_DTPREL16_HA:
14490 case R_PPC64_DTPREL16_HIGHA:
14491 case R_PPC64_DTPREL16_HIGHERA:
14492 case R_PPC64_DTPREL16_HIGHESTA:
14493 /* It's just possible that this symbol is a weak symbol
14494 that's not actually defined anywhere. In that case,
14495 'sec' would be NULL, and we should leave the symbol
14496 alone (it will be set to zero elsewhere in the link). */
14501 case R_PPC64_GOT16_HA:
14502 case R_PPC64_PLTGOT16_HA:
14503 case R_PPC64_PLT16_HA:
14504 case R_PPC64_GOT_TLSGD16_HA:
14505 case R_PPC64_GOT_TLSLD16_HA:
14506 case R_PPC64_GOT_TPREL16_HA:
14507 case R_PPC64_GOT_DTPREL16_HA:
14508 /* Add 0x10000 if sign bit in 0:15 is set.
14509 Bits 0:15 are not used. */
14513 case R_PPC64_ADDR16_DS:
14514 case R_PPC64_ADDR16_LO_DS:
14515 case R_PPC64_GOT16_DS:
14516 case R_PPC64_GOT16_LO_DS:
14517 case R_PPC64_PLT16_LO_DS:
14518 case R_PPC64_SECTOFF_DS:
14519 case R_PPC64_SECTOFF_LO_DS:
14520 case R_PPC64_TOC16_DS:
14521 case R_PPC64_TOC16_LO_DS:
14522 case R_PPC64_PLTGOT16_DS:
14523 case R_PPC64_PLTGOT16_LO_DS:
14524 case R_PPC64_GOT_TPREL16_DS:
14525 case R_PPC64_GOT_TPREL16_LO_DS:
14526 case R_PPC64_GOT_DTPREL16_DS:
14527 case R_PPC64_GOT_DTPREL16_LO_DS:
14528 case R_PPC64_TPREL16_DS:
14529 case R_PPC64_TPREL16_LO_DS:
14530 case R_PPC64_DTPREL16_DS:
14531 case R_PPC64_DTPREL16_LO_DS:
14532 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14534 /* If this reloc is against an lq insn, then the value must be
14535 a multiple of 16. This is somewhat of a hack, but the
14536 "correct" way to do this by defining _DQ forms of all the
14537 _DS relocs bloats all reloc switches in this file. It
14538 doesn't seem to make much sense to use any of these relocs
14539 in data, so testing the insn should be safe. */
14540 if ((insn & (0x3f << 26)) == (56u << 26))
14542 if (((relocation + addend) & mask) != 0)
14544 info->callbacks->einfo
14545 (_("%P: %H: error: %s not a multiple of %u\n"),
14546 input_bfd, input_section, rel->r_offset,
14547 ppc64_elf_howto_table[r_type]->name,
14549 bfd_set_error (bfd_error_bad_value);
14556 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14557 because such sections are not SEC_ALLOC and thus ld.so will
14558 not process them. */
14559 if (unresolved_reloc
14560 && !((input_section->flags & SEC_DEBUGGING) != 0
14561 && h->elf.def_dynamic)
14562 && _bfd_elf_section_offset (output_bfd, info, input_section,
14563 rel->r_offset) != (bfd_vma) -1)
14565 info->callbacks->einfo
14566 (_("%P: %H: unresolvable %s against `%T'\n"),
14567 input_bfd, input_section, rel->r_offset,
14568 ppc64_elf_howto_table[(int) r_type]->name,
14569 h->elf.root.root.string);
14573 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14581 if (r != bfd_reloc_ok)
14583 char *more_info = NULL;
14584 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14586 if (reloc_dest != DEST_NORMAL)
14588 more_info = bfd_malloc (strlen (reloc_name) + 8);
14589 if (more_info != NULL)
14591 strcpy (more_info, reloc_name);
14592 strcat (more_info, (reloc_dest == DEST_OPD
14593 ? " (OPD)" : " (stub)"));
14594 reloc_name = more_info;
14598 if (r == bfd_reloc_overflow)
14603 && h->elf.root.type == bfd_link_hash_undefweak
14604 && ppc64_elf_howto_table[r_type]->pc_relative)
14606 /* Assume this is a call protected by other code that
14607 detects the symbol is undefined. If this is the case,
14608 we can safely ignore the overflow. If not, the
14609 program is hosed anyway, and a little warning isn't
14615 if (!((*info->callbacks->reloc_overflow)
14616 (info, &h->elf.root, sym_name,
14617 reloc_name, orig_rel.r_addend,
14618 input_bfd, input_section, rel->r_offset)))
14623 info->callbacks->einfo
14624 (_("%P: %H: %s against `%T': error %d\n"),
14625 input_bfd, input_section, rel->r_offset,
14626 reloc_name, sym_name, (int) r);
14629 if (more_info != NULL)
14634 /* If we're emitting relocations, then shortly after this function
14635 returns, reloc offsets and addends for this section will be
14636 adjusted. Worse, reloc symbol indices will be for the output
14637 file rather than the input. Save a copy of the relocs for
14638 opd_entry_value. */
14639 if (is_opd && (info->emitrelocations || info->relocatable))
14642 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14643 rel = bfd_alloc (input_bfd, amt);
14644 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14645 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14648 memcpy (rel, relocs, amt);
14653 /* Adjust the value of any local symbols in opd sections. */
14656 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14657 const char *name ATTRIBUTE_UNUSED,
14658 Elf_Internal_Sym *elfsym,
14659 asection *input_sec,
14660 struct elf_link_hash_entry *h)
14662 struct _opd_sec_data *opd;
14669 opd = get_opd_info (input_sec);
14670 if (opd == NULL || opd->adjust == NULL)
14673 value = elfsym->st_value - input_sec->output_offset;
14674 if (!info->relocatable)
14675 value -= input_sec->output_section->vma;
14677 adjust = opd->adjust[value / 8];
14681 elfsym->st_value += adjust;
14685 /* Finish up dynamic symbol handling. We set the contents of various
14686 dynamic sections here. */
14689 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14690 struct bfd_link_info *info,
14691 struct elf_link_hash_entry *h,
14692 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14694 struct ppc_link_hash_table *htab;
14695 struct plt_entry *ent;
14696 Elf_Internal_Rela rela;
14699 htab = ppc_hash_table (info);
14703 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14704 if (ent->plt.offset != (bfd_vma) -1)
14706 /* This symbol has an entry in the procedure linkage
14707 table. Set it up. */
14708 if (!htab->elf.dynamic_sections_created
14709 || h->dynindx == -1)
14711 BFD_ASSERT (h->type == STT_GNU_IFUNC
14713 && (h->root.type == bfd_link_hash_defined
14714 || h->root.type == bfd_link_hash_defweak));
14715 rela.r_offset = (htab->elf.iplt->output_section->vma
14716 + htab->elf.iplt->output_offset
14717 + ent->plt.offset);
14719 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14721 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14722 rela.r_addend = (h->root.u.def.value
14723 + h->root.u.def.section->output_offset
14724 + h->root.u.def.section->output_section->vma
14726 loc = (htab->elf.irelplt->contents
14727 + (htab->elf.irelplt->reloc_count++
14728 * sizeof (Elf64_External_Rela)));
14732 rela.r_offset = (htab->elf.splt->output_section->vma
14733 + htab->elf.splt->output_offset
14734 + ent->plt.offset);
14735 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14736 rela.r_addend = ent->addend;
14737 loc = (htab->elf.srelplt->contents
14738 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14739 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14741 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14743 if (!htab->opd_abi)
14745 if (!h->def_regular)
14747 /* Mark the symbol as undefined, rather than as
14748 defined in glink. Leave the value if there were
14749 any relocations where pointer equality matters
14750 (this is a clue for the dynamic linker, to make
14751 function pointer comparisons work between an
14752 application and shared library), otherwise set it
14754 sym->st_shndx = SHN_UNDEF;
14755 if (!h->pointer_equality_needed)
14757 else if (!h->ref_regular_nonweak)
14759 /* This breaks function pointer comparisons, but
14760 that is better than breaking tests for a NULL
14761 function pointer. */
14770 /* This symbol needs a copy reloc. Set it up. */
14772 if (h->dynindx == -1
14773 || (h->root.type != bfd_link_hash_defined
14774 && h->root.type != bfd_link_hash_defweak)
14775 || htab->relbss == NULL)
14778 rela.r_offset = (h->root.u.def.value
14779 + h->root.u.def.section->output_section->vma
14780 + h->root.u.def.section->output_offset);
14781 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14783 loc = htab->relbss->contents;
14784 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14785 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14791 /* Used to decide how to sort relocs in an optimal manner for the
14792 dynamic linker, before writing them out. */
14794 static enum elf_reloc_type_class
14795 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14796 const asection *rel_sec,
14797 const Elf_Internal_Rela *rela)
14799 enum elf_ppc64_reloc_type r_type;
14800 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14802 if (rel_sec == htab->elf.irelplt)
14803 return reloc_class_ifunc;
14805 r_type = ELF64_R_TYPE (rela->r_info);
14808 case R_PPC64_RELATIVE:
14809 return reloc_class_relative;
14810 case R_PPC64_JMP_SLOT:
14811 return reloc_class_plt;
14813 return reloc_class_copy;
14815 return reloc_class_normal;
14819 /* Finish up the dynamic sections. */
14822 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14823 struct bfd_link_info *info)
14825 struct ppc_link_hash_table *htab;
14829 htab = ppc_hash_table (info);
14833 dynobj = htab->elf.dynobj;
14834 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14836 if (htab->elf.dynamic_sections_created)
14838 Elf64_External_Dyn *dyncon, *dynconend;
14840 if (sdyn == NULL || htab->elf.sgot == NULL)
14843 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14844 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14845 for (; dyncon < dynconend; dyncon++)
14847 Elf_Internal_Dyn dyn;
14850 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14857 case DT_PPC64_GLINK:
14859 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14860 /* We stupidly defined DT_PPC64_GLINK to be the start
14861 of glink rather than the first entry point, which is
14862 what ld.so needs, and now have a bigger stub to
14863 support automatic multiple TOCs. */
14864 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14868 s = bfd_get_section_by_name (output_bfd, ".opd");
14871 dyn.d_un.d_ptr = s->vma;
14875 if (htab->do_multi_toc && htab->multi_toc_needed)
14876 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14879 case DT_PPC64_OPDSZ:
14880 s = bfd_get_section_by_name (output_bfd, ".opd");
14883 dyn.d_un.d_val = s->size;
14887 s = htab->elf.splt;
14888 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14892 s = htab->elf.srelplt;
14893 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14897 dyn.d_un.d_val = htab->elf.srelplt->size;
14901 /* Don't count procedure linkage table relocs in the
14902 overall reloc count. */
14903 s = htab->elf.srelplt;
14906 dyn.d_un.d_val -= s->size;
14910 /* We may not be using the standard ELF linker script.
14911 If .rela.plt is the first .rela section, we adjust
14912 DT_RELA to not include it. */
14913 s = htab->elf.srelplt;
14916 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14918 dyn.d_un.d_ptr += s->size;
14922 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14926 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14928 /* Fill in the first entry in the global offset table.
14929 We use it to hold the link-time TOCbase. */
14930 bfd_put_64 (output_bfd,
14931 elf_gp (output_bfd) + TOC_BASE_OFF,
14932 htab->elf.sgot->contents);
14934 /* Set .got entry size. */
14935 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14938 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14940 /* Set .plt entry size. */
14941 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14942 = PLT_ENTRY_SIZE (htab);
14945 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14946 brlt ourselves if emitrelocations. */
14947 if (htab->brlt != NULL
14948 && htab->brlt->reloc_count != 0
14949 && !_bfd_elf_link_output_relocs (output_bfd,
14951 elf_section_data (htab->brlt)->rela.hdr,
14952 elf_section_data (htab->brlt)->relocs,
14956 if (htab->glink != NULL
14957 && htab->glink->reloc_count != 0
14958 && !_bfd_elf_link_output_relocs (output_bfd,
14960 elf_section_data (htab->glink)->rela.hdr,
14961 elf_section_data (htab->glink)->relocs,
14966 if (htab->glink_eh_frame != NULL
14967 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14968 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14969 htab->glink_eh_frame,
14970 htab->glink_eh_frame->contents))
14973 /* We need to handle writing out multiple GOT sections ourselves,
14974 since we didn't add them to DYNOBJ. We know dynobj is the first
14976 while ((dynobj = dynobj->link_next) != NULL)
14980 if (!is_ppc64_elf (dynobj))
14983 s = ppc64_elf_tdata (dynobj)->got;
14986 && s->output_section != bfd_abs_section_ptr
14987 && !bfd_set_section_contents (output_bfd, s->output_section,
14988 s->contents, s->output_offset,
14991 s = ppc64_elf_tdata (dynobj)->relgot;
14994 && s->output_section != bfd_abs_section_ptr
14995 && !bfd_set_section_contents (output_bfd, s->output_section,
14996 s->contents, s->output_offset,
15004 #include "elf64-target.h"
15006 /* FreeBSD support */
15008 #undef TARGET_LITTLE_SYM
15009 #undef TARGET_LITTLE_NAME
15011 #undef TARGET_BIG_SYM
15012 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15013 #undef TARGET_BIG_NAME
15014 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15017 #define ELF_OSABI ELFOSABI_FREEBSD
15020 #define elf64_bed elf64_powerpc_fbsd_bed
15022 #include "elf64-target.h"