1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2017 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_want_dynrelro 1
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_dtrel_excludes_plt 1
80 #define elf_backend_default_execstack 0
82 #define bfd_elf64_mkobject ppc64_elf_mkobject
83 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
84 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
85 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
86 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
87 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
88 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
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
91 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
93 #define elf_backend_object_p ppc64_elf_object_p
94 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
95 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
96 #define elf_backend_write_core_note ppc64_elf_write_core_note
97 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
98 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
99 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
100 #define elf_backend_check_directives ppc64_elf_before_check_relocs
101 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
102 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
103 #define elf_backend_check_relocs ppc64_elf_check_relocs
104 #define elf_backend_gc_keep ppc64_elf_gc_keep
105 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
106 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
107 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
108 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
109 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
110 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
111 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
112 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
113 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
114 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
115 #define elf_backend_action_discarded ppc64_elf_action_discarded
116 #define elf_backend_relocate_section ppc64_elf_relocate_section
117 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
118 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
119 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
120 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
121 #define elf_backend_special_sections ppc64_elf_special_sections
122 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
123 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
125 /* The name of the dynamic interpreter. This is put in the .interp
127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
129 /* The size in bytes of an entry in the procedure linkage table. */
130 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
132 /* The initial size of the plt reserved for the dynamic linker. */
133 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
135 /* Offsets to some stack save slots. */
137 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
138 /* This one is dodgy. ELFv2 does not have a linker word, so use the
139 CR save slot. Used only by optimised __tls_get_addr call stub,
140 relying on __tls_get_addr_opt not saving CR.. */
141 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
143 /* TOC base pointers offset from start of TOC. */
144 #define TOC_BASE_OFF 0x8000
145 /* TOC base alignment. */
146 #define TOC_BASE_ALIGN 256
148 /* Offset of tp and dtp pointers from start of TLS block. */
149 #define TP_OFFSET 0x7000
150 #define DTP_OFFSET 0x8000
152 /* .plt call stub instructions. The normal stub is like this, but
153 sometimes the .plt entry crosses a 64k boundary and we need to
154 insert an addi to adjust r11. */
155 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
156 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
157 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
158 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
159 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
160 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
161 #define BCTR 0x4e800420 /* bctr */
163 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
164 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
165 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
167 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
168 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
169 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
170 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
171 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
172 #define BNECTR 0x4ca20420 /* bnectr+ */
173 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
175 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
176 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
177 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
179 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
180 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
181 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
183 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
184 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
185 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
186 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
187 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
189 /* glink call stub instructions. We enter with the index in R0. */
190 #define GLINK_CALL_STUB_SIZE (16*4)
194 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
195 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
197 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
198 /* ld %2,(0b-1b)(%11) */
199 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
200 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
206 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
207 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
208 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
209 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
210 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
213 #define NOP 0x60000000
215 /* Some other nops. */
216 #define CROR_151515 0x4def7b82
217 #define CROR_313131 0x4ffffb82
219 /* .glink entries for the first 32k functions are two instructions. */
220 #define LI_R0_0 0x38000000 /* li %r0,0 */
221 #define B_DOT 0x48000000 /* b . */
223 /* After that, we need two instructions to load the index, followed by
225 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
226 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
228 /* Instructions used by the save and restore reg functions. */
229 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
230 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
231 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
232 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
233 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
234 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
235 #define LI_R12_0 0x39800000 /* li %r12,0 */
236 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
237 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
238 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
239 #define BLR 0x4e800020 /* blr */
241 /* Since .opd is an array of descriptors and each entry will end up
242 with identical R_PPC64_RELATIVE relocs, there is really no need to
243 propagate .opd relocs; The dynamic linker should be taught to
244 relocate .opd without reloc entries. */
245 #ifndef NO_OPD_RELOCS
246 #define NO_OPD_RELOCS 0
250 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
254 abiversion (bfd *abfd)
256 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
260 set_abiversion (bfd *abfd, int ver)
262 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
263 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
266 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
268 /* Relocation HOWTO's. */
269 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
271 static reloc_howto_type ppc64_elf_howto_raw[] = {
272 /* This reloc does nothing. */
273 HOWTO (R_PPC64_NONE, /* type */
275 3, /* size (0 = byte, 1 = short, 2 = long) */
277 FALSE, /* pc_relative */
279 complain_overflow_dont, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_PPC64_NONE", /* name */
282 FALSE, /* partial_inplace */
285 FALSE), /* pcrel_offset */
287 /* A standard 32 bit relocation. */
288 HOWTO (R_PPC64_ADDR32, /* type */
290 2, /* size (0 = byte, 1 = short, 2 = long) */
292 FALSE, /* pc_relative */
294 complain_overflow_bitfield, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_PPC64_ADDR32", /* name */
297 FALSE, /* partial_inplace */
299 0xffffffff, /* dst_mask */
300 FALSE), /* pcrel_offset */
302 /* An absolute 26 bit branch; the lower two bits must be zero.
303 FIXME: we don't check that, we just clear them. */
304 HOWTO (R_PPC64_ADDR24, /* type */
306 2, /* size (0 = byte, 1 = short, 2 = long) */
308 FALSE, /* pc_relative */
310 complain_overflow_bitfield, /* complain_on_overflow */
311 bfd_elf_generic_reloc, /* special_function */
312 "R_PPC64_ADDR24", /* name */
313 FALSE, /* partial_inplace */
315 0x03fffffc, /* dst_mask */
316 FALSE), /* pcrel_offset */
318 /* A standard 16 bit relocation. */
319 HOWTO (R_PPC64_ADDR16, /* type */
321 1, /* size (0 = byte, 1 = short, 2 = long) */
323 FALSE, /* pc_relative */
325 complain_overflow_bitfield, /* complain_on_overflow */
326 bfd_elf_generic_reloc, /* special_function */
327 "R_PPC64_ADDR16", /* name */
328 FALSE, /* partial_inplace */
330 0xffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
333 /* A 16 bit relocation without overflow. */
334 HOWTO (R_PPC64_ADDR16_LO, /* type */
336 1, /* size (0 = byte, 1 = short, 2 = long) */
338 FALSE, /* pc_relative */
340 complain_overflow_dont,/* complain_on_overflow */
341 bfd_elf_generic_reloc, /* special_function */
342 "R_PPC64_ADDR16_LO", /* name */
343 FALSE, /* partial_inplace */
345 0xffff, /* dst_mask */
346 FALSE), /* pcrel_offset */
348 /* Bits 16-31 of an address. */
349 HOWTO (R_PPC64_ADDR16_HI, /* type */
351 1, /* size (0 = byte, 1 = short, 2 = long) */
353 FALSE, /* pc_relative */
355 complain_overflow_signed, /* complain_on_overflow */
356 bfd_elf_generic_reloc, /* special_function */
357 "R_PPC64_ADDR16_HI", /* name */
358 FALSE, /* partial_inplace */
360 0xffff, /* dst_mask */
361 FALSE), /* pcrel_offset */
363 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
364 bits, treated as a signed number, is negative. */
365 HOWTO (R_PPC64_ADDR16_HA, /* type */
367 1, /* size (0 = byte, 1 = short, 2 = long) */
369 FALSE, /* pc_relative */
371 complain_overflow_signed, /* complain_on_overflow */
372 ppc64_elf_ha_reloc, /* special_function */
373 "R_PPC64_ADDR16_HA", /* name */
374 FALSE, /* partial_inplace */
376 0xffff, /* dst_mask */
377 FALSE), /* pcrel_offset */
379 /* An absolute 16 bit branch; the lower two bits must be zero.
380 FIXME: we don't check that, we just clear them. */
381 HOWTO (R_PPC64_ADDR14, /* type */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
385 FALSE, /* pc_relative */
387 complain_overflow_signed, /* complain_on_overflow */
388 ppc64_elf_branch_reloc, /* special_function */
389 "R_PPC64_ADDR14", /* name */
390 FALSE, /* partial_inplace */
392 0x0000fffc, /* dst_mask */
393 FALSE), /* pcrel_offset */
395 /* An absolute 16 bit branch, for which bit 10 should be set to
396 indicate that the branch is expected to be taken. The lower two
397 bits must be zero. */
398 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
400 2, /* size (0 = byte, 1 = short, 2 = long) */
402 FALSE, /* pc_relative */
404 complain_overflow_signed, /* complain_on_overflow */
405 ppc64_elf_brtaken_reloc, /* special_function */
406 "R_PPC64_ADDR14_BRTAKEN",/* name */
407 FALSE, /* partial_inplace */
409 0x0000fffc, /* dst_mask */
410 FALSE), /* pcrel_offset */
412 /* An absolute 16 bit branch, for which bit 10 should be set to
413 indicate that the branch is not expected to be taken. The lower
414 two bits must be zero. */
415 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
417 2, /* size (0 = byte, 1 = short, 2 = long) */
419 FALSE, /* pc_relative */
421 complain_overflow_signed, /* complain_on_overflow */
422 ppc64_elf_brtaken_reloc, /* special_function */
423 "R_PPC64_ADDR14_BRNTAKEN",/* name */
424 FALSE, /* partial_inplace */
426 0x0000fffc, /* dst_mask */
427 FALSE), /* pcrel_offset */
429 /* A relative 26 bit branch; the lower two bits must be zero. */
430 HOWTO (R_PPC64_REL24, /* type */
432 2, /* size (0 = byte, 1 = short, 2 = long) */
434 TRUE, /* pc_relative */
436 complain_overflow_signed, /* complain_on_overflow */
437 ppc64_elf_branch_reloc, /* special_function */
438 "R_PPC64_REL24", /* name */
439 FALSE, /* partial_inplace */
441 0x03fffffc, /* dst_mask */
442 TRUE), /* pcrel_offset */
444 /* A relative 16 bit branch; the lower two bits must be zero. */
445 HOWTO (R_PPC64_REL14, /* type */
447 2, /* size (0 = byte, 1 = short, 2 = long) */
449 TRUE, /* pc_relative */
451 complain_overflow_signed, /* complain_on_overflow */
452 ppc64_elf_branch_reloc, /* special_function */
453 "R_PPC64_REL14", /* name */
454 FALSE, /* partial_inplace */
456 0x0000fffc, /* dst_mask */
457 TRUE), /* pcrel_offset */
459 /* A relative 16 bit branch. Bit 10 should be set to indicate that
460 the branch is expected to be taken. The lower two bits must be
462 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
464 2, /* size (0 = byte, 1 = short, 2 = long) */
466 TRUE, /* pc_relative */
468 complain_overflow_signed, /* complain_on_overflow */
469 ppc64_elf_brtaken_reloc, /* special_function */
470 "R_PPC64_REL14_BRTAKEN", /* name */
471 FALSE, /* partial_inplace */
473 0x0000fffc, /* dst_mask */
474 TRUE), /* pcrel_offset */
476 /* A relative 16 bit branch. Bit 10 should be set to indicate that
477 the branch is not expected to be taken. The lower two bits must
479 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
481 2, /* size (0 = byte, 1 = short, 2 = long) */
483 TRUE, /* pc_relative */
485 complain_overflow_signed, /* complain_on_overflow */
486 ppc64_elf_brtaken_reloc, /* special_function */
487 "R_PPC64_REL14_BRNTAKEN",/* name */
488 FALSE, /* partial_inplace */
490 0x0000fffc, /* dst_mask */
491 TRUE), /* pcrel_offset */
493 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
495 HOWTO (R_PPC64_GOT16, /* type */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
499 FALSE, /* pc_relative */
501 complain_overflow_signed, /* complain_on_overflow */
502 ppc64_elf_unhandled_reloc, /* special_function */
503 "R_PPC64_GOT16", /* name */
504 FALSE, /* partial_inplace */
506 0xffff, /* dst_mask */
507 FALSE), /* pcrel_offset */
509 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
511 HOWTO (R_PPC64_GOT16_LO, /* type */
513 1, /* size (0 = byte, 1 = short, 2 = long) */
515 FALSE, /* pc_relative */
517 complain_overflow_dont, /* complain_on_overflow */
518 ppc64_elf_unhandled_reloc, /* special_function */
519 "R_PPC64_GOT16_LO", /* name */
520 FALSE, /* partial_inplace */
522 0xffff, /* dst_mask */
523 FALSE), /* pcrel_offset */
525 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
527 HOWTO (R_PPC64_GOT16_HI, /* type */
529 1, /* size (0 = byte, 1 = short, 2 = long) */
531 FALSE, /* pc_relative */
533 complain_overflow_signed,/* complain_on_overflow */
534 ppc64_elf_unhandled_reloc, /* special_function */
535 "R_PPC64_GOT16_HI", /* name */
536 FALSE, /* partial_inplace */
538 0xffff, /* dst_mask */
539 FALSE), /* pcrel_offset */
541 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
543 HOWTO (R_PPC64_GOT16_HA, /* type */
545 1, /* size (0 = byte, 1 = short, 2 = long) */
547 FALSE, /* pc_relative */
549 complain_overflow_signed,/* complain_on_overflow */
550 ppc64_elf_unhandled_reloc, /* special_function */
551 "R_PPC64_GOT16_HA", /* name */
552 FALSE, /* partial_inplace */
554 0xffff, /* dst_mask */
555 FALSE), /* pcrel_offset */
557 /* This is used only by the dynamic linker. The symbol should exist
558 both in the object being run and in some shared library. The
559 dynamic linker copies the data addressed by the symbol from the
560 shared library into the object, because the object being
561 run has to have the data at some particular address. */
562 HOWTO (R_PPC64_COPY, /* type */
564 0, /* this one is variable size */
566 FALSE, /* pc_relative */
568 complain_overflow_dont, /* complain_on_overflow */
569 ppc64_elf_unhandled_reloc, /* special_function */
570 "R_PPC64_COPY", /* name */
571 FALSE, /* partial_inplace */
574 FALSE), /* pcrel_offset */
576 /* Like R_PPC64_ADDR64, but used when setting global offset table
578 HOWTO (R_PPC64_GLOB_DAT, /* type */
580 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
582 FALSE, /* pc_relative */
584 complain_overflow_dont, /* complain_on_overflow */
585 ppc64_elf_unhandled_reloc, /* special_function */
586 "R_PPC64_GLOB_DAT", /* name */
587 FALSE, /* partial_inplace */
589 ONES (64), /* dst_mask */
590 FALSE), /* pcrel_offset */
592 /* Created by the link editor. Marks a procedure linkage table
593 entry for a symbol. */
594 HOWTO (R_PPC64_JMP_SLOT, /* type */
596 0, /* size (0 = byte, 1 = short, 2 = long) */
598 FALSE, /* pc_relative */
600 complain_overflow_dont, /* complain_on_overflow */
601 ppc64_elf_unhandled_reloc, /* special_function */
602 "R_PPC64_JMP_SLOT", /* name */
603 FALSE, /* partial_inplace */
606 FALSE), /* pcrel_offset */
608 /* Used only by the dynamic linker. When the object is run, this
609 doubleword64 is set to the load address of the object, plus the
611 HOWTO (R_PPC64_RELATIVE, /* type */
613 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
615 FALSE, /* pc_relative */
617 complain_overflow_dont, /* complain_on_overflow */
618 bfd_elf_generic_reloc, /* special_function */
619 "R_PPC64_RELATIVE", /* name */
620 FALSE, /* partial_inplace */
622 ONES (64), /* dst_mask */
623 FALSE), /* pcrel_offset */
625 /* Like R_PPC64_ADDR32, but may be unaligned. */
626 HOWTO (R_PPC64_UADDR32, /* type */
628 2, /* size (0 = byte, 1 = short, 2 = long) */
630 FALSE, /* pc_relative */
632 complain_overflow_bitfield, /* complain_on_overflow */
633 bfd_elf_generic_reloc, /* special_function */
634 "R_PPC64_UADDR32", /* name */
635 FALSE, /* partial_inplace */
637 0xffffffff, /* dst_mask */
638 FALSE), /* pcrel_offset */
640 /* Like R_PPC64_ADDR16, but may be unaligned. */
641 HOWTO (R_PPC64_UADDR16, /* type */
643 1, /* size (0 = byte, 1 = short, 2 = long) */
645 FALSE, /* pc_relative */
647 complain_overflow_bitfield, /* complain_on_overflow */
648 bfd_elf_generic_reloc, /* special_function */
649 "R_PPC64_UADDR16", /* name */
650 FALSE, /* partial_inplace */
652 0xffff, /* dst_mask */
653 FALSE), /* pcrel_offset */
655 /* 32-bit PC relative. */
656 HOWTO (R_PPC64_REL32, /* type */
658 2, /* size (0 = byte, 1 = short, 2 = long) */
660 TRUE, /* pc_relative */
662 complain_overflow_signed, /* complain_on_overflow */
663 bfd_elf_generic_reloc, /* special_function */
664 "R_PPC64_REL32", /* name */
665 FALSE, /* partial_inplace */
667 0xffffffff, /* dst_mask */
668 TRUE), /* pcrel_offset */
670 /* 32-bit relocation to the symbol's procedure linkage table. */
671 HOWTO (R_PPC64_PLT32, /* type */
673 2, /* size (0 = byte, 1 = short, 2 = long) */
675 FALSE, /* pc_relative */
677 complain_overflow_bitfield, /* complain_on_overflow */
678 ppc64_elf_unhandled_reloc, /* special_function */
679 "R_PPC64_PLT32", /* name */
680 FALSE, /* partial_inplace */
682 0xffffffff, /* dst_mask */
683 FALSE), /* pcrel_offset */
685 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
686 FIXME: R_PPC64_PLTREL32 not supported. */
687 HOWTO (R_PPC64_PLTREL32, /* type */
689 2, /* size (0 = byte, 1 = short, 2 = long) */
691 TRUE, /* pc_relative */
693 complain_overflow_signed, /* complain_on_overflow */
694 ppc64_elf_unhandled_reloc, /* special_function */
695 "R_PPC64_PLTREL32", /* name */
696 FALSE, /* partial_inplace */
698 0xffffffff, /* dst_mask */
699 TRUE), /* pcrel_offset */
701 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
703 HOWTO (R_PPC64_PLT16_LO, /* type */
705 1, /* size (0 = byte, 1 = short, 2 = long) */
707 FALSE, /* pc_relative */
709 complain_overflow_dont, /* complain_on_overflow */
710 ppc64_elf_unhandled_reloc, /* special_function */
711 "R_PPC64_PLT16_LO", /* name */
712 FALSE, /* partial_inplace */
714 0xffff, /* dst_mask */
715 FALSE), /* pcrel_offset */
717 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
719 HOWTO (R_PPC64_PLT16_HI, /* type */
721 1, /* size (0 = byte, 1 = short, 2 = long) */
723 FALSE, /* pc_relative */
725 complain_overflow_signed, /* complain_on_overflow */
726 ppc64_elf_unhandled_reloc, /* special_function */
727 "R_PPC64_PLT16_HI", /* name */
728 FALSE, /* partial_inplace */
730 0xffff, /* dst_mask */
731 FALSE), /* pcrel_offset */
733 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
735 HOWTO (R_PPC64_PLT16_HA, /* type */
737 1, /* size (0 = byte, 1 = short, 2 = long) */
739 FALSE, /* pc_relative */
741 complain_overflow_signed, /* complain_on_overflow */
742 ppc64_elf_unhandled_reloc, /* special_function */
743 "R_PPC64_PLT16_HA", /* name */
744 FALSE, /* partial_inplace */
746 0xffff, /* dst_mask */
747 FALSE), /* pcrel_offset */
749 /* 16-bit section relative relocation. */
750 HOWTO (R_PPC64_SECTOFF, /* type */
752 1, /* size (0 = byte, 1 = short, 2 = long) */
754 FALSE, /* pc_relative */
756 complain_overflow_signed, /* complain_on_overflow */
757 ppc64_elf_sectoff_reloc, /* special_function */
758 "R_PPC64_SECTOFF", /* name */
759 FALSE, /* partial_inplace */
761 0xffff, /* dst_mask */
762 FALSE), /* pcrel_offset */
764 /* Like R_PPC64_SECTOFF, but no overflow warning. */
765 HOWTO (R_PPC64_SECTOFF_LO, /* type */
767 1, /* size (0 = byte, 1 = short, 2 = long) */
769 FALSE, /* pc_relative */
771 complain_overflow_dont, /* complain_on_overflow */
772 ppc64_elf_sectoff_reloc, /* special_function */
773 "R_PPC64_SECTOFF_LO", /* name */
774 FALSE, /* partial_inplace */
776 0xffff, /* dst_mask */
777 FALSE), /* pcrel_offset */
779 /* 16-bit upper half section relative relocation. */
780 HOWTO (R_PPC64_SECTOFF_HI, /* type */
782 1, /* size (0 = byte, 1 = short, 2 = long) */
784 FALSE, /* pc_relative */
786 complain_overflow_signed, /* complain_on_overflow */
787 ppc64_elf_sectoff_reloc, /* special_function */
788 "R_PPC64_SECTOFF_HI", /* name */
789 FALSE, /* partial_inplace */
791 0xffff, /* dst_mask */
792 FALSE), /* pcrel_offset */
794 /* 16-bit upper half adjusted section relative relocation. */
795 HOWTO (R_PPC64_SECTOFF_HA, /* type */
797 1, /* size (0 = byte, 1 = short, 2 = long) */
799 FALSE, /* pc_relative */
801 complain_overflow_signed, /* complain_on_overflow */
802 ppc64_elf_sectoff_ha_reloc, /* special_function */
803 "R_PPC64_SECTOFF_HA", /* name */
804 FALSE, /* partial_inplace */
806 0xffff, /* dst_mask */
807 FALSE), /* pcrel_offset */
809 /* Like R_PPC64_REL24 without touching the two least significant bits. */
810 HOWTO (R_PPC64_REL30, /* type */
812 2, /* size (0 = byte, 1 = short, 2 = long) */
814 TRUE, /* pc_relative */
816 complain_overflow_dont, /* complain_on_overflow */
817 bfd_elf_generic_reloc, /* special_function */
818 "R_PPC64_REL30", /* name */
819 FALSE, /* partial_inplace */
821 0xfffffffc, /* dst_mask */
822 TRUE), /* pcrel_offset */
824 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
826 /* A standard 64-bit relocation. */
827 HOWTO (R_PPC64_ADDR64, /* type */
829 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
831 FALSE, /* pc_relative */
833 complain_overflow_dont, /* complain_on_overflow */
834 bfd_elf_generic_reloc, /* special_function */
835 "R_PPC64_ADDR64", /* name */
836 FALSE, /* partial_inplace */
838 ONES (64), /* dst_mask */
839 FALSE), /* pcrel_offset */
841 /* The bits 32-47 of an address. */
842 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
844 1, /* size (0 = byte, 1 = short, 2 = long) */
846 FALSE, /* pc_relative */
848 complain_overflow_dont, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_PPC64_ADDR16_HIGHER", /* name */
851 FALSE, /* partial_inplace */
853 0xffff, /* dst_mask */
854 FALSE), /* pcrel_offset */
856 /* The bits 32-47 of an address, plus 1 if the contents of the low
857 16 bits, treated as a signed number, is negative. */
858 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
860 1, /* size (0 = byte, 1 = short, 2 = long) */
862 FALSE, /* pc_relative */
864 complain_overflow_dont, /* complain_on_overflow */
865 ppc64_elf_ha_reloc, /* special_function */
866 "R_PPC64_ADDR16_HIGHERA", /* name */
867 FALSE, /* partial_inplace */
869 0xffff, /* dst_mask */
870 FALSE), /* pcrel_offset */
872 /* The bits 48-63 of an address. */
873 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
875 1, /* size (0 = byte, 1 = short, 2 = long) */
877 FALSE, /* pc_relative */
879 complain_overflow_dont, /* complain_on_overflow */
880 bfd_elf_generic_reloc, /* special_function */
881 "R_PPC64_ADDR16_HIGHEST", /* name */
882 FALSE, /* partial_inplace */
884 0xffff, /* dst_mask */
885 FALSE), /* pcrel_offset */
887 /* The bits 48-63 of an address, plus 1 if the contents of the low
888 16 bits, treated as a signed number, is negative. */
889 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
891 1, /* size (0 = byte, 1 = short, 2 = long) */
893 FALSE, /* pc_relative */
895 complain_overflow_dont, /* complain_on_overflow */
896 ppc64_elf_ha_reloc, /* special_function */
897 "R_PPC64_ADDR16_HIGHESTA", /* name */
898 FALSE, /* partial_inplace */
900 0xffff, /* dst_mask */
901 FALSE), /* pcrel_offset */
903 /* Like ADDR64, but may be unaligned. */
904 HOWTO (R_PPC64_UADDR64, /* type */
906 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
908 FALSE, /* pc_relative */
910 complain_overflow_dont, /* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_PPC64_UADDR64", /* name */
913 FALSE, /* partial_inplace */
915 ONES (64), /* dst_mask */
916 FALSE), /* pcrel_offset */
918 /* 64-bit relative relocation. */
919 HOWTO (R_PPC64_REL64, /* type */
921 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
923 TRUE, /* pc_relative */
925 complain_overflow_dont, /* complain_on_overflow */
926 bfd_elf_generic_reloc, /* special_function */
927 "R_PPC64_REL64", /* name */
928 FALSE, /* partial_inplace */
930 ONES (64), /* dst_mask */
931 TRUE), /* pcrel_offset */
933 /* 64-bit relocation to the symbol's procedure linkage table. */
934 HOWTO (R_PPC64_PLT64, /* type */
936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
938 FALSE, /* pc_relative */
940 complain_overflow_dont, /* complain_on_overflow */
941 ppc64_elf_unhandled_reloc, /* special_function */
942 "R_PPC64_PLT64", /* name */
943 FALSE, /* partial_inplace */
945 ONES (64), /* dst_mask */
946 FALSE), /* pcrel_offset */
948 /* 64-bit PC relative relocation to the symbol's procedure linkage
950 /* FIXME: R_PPC64_PLTREL64 not supported. */
951 HOWTO (R_PPC64_PLTREL64, /* type */
953 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
955 TRUE, /* pc_relative */
957 complain_overflow_dont, /* complain_on_overflow */
958 ppc64_elf_unhandled_reloc, /* special_function */
959 "R_PPC64_PLTREL64", /* name */
960 FALSE, /* partial_inplace */
962 ONES (64), /* dst_mask */
963 TRUE), /* pcrel_offset */
965 /* 16 bit TOC-relative relocation. */
967 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
968 HOWTO (R_PPC64_TOC16, /* type */
970 1, /* size (0 = byte, 1 = short, 2 = long) */
972 FALSE, /* pc_relative */
974 complain_overflow_signed, /* complain_on_overflow */
975 ppc64_elf_toc_reloc, /* special_function */
976 "R_PPC64_TOC16", /* name */
977 FALSE, /* partial_inplace */
979 0xffff, /* dst_mask */
980 FALSE), /* pcrel_offset */
982 /* 16 bit TOC-relative relocation without overflow. */
984 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
985 HOWTO (R_PPC64_TOC16_LO, /* type */
987 1, /* size (0 = byte, 1 = short, 2 = long) */
989 FALSE, /* pc_relative */
991 complain_overflow_dont, /* complain_on_overflow */
992 ppc64_elf_toc_reloc, /* special_function */
993 "R_PPC64_TOC16_LO", /* name */
994 FALSE, /* partial_inplace */
996 0xffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
999 /* 16 bit TOC-relative relocation, high 16 bits. */
1001 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1002 HOWTO (R_PPC64_TOC16_HI, /* type */
1003 16, /* rightshift */
1004 1, /* size (0 = byte, 1 = short, 2 = long) */
1006 FALSE, /* pc_relative */
1008 complain_overflow_signed, /* complain_on_overflow */
1009 ppc64_elf_toc_reloc, /* special_function */
1010 "R_PPC64_TOC16_HI", /* name */
1011 FALSE, /* partial_inplace */
1013 0xffff, /* dst_mask */
1014 FALSE), /* pcrel_offset */
1016 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1017 contents of the low 16 bits, treated as a signed number, is
1020 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1021 HOWTO (R_PPC64_TOC16_HA, /* type */
1022 16, /* rightshift */
1023 1, /* size (0 = byte, 1 = short, 2 = long) */
1025 FALSE, /* pc_relative */
1027 complain_overflow_signed, /* complain_on_overflow */
1028 ppc64_elf_toc_ha_reloc, /* special_function */
1029 "R_PPC64_TOC16_HA", /* name */
1030 FALSE, /* partial_inplace */
1032 0xffff, /* dst_mask */
1033 FALSE), /* pcrel_offset */
1035 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1037 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1038 HOWTO (R_PPC64_TOC, /* type */
1040 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042 FALSE, /* pc_relative */
1044 complain_overflow_dont, /* complain_on_overflow */
1045 ppc64_elf_toc64_reloc, /* special_function */
1046 "R_PPC64_TOC", /* name */
1047 FALSE, /* partial_inplace */
1049 ONES (64), /* dst_mask */
1050 FALSE), /* pcrel_offset */
1052 /* Like R_PPC64_GOT16, but also informs the link editor that the
1053 value to relocate may (!) refer to a PLT entry which the link
1054 editor (a) may replace with the symbol value. If the link editor
1055 is unable to fully resolve the symbol, it may (b) create a PLT
1056 entry and store the address to the new PLT entry in the GOT.
1057 This permits lazy resolution of function symbols at run time.
1058 The link editor may also skip all of this and just (c) emit a
1059 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1060 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1061 HOWTO (R_PPC64_PLTGOT16, /* type */
1063 1, /* size (0 = byte, 1 = short, 2 = long) */
1065 FALSE, /* pc_relative */
1067 complain_overflow_signed, /* complain_on_overflow */
1068 ppc64_elf_unhandled_reloc, /* special_function */
1069 "R_PPC64_PLTGOT16", /* name */
1070 FALSE, /* partial_inplace */
1072 0xffff, /* dst_mask */
1073 FALSE), /* pcrel_offset */
1075 /* Like R_PPC64_PLTGOT16, but without overflow. */
1076 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1077 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1079 1, /* size (0 = byte, 1 = short, 2 = long) */
1081 FALSE, /* pc_relative */
1083 complain_overflow_dont, /* complain_on_overflow */
1084 ppc64_elf_unhandled_reloc, /* special_function */
1085 "R_PPC64_PLTGOT16_LO", /* name */
1086 FALSE, /* partial_inplace */
1088 0xffff, /* dst_mask */
1089 FALSE), /* pcrel_offset */
1091 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1092 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1093 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1094 16, /* rightshift */
1095 1, /* size (0 = byte, 1 = short, 2 = long) */
1097 FALSE, /* pc_relative */
1099 complain_overflow_signed, /* complain_on_overflow */
1100 ppc64_elf_unhandled_reloc, /* special_function */
1101 "R_PPC64_PLTGOT16_HI", /* name */
1102 FALSE, /* partial_inplace */
1104 0xffff, /* dst_mask */
1105 FALSE), /* pcrel_offset */
1107 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1108 1 if the contents of the low 16 bits, treated as a signed number,
1110 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1111 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1112 16, /* rightshift */
1113 1, /* size (0 = byte, 1 = short, 2 = long) */
1115 FALSE, /* pc_relative */
1117 complain_overflow_signed, /* complain_on_overflow */
1118 ppc64_elf_unhandled_reloc, /* special_function */
1119 "R_PPC64_PLTGOT16_HA", /* name */
1120 FALSE, /* partial_inplace */
1122 0xffff, /* dst_mask */
1123 FALSE), /* pcrel_offset */
1125 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1126 HOWTO (R_PPC64_ADDR16_DS, /* type */
1128 1, /* size (0 = byte, 1 = short, 2 = long) */
1130 FALSE, /* pc_relative */
1132 complain_overflow_signed, /* complain_on_overflow */
1133 bfd_elf_generic_reloc, /* special_function */
1134 "R_PPC64_ADDR16_DS", /* name */
1135 FALSE, /* partial_inplace */
1137 0xfffc, /* dst_mask */
1138 FALSE), /* pcrel_offset */
1140 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1141 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1143 1, /* size (0 = byte, 1 = short, 2 = long) */
1145 FALSE, /* pc_relative */
1147 complain_overflow_dont,/* complain_on_overflow */
1148 bfd_elf_generic_reloc, /* special_function */
1149 "R_PPC64_ADDR16_LO_DS",/* name */
1150 FALSE, /* partial_inplace */
1152 0xfffc, /* dst_mask */
1153 FALSE), /* pcrel_offset */
1155 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1156 HOWTO (R_PPC64_GOT16_DS, /* type */
1158 1, /* size (0 = byte, 1 = short, 2 = long) */
1160 FALSE, /* pc_relative */
1162 complain_overflow_signed, /* complain_on_overflow */
1163 ppc64_elf_unhandled_reloc, /* special_function */
1164 "R_PPC64_GOT16_DS", /* name */
1165 FALSE, /* partial_inplace */
1167 0xfffc, /* dst_mask */
1168 FALSE), /* pcrel_offset */
1170 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1171 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1173 1, /* size (0 = byte, 1 = short, 2 = long) */
1175 FALSE, /* pc_relative */
1177 complain_overflow_dont, /* complain_on_overflow */
1178 ppc64_elf_unhandled_reloc, /* special_function */
1179 "R_PPC64_GOT16_LO_DS", /* name */
1180 FALSE, /* partial_inplace */
1182 0xfffc, /* dst_mask */
1183 FALSE), /* pcrel_offset */
1185 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1186 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1188 1, /* size (0 = byte, 1 = short, 2 = long) */
1190 FALSE, /* pc_relative */
1192 complain_overflow_dont, /* complain_on_overflow */
1193 ppc64_elf_unhandled_reloc, /* special_function */
1194 "R_PPC64_PLT16_LO_DS", /* name */
1195 FALSE, /* partial_inplace */
1197 0xfffc, /* dst_mask */
1198 FALSE), /* pcrel_offset */
1200 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1201 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1203 1, /* size (0 = byte, 1 = short, 2 = long) */
1205 FALSE, /* pc_relative */
1207 complain_overflow_signed, /* complain_on_overflow */
1208 ppc64_elf_sectoff_reloc, /* special_function */
1209 "R_PPC64_SECTOFF_DS", /* name */
1210 FALSE, /* partial_inplace */
1212 0xfffc, /* dst_mask */
1213 FALSE), /* pcrel_offset */
1215 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1216 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218 1, /* size (0 = byte, 1 = short, 2 = long) */
1220 FALSE, /* pc_relative */
1222 complain_overflow_dont, /* complain_on_overflow */
1223 ppc64_elf_sectoff_reloc, /* special_function */
1224 "R_PPC64_SECTOFF_LO_DS",/* name */
1225 FALSE, /* partial_inplace */
1227 0xfffc, /* dst_mask */
1228 FALSE), /* pcrel_offset */
1230 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1231 HOWTO (R_PPC64_TOC16_DS, /* type */
1233 1, /* size (0 = byte, 1 = short, 2 = long) */
1235 FALSE, /* pc_relative */
1237 complain_overflow_signed, /* complain_on_overflow */
1238 ppc64_elf_toc_reloc, /* special_function */
1239 "R_PPC64_TOC16_DS", /* name */
1240 FALSE, /* partial_inplace */
1242 0xfffc, /* dst_mask */
1243 FALSE), /* pcrel_offset */
1245 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1246 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1248 1, /* size (0 = byte, 1 = short, 2 = long) */
1250 FALSE, /* pc_relative */
1252 complain_overflow_dont, /* complain_on_overflow */
1253 ppc64_elf_toc_reloc, /* special_function */
1254 "R_PPC64_TOC16_LO_DS", /* name */
1255 FALSE, /* partial_inplace */
1257 0xfffc, /* dst_mask */
1258 FALSE), /* pcrel_offset */
1260 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1261 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1262 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1264 1, /* size (0 = byte, 1 = short, 2 = long) */
1266 FALSE, /* pc_relative */
1268 complain_overflow_signed, /* complain_on_overflow */
1269 ppc64_elf_unhandled_reloc, /* special_function */
1270 "R_PPC64_PLTGOT16_DS", /* name */
1271 FALSE, /* partial_inplace */
1273 0xfffc, /* dst_mask */
1274 FALSE), /* pcrel_offset */
1276 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1277 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1278 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280 1, /* size (0 = byte, 1 = short, 2 = long) */
1282 FALSE, /* pc_relative */
1284 complain_overflow_dont, /* complain_on_overflow */
1285 ppc64_elf_unhandled_reloc, /* special_function */
1286 "R_PPC64_PLTGOT16_LO_DS",/* name */
1287 FALSE, /* partial_inplace */
1289 0xfffc, /* dst_mask */
1290 FALSE), /* pcrel_offset */
1292 /* Marker relocs for TLS. */
1295 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 FALSE, /* pc_relative */
1299 complain_overflow_dont, /* complain_on_overflow */
1300 bfd_elf_generic_reloc, /* special_function */
1301 "R_PPC64_TLS", /* name */
1302 FALSE, /* partial_inplace */
1305 FALSE), /* pcrel_offset */
1307 HOWTO (R_PPC64_TLSGD,
1309 2, /* size (0 = byte, 1 = short, 2 = long) */
1311 FALSE, /* pc_relative */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 bfd_elf_generic_reloc, /* special_function */
1315 "R_PPC64_TLSGD", /* name */
1316 FALSE, /* partial_inplace */
1319 FALSE), /* pcrel_offset */
1321 HOWTO (R_PPC64_TLSLD,
1323 2, /* size (0 = byte, 1 = short, 2 = long) */
1325 FALSE, /* pc_relative */
1327 complain_overflow_dont, /* complain_on_overflow */
1328 bfd_elf_generic_reloc, /* special_function */
1329 "R_PPC64_TLSLD", /* name */
1330 FALSE, /* partial_inplace */
1333 FALSE), /* pcrel_offset */
1335 HOWTO (R_PPC64_TOCSAVE,
1337 2, /* size (0 = byte, 1 = short, 2 = long) */
1339 FALSE, /* pc_relative */
1341 complain_overflow_dont, /* complain_on_overflow */
1342 bfd_elf_generic_reloc, /* special_function */
1343 "R_PPC64_TOCSAVE", /* name */
1344 FALSE, /* partial_inplace */
1347 FALSE), /* pcrel_offset */
1349 /* Computes the load module index of the load module that contains the
1350 definition of its TLS sym. */
1351 HOWTO (R_PPC64_DTPMOD64,
1353 4, /* size (0 = byte, 1 = short, 2 = long) */
1355 FALSE, /* pc_relative */
1357 complain_overflow_dont, /* complain_on_overflow */
1358 ppc64_elf_unhandled_reloc, /* special_function */
1359 "R_PPC64_DTPMOD64", /* name */
1360 FALSE, /* partial_inplace */
1362 ONES (64), /* dst_mask */
1363 FALSE), /* pcrel_offset */
1365 /* Computes a dtv-relative displacement, the difference between the value
1366 of sym+add and the base address of the thread-local storage block that
1367 contains the definition of sym, minus 0x8000. */
1368 HOWTO (R_PPC64_DTPREL64,
1370 4, /* size (0 = byte, 1 = short, 2 = long) */
1372 FALSE, /* pc_relative */
1374 complain_overflow_dont, /* complain_on_overflow */
1375 ppc64_elf_unhandled_reloc, /* special_function */
1376 "R_PPC64_DTPREL64", /* name */
1377 FALSE, /* partial_inplace */
1379 ONES (64), /* dst_mask */
1380 FALSE), /* pcrel_offset */
1382 /* A 16 bit dtprel reloc. */
1383 HOWTO (R_PPC64_DTPREL16,
1385 1, /* size (0 = byte, 1 = short, 2 = long) */
1387 FALSE, /* pc_relative */
1389 complain_overflow_signed, /* complain_on_overflow */
1390 ppc64_elf_unhandled_reloc, /* special_function */
1391 "R_PPC64_DTPREL16", /* name */
1392 FALSE, /* partial_inplace */
1394 0xffff, /* dst_mask */
1395 FALSE), /* pcrel_offset */
1397 /* Like DTPREL16, but no overflow. */
1398 HOWTO (R_PPC64_DTPREL16_LO,
1400 1, /* size (0 = byte, 1 = short, 2 = long) */
1402 FALSE, /* pc_relative */
1404 complain_overflow_dont, /* complain_on_overflow */
1405 ppc64_elf_unhandled_reloc, /* special_function */
1406 "R_PPC64_DTPREL16_LO", /* name */
1407 FALSE, /* partial_inplace */
1409 0xffff, /* dst_mask */
1410 FALSE), /* pcrel_offset */
1412 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1413 HOWTO (R_PPC64_DTPREL16_HI,
1414 16, /* rightshift */
1415 1, /* size (0 = byte, 1 = short, 2 = long) */
1417 FALSE, /* pc_relative */
1419 complain_overflow_signed, /* complain_on_overflow */
1420 ppc64_elf_unhandled_reloc, /* special_function */
1421 "R_PPC64_DTPREL16_HI", /* name */
1422 FALSE, /* partial_inplace */
1424 0xffff, /* dst_mask */
1425 FALSE), /* pcrel_offset */
1427 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1428 HOWTO (R_PPC64_DTPREL16_HA,
1429 16, /* rightshift */
1430 1, /* size (0 = byte, 1 = short, 2 = long) */
1432 FALSE, /* pc_relative */
1434 complain_overflow_signed, /* complain_on_overflow */
1435 ppc64_elf_unhandled_reloc, /* special_function */
1436 "R_PPC64_DTPREL16_HA", /* name */
1437 FALSE, /* partial_inplace */
1439 0xffff, /* dst_mask */
1440 FALSE), /* pcrel_offset */
1442 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1443 HOWTO (R_PPC64_DTPREL16_HIGHER,
1444 32, /* rightshift */
1445 1, /* size (0 = byte, 1 = short, 2 = long) */
1447 FALSE, /* pc_relative */
1449 complain_overflow_dont, /* complain_on_overflow */
1450 ppc64_elf_unhandled_reloc, /* special_function */
1451 "R_PPC64_DTPREL16_HIGHER", /* name */
1452 FALSE, /* partial_inplace */
1454 0xffff, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1457 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1458 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1459 32, /* rightshift */
1460 1, /* size (0 = byte, 1 = short, 2 = long) */
1462 FALSE, /* pc_relative */
1464 complain_overflow_dont, /* complain_on_overflow */
1465 ppc64_elf_unhandled_reloc, /* special_function */
1466 "R_PPC64_DTPREL16_HIGHERA", /* name */
1467 FALSE, /* partial_inplace */
1469 0xffff, /* dst_mask */
1470 FALSE), /* pcrel_offset */
1472 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1473 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1474 48, /* rightshift */
1475 1, /* size (0 = byte, 1 = short, 2 = long) */
1477 FALSE, /* pc_relative */
1479 complain_overflow_dont, /* complain_on_overflow */
1480 ppc64_elf_unhandled_reloc, /* special_function */
1481 "R_PPC64_DTPREL16_HIGHEST", /* name */
1482 FALSE, /* partial_inplace */
1484 0xffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1487 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1488 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1489 48, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1492 FALSE, /* pc_relative */
1494 complain_overflow_dont, /* complain_on_overflow */
1495 ppc64_elf_unhandled_reloc, /* special_function */
1496 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1497 FALSE, /* partial_inplace */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1502 /* Like DTPREL16, but for insns with a DS field. */
1503 HOWTO (R_PPC64_DTPREL16_DS,
1505 1, /* size (0 = byte, 1 = short, 2 = long) */
1507 FALSE, /* pc_relative */
1509 complain_overflow_signed, /* complain_on_overflow */
1510 ppc64_elf_unhandled_reloc, /* special_function */
1511 "R_PPC64_DTPREL16_DS", /* name */
1512 FALSE, /* partial_inplace */
1514 0xfffc, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1517 /* Like DTPREL16_DS, but no overflow. */
1518 HOWTO (R_PPC64_DTPREL16_LO_DS,
1520 1, /* size (0 = byte, 1 = short, 2 = long) */
1522 FALSE, /* pc_relative */
1524 complain_overflow_dont, /* complain_on_overflow */
1525 ppc64_elf_unhandled_reloc, /* special_function */
1526 "R_PPC64_DTPREL16_LO_DS", /* name */
1527 FALSE, /* partial_inplace */
1529 0xfffc, /* dst_mask */
1530 FALSE), /* pcrel_offset */
1532 /* Computes a tp-relative displacement, the difference between the value of
1533 sym+add and the value of the thread pointer (r13). */
1534 HOWTO (R_PPC64_TPREL64,
1536 4, /* size (0 = byte, 1 = short, 2 = long) */
1538 FALSE, /* pc_relative */
1540 complain_overflow_dont, /* complain_on_overflow */
1541 ppc64_elf_unhandled_reloc, /* special_function */
1542 "R_PPC64_TPREL64", /* name */
1543 FALSE, /* partial_inplace */
1545 ONES (64), /* dst_mask */
1546 FALSE), /* pcrel_offset */
1548 /* A 16 bit tprel reloc. */
1549 HOWTO (R_PPC64_TPREL16,
1551 1, /* size (0 = byte, 1 = short, 2 = long) */
1553 FALSE, /* pc_relative */
1555 complain_overflow_signed, /* complain_on_overflow */
1556 ppc64_elf_unhandled_reloc, /* special_function */
1557 "R_PPC64_TPREL16", /* name */
1558 FALSE, /* partial_inplace */
1560 0xffff, /* dst_mask */
1561 FALSE), /* pcrel_offset */
1563 /* Like TPREL16, but no overflow. */
1564 HOWTO (R_PPC64_TPREL16_LO,
1566 1, /* size (0 = byte, 1 = short, 2 = long) */
1568 FALSE, /* pc_relative */
1570 complain_overflow_dont, /* complain_on_overflow */
1571 ppc64_elf_unhandled_reloc, /* special_function */
1572 "R_PPC64_TPREL16_LO", /* name */
1573 FALSE, /* partial_inplace */
1575 0xffff, /* dst_mask */
1576 FALSE), /* pcrel_offset */
1578 /* Like TPREL16_LO, but next higher group of 16 bits. */
1579 HOWTO (R_PPC64_TPREL16_HI,
1580 16, /* rightshift */
1581 1, /* size (0 = byte, 1 = short, 2 = long) */
1583 FALSE, /* pc_relative */
1585 complain_overflow_signed, /* complain_on_overflow */
1586 ppc64_elf_unhandled_reloc, /* special_function */
1587 "R_PPC64_TPREL16_HI", /* name */
1588 FALSE, /* partial_inplace */
1590 0xffff, /* dst_mask */
1591 FALSE), /* pcrel_offset */
1593 /* Like TPREL16_HI, but adjust for low 16 bits. */
1594 HOWTO (R_PPC64_TPREL16_HA,
1595 16, /* rightshift */
1596 1, /* size (0 = byte, 1 = short, 2 = long) */
1598 FALSE, /* pc_relative */
1600 complain_overflow_signed, /* complain_on_overflow */
1601 ppc64_elf_unhandled_reloc, /* special_function */
1602 "R_PPC64_TPREL16_HA", /* name */
1603 FALSE, /* partial_inplace */
1605 0xffff, /* dst_mask */
1606 FALSE), /* pcrel_offset */
1608 /* Like TPREL16_HI, but next higher group of 16 bits. */
1609 HOWTO (R_PPC64_TPREL16_HIGHER,
1610 32, /* rightshift */
1611 1, /* size (0 = byte, 1 = short, 2 = long) */
1613 FALSE, /* pc_relative */
1615 complain_overflow_dont, /* complain_on_overflow */
1616 ppc64_elf_unhandled_reloc, /* special_function */
1617 "R_PPC64_TPREL16_HIGHER", /* name */
1618 FALSE, /* partial_inplace */
1620 0xffff, /* dst_mask */
1621 FALSE), /* pcrel_offset */
1623 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1624 HOWTO (R_PPC64_TPREL16_HIGHERA,
1625 32, /* rightshift */
1626 1, /* size (0 = byte, 1 = short, 2 = long) */
1628 FALSE, /* pc_relative */
1630 complain_overflow_dont, /* complain_on_overflow */
1631 ppc64_elf_unhandled_reloc, /* special_function */
1632 "R_PPC64_TPREL16_HIGHERA", /* name */
1633 FALSE, /* partial_inplace */
1635 0xffff, /* dst_mask */
1636 FALSE), /* pcrel_offset */
1638 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1639 HOWTO (R_PPC64_TPREL16_HIGHEST,
1640 48, /* rightshift */
1641 1, /* size (0 = byte, 1 = short, 2 = long) */
1643 FALSE, /* pc_relative */
1645 complain_overflow_dont, /* complain_on_overflow */
1646 ppc64_elf_unhandled_reloc, /* special_function */
1647 "R_PPC64_TPREL16_HIGHEST", /* name */
1648 FALSE, /* partial_inplace */
1650 0xffff, /* dst_mask */
1651 FALSE), /* pcrel_offset */
1653 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1654 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1655 48, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 FALSE, /* pc_relative */
1660 complain_overflow_dont, /* complain_on_overflow */
1661 ppc64_elf_unhandled_reloc, /* special_function */
1662 "R_PPC64_TPREL16_HIGHESTA", /* name */
1663 FALSE, /* partial_inplace */
1665 0xffff, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1668 /* Like TPREL16, but for insns with a DS field. */
1669 HOWTO (R_PPC64_TPREL16_DS,
1671 1, /* size (0 = byte, 1 = short, 2 = long) */
1673 FALSE, /* pc_relative */
1675 complain_overflow_signed, /* complain_on_overflow */
1676 ppc64_elf_unhandled_reloc, /* special_function */
1677 "R_PPC64_TPREL16_DS", /* name */
1678 FALSE, /* partial_inplace */
1680 0xfffc, /* dst_mask */
1681 FALSE), /* pcrel_offset */
1683 /* Like TPREL16_DS, but no overflow. */
1684 HOWTO (R_PPC64_TPREL16_LO_DS,
1686 1, /* size (0 = byte, 1 = short, 2 = long) */
1688 FALSE, /* pc_relative */
1690 complain_overflow_dont, /* complain_on_overflow */
1691 ppc64_elf_unhandled_reloc, /* special_function */
1692 "R_PPC64_TPREL16_LO_DS", /* name */
1693 FALSE, /* partial_inplace */
1695 0xfffc, /* dst_mask */
1696 FALSE), /* pcrel_offset */
1698 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1699 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1700 to the first entry relative to the TOC base (r2). */
1701 HOWTO (R_PPC64_GOT_TLSGD16,
1703 1, /* size (0 = byte, 1 = short, 2 = long) */
1705 FALSE, /* pc_relative */
1707 complain_overflow_signed, /* complain_on_overflow */
1708 ppc64_elf_unhandled_reloc, /* special_function */
1709 "R_PPC64_GOT_TLSGD16", /* name */
1710 FALSE, /* partial_inplace */
1712 0xffff, /* dst_mask */
1713 FALSE), /* pcrel_offset */
1715 /* Like GOT_TLSGD16, but no overflow. */
1716 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1718 1, /* size (0 = byte, 1 = short, 2 = long) */
1720 FALSE, /* pc_relative */
1722 complain_overflow_dont, /* complain_on_overflow */
1723 ppc64_elf_unhandled_reloc, /* special_function */
1724 "R_PPC64_GOT_TLSGD16_LO", /* name */
1725 FALSE, /* partial_inplace */
1727 0xffff, /* dst_mask */
1728 FALSE), /* pcrel_offset */
1730 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1731 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1732 16, /* rightshift */
1733 1, /* size (0 = byte, 1 = short, 2 = long) */
1735 FALSE, /* pc_relative */
1737 complain_overflow_signed, /* complain_on_overflow */
1738 ppc64_elf_unhandled_reloc, /* special_function */
1739 "R_PPC64_GOT_TLSGD16_HI", /* name */
1740 FALSE, /* partial_inplace */
1742 0xffff, /* dst_mask */
1743 FALSE), /* pcrel_offset */
1745 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1746 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1747 16, /* rightshift */
1748 1, /* size (0 = byte, 1 = short, 2 = long) */
1750 FALSE, /* pc_relative */
1752 complain_overflow_signed, /* complain_on_overflow */
1753 ppc64_elf_unhandled_reloc, /* special_function */
1754 "R_PPC64_GOT_TLSGD16_HA", /* name */
1755 FALSE, /* partial_inplace */
1757 0xffff, /* dst_mask */
1758 FALSE), /* pcrel_offset */
1760 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1761 with values (sym+add)@dtpmod and zero, and computes the offset to the
1762 first entry relative to the TOC base (r2). */
1763 HOWTO (R_PPC64_GOT_TLSLD16,
1765 1, /* size (0 = byte, 1 = short, 2 = long) */
1767 FALSE, /* pc_relative */
1769 complain_overflow_signed, /* complain_on_overflow */
1770 ppc64_elf_unhandled_reloc, /* special_function */
1771 "R_PPC64_GOT_TLSLD16", /* name */
1772 FALSE, /* partial_inplace */
1774 0xffff, /* dst_mask */
1775 FALSE), /* pcrel_offset */
1777 /* Like GOT_TLSLD16, but no overflow. */
1778 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1780 1, /* size (0 = byte, 1 = short, 2 = long) */
1782 FALSE, /* pc_relative */
1784 complain_overflow_dont, /* complain_on_overflow */
1785 ppc64_elf_unhandled_reloc, /* special_function */
1786 "R_PPC64_GOT_TLSLD16_LO", /* name */
1787 FALSE, /* partial_inplace */
1789 0xffff, /* dst_mask */
1790 FALSE), /* pcrel_offset */
1792 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1793 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1794 16, /* rightshift */
1795 1, /* size (0 = byte, 1 = short, 2 = long) */
1797 FALSE, /* pc_relative */
1799 complain_overflow_signed, /* complain_on_overflow */
1800 ppc64_elf_unhandled_reloc, /* special_function */
1801 "R_PPC64_GOT_TLSLD16_HI", /* name */
1802 FALSE, /* partial_inplace */
1804 0xffff, /* dst_mask */
1805 FALSE), /* pcrel_offset */
1807 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1808 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1809 16, /* rightshift */
1810 1, /* size (0 = byte, 1 = short, 2 = long) */
1812 FALSE, /* pc_relative */
1814 complain_overflow_signed, /* complain_on_overflow */
1815 ppc64_elf_unhandled_reloc, /* special_function */
1816 "R_PPC64_GOT_TLSLD16_HA", /* name */
1817 FALSE, /* partial_inplace */
1819 0xffff, /* dst_mask */
1820 FALSE), /* pcrel_offset */
1822 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1823 the offset to the entry relative to the TOC base (r2). */
1824 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1826 1, /* size (0 = byte, 1 = short, 2 = long) */
1828 FALSE, /* pc_relative */
1830 complain_overflow_signed, /* complain_on_overflow */
1831 ppc64_elf_unhandled_reloc, /* special_function */
1832 "R_PPC64_GOT_DTPREL16_DS", /* name */
1833 FALSE, /* partial_inplace */
1835 0xfffc, /* dst_mask */
1836 FALSE), /* pcrel_offset */
1838 /* Like GOT_DTPREL16_DS, but no overflow. */
1839 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1841 1, /* size (0 = byte, 1 = short, 2 = long) */
1843 FALSE, /* pc_relative */
1845 complain_overflow_dont, /* complain_on_overflow */
1846 ppc64_elf_unhandled_reloc, /* special_function */
1847 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1848 FALSE, /* partial_inplace */
1850 0xfffc, /* dst_mask */
1851 FALSE), /* pcrel_offset */
1853 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1854 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1855 16, /* rightshift */
1856 1, /* size (0 = byte, 1 = short, 2 = long) */
1858 FALSE, /* pc_relative */
1860 complain_overflow_signed, /* complain_on_overflow */
1861 ppc64_elf_unhandled_reloc, /* special_function */
1862 "R_PPC64_GOT_DTPREL16_HI", /* name */
1863 FALSE, /* partial_inplace */
1865 0xffff, /* dst_mask */
1866 FALSE), /* pcrel_offset */
1868 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1869 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1870 16, /* rightshift */
1871 1, /* size (0 = byte, 1 = short, 2 = long) */
1873 FALSE, /* pc_relative */
1875 complain_overflow_signed, /* complain_on_overflow */
1876 ppc64_elf_unhandled_reloc, /* special_function */
1877 "R_PPC64_GOT_DTPREL16_HA", /* name */
1878 FALSE, /* partial_inplace */
1880 0xffff, /* dst_mask */
1881 FALSE), /* pcrel_offset */
1883 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1884 offset to the entry relative to the TOC base (r2). */
1885 HOWTO (R_PPC64_GOT_TPREL16_DS,
1887 1, /* size (0 = byte, 1 = short, 2 = long) */
1889 FALSE, /* pc_relative */
1891 complain_overflow_signed, /* complain_on_overflow */
1892 ppc64_elf_unhandled_reloc, /* special_function */
1893 "R_PPC64_GOT_TPREL16_DS", /* name */
1894 FALSE, /* partial_inplace */
1896 0xfffc, /* dst_mask */
1897 FALSE), /* pcrel_offset */
1899 /* Like GOT_TPREL16_DS, but no overflow. */
1900 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1902 1, /* size (0 = byte, 1 = short, 2 = long) */
1904 FALSE, /* pc_relative */
1906 complain_overflow_dont, /* complain_on_overflow */
1907 ppc64_elf_unhandled_reloc, /* special_function */
1908 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1909 FALSE, /* partial_inplace */
1911 0xfffc, /* dst_mask */
1912 FALSE), /* pcrel_offset */
1914 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1915 HOWTO (R_PPC64_GOT_TPREL16_HI,
1916 16, /* rightshift */
1917 1, /* size (0 = byte, 1 = short, 2 = long) */
1919 FALSE, /* pc_relative */
1921 complain_overflow_signed, /* complain_on_overflow */
1922 ppc64_elf_unhandled_reloc, /* special_function */
1923 "R_PPC64_GOT_TPREL16_HI", /* name */
1924 FALSE, /* partial_inplace */
1926 0xffff, /* dst_mask */
1927 FALSE), /* pcrel_offset */
1929 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1930 HOWTO (R_PPC64_GOT_TPREL16_HA,
1931 16, /* rightshift */
1932 1, /* size (0 = byte, 1 = short, 2 = long) */
1934 FALSE, /* pc_relative */
1936 complain_overflow_signed, /* complain_on_overflow */
1937 ppc64_elf_unhandled_reloc, /* special_function */
1938 "R_PPC64_GOT_TPREL16_HA", /* name */
1939 FALSE, /* partial_inplace */
1941 0xffff, /* dst_mask */
1942 FALSE), /* pcrel_offset */
1944 HOWTO (R_PPC64_JMP_IREL, /* type */
1946 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948 FALSE, /* pc_relative */
1950 complain_overflow_dont, /* complain_on_overflow */
1951 ppc64_elf_unhandled_reloc, /* special_function */
1952 "R_PPC64_JMP_IREL", /* name */
1953 FALSE, /* partial_inplace */
1956 FALSE), /* pcrel_offset */
1958 HOWTO (R_PPC64_IRELATIVE, /* type */
1960 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962 FALSE, /* pc_relative */
1964 complain_overflow_dont, /* complain_on_overflow */
1965 bfd_elf_generic_reloc, /* special_function */
1966 "R_PPC64_IRELATIVE", /* name */
1967 FALSE, /* partial_inplace */
1969 ONES (64), /* dst_mask */
1970 FALSE), /* pcrel_offset */
1972 /* A 16 bit relative relocation. */
1973 HOWTO (R_PPC64_REL16, /* type */
1975 1, /* size (0 = byte, 1 = short, 2 = long) */
1977 TRUE, /* pc_relative */
1979 complain_overflow_signed, /* complain_on_overflow */
1980 bfd_elf_generic_reloc, /* special_function */
1981 "R_PPC64_REL16", /* name */
1982 FALSE, /* partial_inplace */
1984 0xffff, /* dst_mask */
1985 TRUE), /* pcrel_offset */
1987 /* A 16 bit relative relocation without overflow. */
1988 HOWTO (R_PPC64_REL16_LO, /* type */
1990 1, /* size (0 = byte, 1 = short, 2 = long) */
1992 TRUE, /* pc_relative */
1994 complain_overflow_dont,/* complain_on_overflow */
1995 bfd_elf_generic_reloc, /* special_function */
1996 "R_PPC64_REL16_LO", /* name */
1997 FALSE, /* partial_inplace */
1999 0xffff, /* dst_mask */
2000 TRUE), /* pcrel_offset */
2002 /* The high order 16 bits of a relative address. */
2003 HOWTO (R_PPC64_REL16_HI, /* type */
2004 16, /* rightshift */
2005 1, /* size (0 = byte, 1 = short, 2 = long) */
2007 TRUE, /* pc_relative */
2009 complain_overflow_signed, /* complain_on_overflow */
2010 bfd_elf_generic_reloc, /* special_function */
2011 "R_PPC64_REL16_HI", /* name */
2012 FALSE, /* partial_inplace */
2014 0xffff, /* dst_mask */
2015 TRUE), /* pcrel_offset */
2017 /* The high order 16 bits of a relative address, plus 1 if the contents of
2018 the low 16 bits, treated as a signed number, is negative. */
2019 HOWTO (R_PPC64_REL16_HA, /* type */
2020 16, /* rightshift */
2021 1, /* size (0 = byte, 1 = short, 2 = long) */
2023 TRUE, /* pc_relative */
2025 complain_overflow_signed, /* complain_on_overflow */
2026 ppc64_elf_ha_reloc, /* special_function */
2027 "R_PPC64_REL16_HA", /* name */
2028 FALSE, /* partial_inplace */
2030 0xffff, /* dst_mask */
2031 TRUE), /* pcrel_offset */
2033 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2034 HOWTO (R_PPC64_REL16DX_HA, /* type */
2035 16, /* rightshift */
2036 2, /* size (0 = byte, 1 = short, 2 = long) */
2038 TRUE, /* pc_relative */
2040 complain_overflow_signed, /* complain_on_overflow */
2041 ppc64_elf_ha_reloc, /* special_function */
2042 "R_PPC64_REL16DX_HA", /* name */
2043 FALSE, /* partial_inplace */
2045 0x1fffc1, /* dst_mask */
2046 TRUE), /* pcrel_offset */
2048 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2049 HOWTO (R_PPC64_16DX_HA, /* type */
2050 16, /* rightshift */
2051 2, /* size (0 = byte, 1 = short, 2 = long) */
2053 FALSE, /* pc_relative */
2055 complain_overflow_signed, /* complain_on_overflow */
2056 ppc64_elf_ha_reloc, /* special_function */
2057 "R_PPC64_16DX_HA", /* name */
2058 FALSE, /* partial_inplace */
2060 0x1fffc1, /* dst_mask */
2061 FALSE), /* pcrel_offset */
2063 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2064 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2065 16, /* rightshift */
2066 1, /* size (0 = byte, 1 = short, 2 = long) */
2068 FALSE, /* pc_relative */
2070 complain_overflow_dont, /* complain_on_overflow */
2071 bfd_elf_generic_reloc, /* special_function */
2072 "R_PPC64_ADDR16_HIGH", /* name */
2073 FALSE, /* partial_inplace */
2075 0xffff, /* dst_mask */
2076 FALSE), /* pcrel_offset */
2078 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2079 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2080 16, /* rightshift */
2081 1, /* size (0 = byte, 1 = short, 2 = long) */
2083 FALSE, /* pc_relative */
2085 complain_overflow_dont, /* complain_on_overflow */
2086 ppc64_elf_ha_reloc, /* special_function */
2087 "R_PPC64_ADDR16_HIGHA", /* name */
2088 FALSE, /* partial_inplace */
2090 0xffff, /* dst_mask */
2091 FALSE), /* pcrel_offset */
2093 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2094 HOWTO (R_PPC64_DTPREL16_HIGH,
2095 16, /* rightshift */
2096 1, /* size (0 = byte, 1 = short, 2 = long) */
2098 FALSE, /* pc_relative */
2100 complain_overflow_dont, /* complain_on_overflow */
2101 ppc64_elf_unhandled_reloc, /* special_function */
2102 "R_PPC64_DTPREL16_HIGH", /* name */
2103 FALSE, /* partial_inplace */
2105 0xffff, /* dst_mask */
2106 FALSE), /* pcrel_offset */
2108 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2109 HOWTO (R_PPC64_DTPREL16_HIGHA,
2110 16, /* rightshift */
2111 1, /* size (0 = byte, 1 = short, 2 = long) */
2113 FALSE, /* pc_relative */
2115 complain_overflow_dont, /* complain_on_overflow */
2116 ppc64_elf_unhandled_reloc, /* special_function */
2117 "R_PPC64_DTPREL16_HIGHA", /* name */
2118 FALSE, /* partial_inplace */
2120 0xffff, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2123 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2124 HOWTO (R_PPC64_TPREL16_HIGH,
2125 16, /* rightshift */
2126 1, /* size (0 = byte, 1 = short, 2 = long) */
2128 FALSE, /* pc_relative */
2130 complain_overflow_dont, /* complain_on_overflow */
2131 ppc64_elf_unhandled_reloc, /* special_function */
2132 "R_PPC64_TPREL16_HIGH", /* name */
2133 FALSE, /* partial_inplace */
2135 0xffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2138 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2139 HOWTO (R_PPC64_TPREL16_HIGHA,
2140 16, /* rightshift */
2141 1, /* size (0 = byte, 1 = short, 2 = long) */
2143 FALSE, /* pc_relative */
2145 complain_overflow_dont, /* complain_on_overflow */
2146 ppc64_elf_unhandled_reloc, /* special_function */
2147 "R_PPC64_TPREL16_HIGHA", /* name */
2148 FALSE, /* partial_inplace */
2150 0xffff, /* dst_mask */
2151 FALSE), /* pcrel_offset */
2153 /* Marker reloc on ELFv2 large-model function entry. */
2154 HOWTO (R_PPC64_ENTRY,
2156 2, /* size (0 = byte, 1 = short, 2 = long) */
2158 FALSE, /* pc_relative */
2160 complain_overflow_dont, /* complain_on_overflow */
2161 bfd_elf_generic_reloc, /* special_function */
2162 "R_PPC64_ENTRY", /* name */
2163 FALSE, /* partial_inplace */
2166 FALSE), /* pcrel_offset */
2168 /* Like ADDR64, but use local entry point of function. */
2169 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2171 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173 FALSE, /* pc_relative */
2175 complain_overflow_dont, /* complain_on_overflow */
2176 bfd_elf_generic_reloc, /* special_function */
2177 "R_PPC64_ADDR64_LOCAL", /* name */
2178 FALSE, /* partial_inplace */
2180 ONES (64), /* dst_mask */
2181 FALSE), /* pcrel_offset */
2183 /* GNU extension to record C++ vtable hierarchy. */
2184 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186 0, /* size (0 = byte, 1 = short, 2 = long) */
2188 FALSE, /* pc_relative */
2190 complain_overflow_dont, /* complain_on_overflow */
2191 NULL, /* special_function */
2192 "R_PPC64_GNU_VTINHERIT", /* name */
2193 FALSE, /* partial_inplace */
2196 FALSE), /* pcrel_offset */
2198 /* GNU extension to record C++ vtable member usage. */
2199 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2201 0, /* size (0 = byte, 1 = short, 2 = long) */
2203 FALSE, /* pc_relative */
2205 complain_overflow_dont, /* complain_on_overflow */
2206 NULL, /* special_function */
2207 "R_PPC64_GNU_VTENTRY", /* name */
2208 FALSE, /* partial_inplace */
2211 FALSE), /* pcrel_offset */
2215 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2219 ppc_howto_init (void)
2221 unsigned int i, type;
2223 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2225 type = ppc64_elf_howto_raw[i].type;
2226 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2227 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2231 static reloc_howto_type *
2232 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2233 bfd_reloc_code_real_type code)
2235 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2237 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2238 /* Initialize howto table if needed. */
2246 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2248 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2250 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2252 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2254 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2256 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2258 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2260 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2262 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2264 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2266 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2268 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2270 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2272 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2274 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2276 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2278 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2280 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2282 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2284 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2286 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2288 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2290 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2292 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2294 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2296 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2298 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2300 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2302 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2304 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2306 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2308 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2310 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2312 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2314 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2316 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2318 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2320 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2322 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2324 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2326 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2328 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2330 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2332 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2334 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2336 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2338 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2340 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2342 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2344 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2346 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2348 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2350 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2352 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2354 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2356 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2358 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2360 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2362 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2364 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2366 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2368 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2370 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2372 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2374 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2376 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2378 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2380 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2382 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2384 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2386 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2388 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2390 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2392 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2394 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2396 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2398 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2400 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2402 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2404 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2406 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2408 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2410 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2412 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2414 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2416 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2418 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2420 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2422 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2424 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2426 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2428 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2430 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2432 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2434 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2436 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2438 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2440 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2442 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2444 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2446 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2448 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2450 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2452 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2454 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2456 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2458 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2460 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2462 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2464 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2466 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2468 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2470 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2472 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2474 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2476 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2478 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2482 return ppc64_elf_howto_table[r];
2485 static reloc_howto_type *
2486 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2491 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2492 if (ppc64_elf_howto_raw[i].name != NULL
2493 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2494 return &ppc64_elf_howto_raw[i];
2499 /* Set the howto pointer for a PowerPC ELF reloc. */
2502 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2503 Elf_Internal_Rela *dst)
2507 /* Initialize howto table if needed. */
2508 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2511 type = ELF64_R_TYPE (dst->r_info);
2512 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2514 /* xgettext:c-format */
2515 _bfd_error_handler (_("%B: invalid relocation type %d"),
2517 type = R_PPC64_NONE;
2519 cache_ptr->howto = ppc64_elf_howto_table[type];
2522 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2524 static bfd_reloc_status_type
2525 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526 void *data, asection *input_section,
2527 bfd *output_bfd, char **error_message)
2529 enum elf_ppc64_reloc_type r_type;
2531 bfd_size_type octets;
2534 /* If this is a relocatable link (output_bfd test tells us), just
2535 call the generic function. Any adjustment will be done at final
2537 if (output_bfd != NULL)
2538 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2539 input_section, output_bfd, error_message);
2541 /* Adjust the addend for sign extension of the low 16 bits.
2542 We won't actually be using the low 16 bits, so trashing them
2544 reloc_entry->addend += 0x8000;
2545 r_type = reloc_entry->howto->type;
2546 if (r_type != R_PPC64_REL16DX_HA)
2547 return bfd_reloc_continue;
2550 if (!bfd_is_com_section (symbol->section))
2551 value = symbol->value;
2552 value += (reloc_entry->addend
2553 + symbol->section->output_offset
2554 + symbol->section->output_section->vma);
2555 value -= (reloc_entry->address
2556 + input_section->output_offset
2557 + input_section->output_section->vma);
2558 value = (bfd_signed_vma) value >> 16;
2560 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2561 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2564 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2565 if (value + 0x8000 > 0xffff)
2566 return bfd_reloc_overflow;
2567 return bfd_reloc_ok;
2570 static bfd_reloc_status_type
2571 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2572 void *data, asection *input_section,
2573 bfd *output_bfd, char **error_message)
2575 if (output_bfd != NULL)
2576 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2577 input_section, output_bfd, error_message);
2579 if (strcmp (symbol->section->name, ".opd") == 0
2580 && (symbol->section->owner->flags & DYNAMIC) == 0)
2582 bfd_vma dest = opd_entry_value (symbol->section,
2583 symbol->value + reloc_entry->addend,
2585 if (dest != (bfd_vma) -1)
2586 reloc_entry->addend = dest - (symbol->value
2587 + symbol->section->output_section->vma
2588 + symbol->section->output_offset);
2592 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594 if (symbol->section->owner != abfd
2595 && symbol->section->owner != NULL
2596 && abiversion (symbol->section->owner) >= 2)
2600 for (i = 0; i < symbol->section->owner->symcount; ++i)
2602 asymbol *symdef = symbol->section->owner->outsymbols[i];
2604 if (strcmp (symdef->name, symbol->name) == 0)
2606 elfsym = (elf_symbol_type *) symdef;
2612 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614 return bfd_reloc_continue;
2617 static bfd_reloc_status_type
2618 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619 void *data, asection *input_section,
2620 bfd *output_bfd, char **error_message)
2623 enum elf_ppc64_reloc_type r_type;
2624 bfd_size_type octets;
2625 /* Assume 'at' branch hints. */
2626 bfd_boolean is_isa_v2 = TRUE;
2628 /* If this is a relocatable link (output_bfd test tells us), just
2629 call the generic function. Any adjustment will be done at final
2631 if (output_bfd != NULL)
2632 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2633 input_section, output_bfd, error_message);
2635 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2636 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2637 insn &= ~(0x01 << 21);
2638 r_type = reloc_entry->howto->type;
2639 if (r_type == R_PPC64_ADDR14_BRTAKEN
2640 || r_type == R_PPC64_REL14_BRTAKEN)
2641 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2645 /* Set 'a' bit. This is 0b00010 in BO field for branch
2646 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2647 for branch on CTR insns (BO == 1a00t or 1a01t). */
2648 if ((insn & (0x14 << 21)) == (0x04 << 21))
2650 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2660 if (!bfd_is_com_section (symbol->section))
2661 target = symbol->value;
2662 target += symbol->section->output_section->vma;
2663 target += symbol->section->output_offset;
2664 target += reloc_entry->addend;
2666 from = (reloc_entry->address
2667 + input_section->output_offset
2668 + input_section->output_section->vma);
2670 /* Invert 'y' bit if not the default. */
2671 if ((bfd_signed_vma) (target - from) < 0)
2674 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2676 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2677 input_section, output_bfd, error_message);
2680 static bfd_reloc_status_type
2681 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2682 void *data, asection *input_section,
2683 bfd *output_bfd, char **error_message)
2685 /* If this is a relocatable link (output_bfd test tells us), just
2686 call the generic function. Any adjustment will be done at final
2688 if (output_bfd != NULL)
2689 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2690 input_section, output_bfd, error_message);
2692 /* Subtract the symbol section base address. */
2693 reloc_entry->addend -= symbol->section->output_section->vma;
2694 return bfd_reloc_continue;
2697 static bfd_reloc_status_type
2698 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699 void *data, asection *input_section,
2700 bfd *output_bfd, char **error_message)
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2709 /* Subtract the symbol section base address. */
2710 reloc_entry->addend -= symbol->section->output_section->vma;
2712 /* Adjust the addend for sign extension of the low 16 bits. */
2713 reloc_entry->addend += 0x8000;
2714 return bfd_reloc_continue;
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719 void *data, asection *input_section,
2720 bfd *output_bfd, char **error_message)
2724 /* If this is a relocatable link (output_bfd test tells us), just
2725 call the generic function. Any adjustment will be done at final
2727 if (output_bfd != NULL)
2728 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729 input_section, output_bfd, error_message);
2731 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735 /* Subtract the TOC base address. */
2736 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737 return bfd_reloc_continue;
2740 static bfd_reloc_status_type
2741 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2742 void *data, asection *input_section,
2743 bfd *output_bfd, char **error_message)
2747 /* If this is a relocatable link (output_bfd test tells us), just
2748 call the generic function. Any adjustment will be done at final
2750 if (output_bfd != NULL)
2751 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2752 input_section, output_bfd, error_message);
2754 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2758 /* Subtract the TOC base address. */
2759 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761 /* Adjust the addend for sign extension of the low 16 bits. */
2762 reloc_entry->addend += 0x8000;
2763 return bfd_reloc_continue;
2766 static bfd_reloc_status_type
2767 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2768 void *data, asection *input_section,
2769 bfd *output_bfd, char **error_message)
2772 bfd_size_type octets;
2774 /* If this is a relocatable link (output_bfd test tells us), just
2775 call the generic function. Any adjustment will be done at final
2777 if (output_bfd != NULL)
2778 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779 input_section, output_bfd, error_message);
2781 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2785 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2786 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2787 return bfd_reloc_ok;
2790 static bfd_reloc_status_type
2791 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2792 void *data, asection *input_section,
2793 bfd *output_bfd, char **error_message)
2795 /* If this is a relocatable link (output_bfd test tells us), just
2796 call the generic function. Any adjustment will be done at final
2798 if (output_bfd != NULL)
2799 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2800 input_section, output_bfd, error_message);
2802 if (error_message != NULL)
2804 static char buf[60];
2805 sprintf (buf, "generic linker can't handle %s",
2806 reloc_entry->howto->name);
2807 *error_message = buf;
2809 return bfd_reloc_dangerous;
2812 /* Track GOT entries needed for a given symbol. We might need more
2813 than one got entry per symbol. */
2816 struct got_entry *next;
2818 /* The symbol addend that we'll be placing in the GOT. */
2821 /* Unlike other ELF targets, we use separate GOT entries for the same
2822 symbol referenced from different input files. This is to support
2823 automatic multiple TOC/GOT sections, where the TOC base can vary
2824 from one input file to another. After partitioning into TOC groups
2825 we merge entries within the group.
2827 Point to the BFD owning this GOT entry. */
2830 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2831 TLS_TPREL or TLS_DTPREL for tls entries. */
2832 unsigned char tls_type;
2834 /* Non-zero if got.ent points to real entry. */
2835 unsigned char is_indirect;
2837 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2840 bfd_signed_vma refcount;
2842 struct got_entry *ent;
2846 /* The same for PLT. */
2849 struct plt_entry *next;
2855 bfd_signed_vma refcount;
2860 struct ppc64_elf_obj_tdata
2862 struct elf_obj_tdata elf;
2864 /* Shortcuts to dynamic linker sections. */
2868 /* Used during garbage collection. We attach global symbols defined
2869 on removed .opd entries to this section so that the sym is removed. */
2870 asection *deleted_section;
2872 /* TLS local dynamic got entry handling. Support for multiple GOT
2873 sections means we potentially need one of these for each input bfd. */
2874 struct got_entry tlsld_got;
2877 /* A copy of relocs before they are modified for --emit-relocs. */
2878 Elf_Internal_Rela *relocs;
2880 /* Section contents. */
2884 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2885 the reloc to be in the range -32768 to 32767. */
2886 unsigned int has_small_toc_reloc : 1;
2888 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2889 instruction not one we handle. */
2890 unsigned int unexpected_toc_insn : 1;
2893 #define ppc64_elf_tdata(bfd) \
2894 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896 #define ppc64_tlsld_got(bfd) \
2897 (&ppc64_elf_tdata (bfd)->tlsld_got)
2899 #define is_ppc64_elf(bfd) \
2900 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2901 && elf_object_id (bfd) == PPC64_ELF_DATA)
2903 /* Override the generic function because we store some extras. */
2906 ppc64_elf_mkobject (bfd *abfd)
2908 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2912 /* Fix bad default arch selected for a 64 bit input bfd when the
2913 default is 32 bit. Also select arch based on apuinfo. */
2916 ppc64_elf_object_p (bfd *abfd)
2918 if (!abfd->arch_info->the_default)
2921 if (abfd->arch_info->bits_per_word == 32)
2923 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927 /* Relies on arch after 32 bit default being 64 bit default. */
2928 abfd->arch_info = abfd->arch_info->next;
2929 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2932 return _bfd_elf_ppc_set_arch (abfd);
2935 /* Support for core dump NOTE sections. */
2938 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940 size_t offset, size;
2942 if (note->descsz != 504)
2946 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2949 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2955 /* Make a ".reg/999" section. */
2956 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2957 size, note->descpos + offset);
2961 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963 if (note->descsz != 136)
2966 elf_tdata (abfd)->core->pid
2967 = bfd_get_32 (abfd, note->descdata + 24);
2968 elf_tdata (abfd)->core->program
2969 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2970 elf_tdata (abfd)->core->command
2971 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2977 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2990 va_start (ap, note_type);
2991 memset (data, 0, sizeof (data));
2992 strncpy (data + 40, va_arg (ap, const char *), 16);
2993 strncpy (data + 56, va_arg (ap, const char *), 80);
2995 return elfcore_write_note (abfd, buf, bufsiz,
2996 "CORE", note_type, data, sizeof (data));
3007 va_start (ap, note_type);
3008 memset (data, 0, 112);
3009 pid = va_arg (ap, long);
3010 bfd_put_32 (abfd, pid, data + 32);
3011 cursig = va_arg (ap, int);
3012 bfd_put_16 (abfd, cursig, data + 12);
3013 greg = va_arg (ap, const void *);
3014 memcpy (data + 112, greg, 384);
3015 memset (data + 496, 0, 8);
3017 return elfcore_write_note (abfd, buf, bufsiz,
3018 "CORE", note_type, data, sizeof (data));
3023 /* Add extra PPC sections. */
3025 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3027 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3028 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3029 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3030 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3033 { NULL, 0, 0, 0, 0 }
3036 enum _ppc64_sec_type {
3042 struct _ppc64_elf_section_data
3044 struct bfd_elf_section_data elf;
3048 /* An array with one entry for each opd function descriptor,
3049 and some spares since opd entries may be either 16 or 24 bytes. */
3050 #define OPD_NDX(OFF) ((OFF) >> 4)
3051 struct _opd_sec_data
3053 /* Points to the function code section for local opd entries. */
3054 asection **func_sec;
3056 /* After editing .opd, adjust references to opd local syms. */
3060 /* An array for toc sections, indexed by offset/8. */
3061 struct _toc_sec_data
3063 /* Specifies the relocation symbol index used at a given toc offset. */
3066 /* And the relocation addend. */
3071 enum _ppc64_sec_type sec_type:2;
3073 /* Flag set when small branches are detected. Used to
3074 select suitable defaults for the stub group size. */
3075 unsigned int has_14bit_branch:1;
3078 #define ppc64_elf_section_data(sec) \
3079 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3082 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3084 if (!sec->used_by_bfd)
3086 struct _ppc64_elf_section_data *sdata;
3087 bfd_size_type amt = sizeof (*sdata);
3089 sdata = bfd_zalloc (abfd, amt);
3092 sec->used_by_bfd = sdata;
3095 return _bfd_elf_new_section_hook (abfd, sec);
3098 static struct _opd_sec_data *
3099 get_opd_info (asection * sec)
3102 && ppc64_elf_section_data (sec) != NULL
3103 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3104 return &ppc64_elf_section_data (sec)->u.opd;
3108 /* Parameters for the qsort hook. */
3109 static bfd_boolean synthetic_relocatable;
3110 static asection *synthetic_opd;
3112 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3115 compare_symbols (const void *ap, const void *bp)
3117 const asymbol *a = * (const asymbol **) ap;
3118 const asymbol *b = * (const asymbol **) bp;
3120 /* Section symbols first. */
3121 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3123 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3126 /* then .opd symbols. */
3127 if (synthetic_opd != NULL)
3129 if (strcmp (a->section->name, ".opd") == 0
3130 && strcmp (b->section->name, ".opd") != 0)
3132 if (strcmp (a->section->name, ".opd") != 0
3133 && strcmp (b->section->name, ".opd") == 0)
3137 /* then other code symbols. */
3138 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3139 == (SEC_CODE | SEC_ALLOC)
3140 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3141 != (SEC_CODE | SEC_ALLOC))
3144 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3145 != (SEC_CODE | SEC_ALLOC)
3146 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3147 == (SEC_CODE | SEC_ALLOC))
3150 if (synthetic_relocatable)
3152 if (a->section->id < b->section->id)
3155 if (a->section->id > b->section->id)
3159 if (a->value + a->section->vma < b->value + b->section->vma)
3162 if (a->value + a->section->vma > b->value + b->section->vma)
3165 /* For syms with the same value, prefer strong dynamic global function
3166 syms over other syms. */
3167 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3170 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3173 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3176 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3179 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3182 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3185 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3188 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3194 /* Search SYMS for a symbol of the given VALUE. */
3197 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3201 if (id == (unsigned) -1)
3205 mid = (lo + hi) >> 1;
3206 if (syms[mid]->value + syms[mid]->section->vma < value)
3208 else if (syms[mid]->value + syms[mid]->section->vma > value)
3218 mid = (lo + hi) >> 1;
3219 if (syms[mid]->section->id < id)
3221 else if (syms[mid]->section->id > id)
3223 else if (syms[mid]->value < value)
3225 else if (syms[mid]->value > value)
3235 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237 bfd_vma vma = *(bfd_vma *) ptr;
3238 return ((section->flags & SEC_ALLOC) != 0
3239 && section->vma <= vma
3240 && vma < section->vma + section->size);
3243 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3244 entry syms. Also generate @plt symbols for the glink branch table.
3245 Returns count of synthetic symbols in RET or -1 on error. */
3248 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3249 long static_count, asymbol **static_syms,
3250 long dyn_count, asymbol **dyn_syms,
3257 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3258 asection *opd = NULL;
3259 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3261 int abi = abiversion (abfd);
3267 opd = bfd_get_section_by_name (abfd, ".opd");
3268 if (opd == NULL && abi == 1)
3272 symcount = static_count;
3274 symcount += dyn_count;
3278 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3282 if (!relocatable && static_count != 0 && dyn_count != 0)
3284 /* Use both symbol tables. */
3285 memcpy (syms, static_syms, static_count * sizeof (*syms));
3286 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288 else if (!relocatable && static_count == 0)
3289 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293 synthetic_relocatable = relocatable;
3294 synthetic_opd = opd;
3295 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3297 if (!relocatable && symcount > 1)
3300 /* Trim duplicate syms, since we may have merged the normal and
3301 dynamic symbols. Actually, we only care about syms that have
3302 different values, so trim any with the same value. */
3303 for (i = 1, j = 1; i < symcount; ++i)
3304 if (syms[i - 1]->value + syms[i - 1]->section->vma
3305 != syms[i]->value + syms[i]->section->vma)
3306 syms[j++] = syms[i];
3311 /* Note that here and in compare_symbols we can't compare opd and
3312 sym->section directly. With separate debug info files, the
3313 symbols will be extracted from the debug file while abfd passed
3314 to this function is the real binary. */
3315 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3319 for (; i < symcount; ++i)
3320 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3321 != (SEC_CODE | SEC_ALLOC))
3322 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3326 for (; i < symcount; ++i)
3327 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3332 for (; i < symcount; ++i)
3333 if (strcmp (syms[i]->section->name, ".opd") != 0)
3337 for (; i < symcount; ++i)
3338 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3339 != (SEC_CODE | SEC_ALLOC))
3347 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3352 if (opdsymend == secsymend)
3355 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3356 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3360 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3367 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3371 while (r < opd->relocation + relcount
3372 && r->address < syms[i]->value + opd->vma)
3375 if (r == opd->relocation + relcount)
3378 if (r->address != syms[i]->value + opd->vma)
3381 if (r->howto->type != R_PPC64_ADDR64)
3384 sym = *r->sym_ptr_ptr;
3385 if (!sym_exists_at (syms, opdsymend, symcount,
3386 sym->section->id, sym->value + r->addend))
3389 size += sizeof (asymbol);
3390 size += strlen (syms[i]->name) + 2;
3396 s = *ret = bfd_malloc (size);
3403 names = (char *) (s + count);
3405 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3409 while (r < opd->relocation + relcount
3410 && r->address < syms[i]->value + opd->vma)
3413 if (r == opd->relocation + relcount)
3416 if (r->address != syms[i]->value + opd->vma)
3419 if (r->howto->type != R_PPC64_ADDR64)
3422 sym = *r->sym_ptr_ptr;
3423 if (!sym_exists_at (syms, opdsymend, symcount,
3424 sym->section->id, sym->value + r->addend))
3429 s->flags |= BSF_SYNTHETIC;
3430 s->section = sym->section;
3431 s->value = sym->value + r->addend;
3434 len = strlen (syms[i]->name);
3435 memcpy (names, syms[i]->name, len + 1);
3437 /* Have udata.p point back to the original symbol this
3438 synthetic symbol was derived from. */
3439 s->udata.p = syms[i];
3446 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3447 bfd_byte *contents = NULL;
3450 bfd_vma glink_vma = 0, resolv_vma = 0;
3451 asection *dynamic, *glink = NULL, *relplt = NULL;
3454 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3456 free_contents_and_exit_err:
3458 free_contents_and_exit:
3465 for (i = secsymend; i < opdsymend; ++i)
3469 /* Ignore bogus symbols. */
3470 if (syms[i]->value > opd->size - 8)
3473 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3474 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3477 size += sizeof (asymbol);
3478 size += strlen (syms[i]->name) + 2;
3482 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3484 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3486 bfd_byte *dynbuf, *extdyn, *extdynend;
3488 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3491 goto free_contents_and_exit_err;
3493 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3494 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3497 extdynend = extdyn + dynamic->size;
3498 for (; extdyn < extdynend; extdyn += extdynsize)
3500 Elf_Internal_Dyn dyn;
3501 (*swap_dyn_in) (abfd, extdyn, &dyn);
3503 if (dyn.d_tag == DT_NULL)
3506 if (dyn.d_tag == DT_PPC64_GLINK)
3508 /* The first glink stub starts at offset 32; see
3509 comment in ppc64_elf_finish_dynamic_sections. */
3510 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3511 /* The .glink section usually does not survive the final
3512 link; search for the section (usually .text) where the
3513 glink stubs now reside. */
3514 glink = bfd_sections_find_if (abfd, section_covers_vma,
3525 /* Determine __glink trampoline by reading the relative branch
3526 from the first glink stub. */
3528 unsigned int off = 0;
3530 while (bfd_get_section_contents (abfd, glink, buf,
3531 glink_vma + off - glink->vma, 4))
3533 unsigned int insn = bfd_get_32 (abfd, buf);
3535 if ((insn & ~0x3fffffc) == 0)
3537 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3546 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3548 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3551 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3552 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3553 goto free_contents_and_exit_err;
3555 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3556 size += plt_count * sizeof (asymbol);
3558 p = relplt->relocation;
3559 for (i = 0; i < plt_count; i++, p++)
3561 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563 size += sizeof ("+0x") - 1 + 16;
3569 goto free_contents_and_exit;
3570 s = *ret = bfd_malloc (size);
3572 goto free_contents_and_exit_err;
3574 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3576 for (i = secsymend; i < opdsymend; ++i)
3580 if (syms[i]->value > opd->size - 8)
3583 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3584 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3588 asection *sec = abfd->sections;
3595 long mid = (lo + hi) >> 1;
3596 if (syms[mid]->section->vma < ent)
3598 else if (syms[mid]->section->vma > ent)
3602 sec = syms[mid]->section;
3607 if (lo >= hi && lo > codesecsym)
3608 sec = syms[lo - 1]->section;
3610 for (; sec != NULL; sec = sec->next)
3614 /* SEC_LOAD may not be set if SEC is from a separate debug
3616 if ((sec->flags & SEC_ALLOC) == 0)
3618 if ((sec->flags & SEC_CODE) != 0)
3621 s->flags |= BSF_SYNTHETIC;
3622 s->value = ent - s->section->vma;
3625 len = strlen (syms[i]->name);
3626 memcpy (names, syms[i]->name, len + 1);
3628 /* Have udata.p point back to the original symbol this
3629 synthetic symbol was derived from. */
3630 s->udata.p = syms[i];
3636 if (glink != NULL && relplt != NULL)
3640 /* Add a symbol for the main glink trampoline. */
3641 memset (s, 0, sizeof *s);
3643 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3645 s->value = resolv_vma - glink->vma;
3647 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3648 names += sizeof ("__glink_PLTresolve");
3653 /* FIXME: It would be very much nicer to put sym@plt on the
3654 stub rather than on the glink branch table entry. The
3655 objdump disassembler would then use a sensible symbol
3656 name on plt calls. The difficulty in doing so is
3657 a) finding the stubs, and,
3658 b) matching stubs against plt entries, and,
3659 c) there can be multiple stubs for a given plt entry.
3661 Solving (a) could be done by code scanning, but older
3662 ppc64 binaries used different stubs to current code.
3663 (b) is the tricky one since you need to known the toc
3664 pointer for at least one function that uses a pic stub to
3665 be able to calculate the plt address referenced.
3666 (c) means gdb would need to set multiple breakpoints (or
3667 find the glink branch itself) when setting breakpoints
3668 for pending shared library loads. */
3669 p = relplt->relocation;
3670 for (i = 0; i < plt_count; i++, p++)
3674 *s = **p->sym_ptr_ptr;
3675 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3676 we are defining a symbol, ensure one of them is set. */
3677 if ((s->flags & BSF_LOCAL) == 0)
3678 s->flags |= BSF_GLOBAL;
3679 s->flags |= BSF_SYNTHETIC;
3681 s->value = glink_vma - glink->vma;
3684 len = strlen ((*p->sym_ptr_ptr)->name);
3685 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3689 memcpy (names, "+0x", sizeof ("+0x") - 1);
3690 names += sizeof ("+0x") - 1;
3691 bfd_sprintf_vma (abfd, names, p->addend);
3692 names += strlen (names);
3694 memcpy (names, "@plt", sizeof ("@plt"));
3695 names += sizeof ("@plt");
3715 /* The following functions are specific to the ELF linker, while
3716 functions above are used generally. Those named ppc64_elf_* are
3717 called by the main ELF linker code. They appear in this file more
3718 or less in the order in which they are called. eg.
3719 ppc64_elf_check_relocs is called early in the link process,
3720 ppc64_elf_finish_dynamic_sections is one of the last functions
3723 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3724 functions have both a function code symbol and a function descriptor
3725 symbol. A call to foo in a relocatable object file looks like:
3732 The function definition in another object file might be:
3736 . .quad .TOC.@tocbase
3742 When the linker resolves the call during a static link, the branch
3743 unsurprisingly just goes to .foo and the .opd information is unused.
3744 If the function definition is in a shared library, things are a little
3745 different: The call goes via a plt call stub, the opd information gets
3746 copied to the plt, and the linker patches the nop.
3754 . std 2,40(1) # in practice, the call stub
3755 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3756 . addi 11,11,Lfoo@toc@l # this is the general idea
3764 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3766 The "reloc ()" notation is supposed to indicate that the linker emits
3767 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3770 What are the difficulties here? Well, firstly, the relocations
3771 examined by the linker in check_relocs are against the function code
3772 sym .foo, while the dynamic relocation in the plt is emitted against
3773 the function descriptor symbol, foo. Somewhere along the line, we need
3774 to carefully copy dynamic link information from one symbol to the other.
3775 Secondly, the generic part of the elf linker will make .foo a dynamic
3776 symbol as is normal for most other backends. We need foo dynamic
3777 instead, at least for an application final link. However, when
3778 creating a shared library containing foo, we need to have both symbols
3779 dynamic so that references to .foo are satisfied during the early
3780 stages of linking. Otherwise the linker might decide to pull in a
3781 definition from some other object, eg. a static library.
3783 Update: As of August 2004, we support a new convention. Function
3784 calls may use the function descriptor symbol, ie. "bl foo". This
3785 behaves exactly as "bl .foo". */
3787 /* Of those relocs that might be copied as dynamic relocs, this function
3788 selects those that must be copied when linking a shared library,
3789 even when the symbol is local. */
3792 must_be_dyn_reloc (struct bfd_link_info *info,
3793 enum elf_ppc64_reloc_type r_type)
3805 case R_PPC64_TPREL16:
3806 case R_PPC64_TPREL16_LO:
3807 case R_PPC64_TPREL16_HI:
3808 case R_PPC64_TPREL16_HA:
3809 case R_PPC64_TPREL16_DS:
3810 case R_PPC64_TPREL16_LO_DS:
3811 case R_PPC64_TPREL16_HIGH:
3812 case R_PPC64_TPREL16_HIGHA:
3813 case R_PPC64_TPREL16_HIGHER:
3814 case R_PPC64_TPREL16_HIGHERA:
3815 case R_PPC64_TPREL16_HIGHEST:
3816 case R_PPC64_TPREL16_HIGHESTA:
3817 case R_PPC64_TPREL64:
3818 return !bfd_link_executable (info);
3822 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3823 copying dynamic variables from a shared lib into an app's dynbss
3824 section, and instead use a dynamic relocation to point into the
3825 shared lib. With code that gcc generates, it's vital that this be
3826 enabled; In the PowerPC64 ABI, the address of a function is actually
3827 the address of a function descriptor, which resides in the .opd
3828 section. gcc uses the descriptor directly rather than going via the
3829 GOT as some other ABI's do, which means that initialized function
3830 pointers must reference the descriptor. Thus, a function pointer
3831 initialized to the address of a function in a shared library will
3832 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3833 redefines the function descriptor symbol to point to the copy. This
3834 presents a problem as a plt entry for that function is also
3835 initialized from the function descriptor symbol and the copy reloc
3836 may not be initialized first. */
3837 #define ELIMINATE_COPY_RELOCS 1
3839 /* Section name for stubs is the associated section name plus this
3841 #define STUB_SUFFIX ".stub"
3844 ppc_stub_long_branch:
3845 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3846 destination, but a 24 bit branch in a stub section will reach.
3849 ppc_stub_plt_branch:
3850 Similar to the above, but a 24 bit branch in the stub section won't
3851 reach its destination.
3852 . addis %r11,%r2,xxx@toc@ha
3853 . ld %r12,xxx@toc@l(%r11)
3858 Used to call a function in a shared library. If it so happens that
3859 the plt entry referenced crosses a 64k boundary, then an extra
3860 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3862 . addis %r11,%r2,xxx@toc@ha
3863 . ld %r12,xxx+0@toc@l(%r11)
3865 . ld %r2,xxx+8@toc@l(%r11)
3866 . ld %r11,xxx+16@toc@l(%r11)
3869 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3870 code to adjust the value and save r2 to support multiple toc sections.
3871 A ppc_stub_long_branch with an r2 offset looks like:
3873 . addis %r2,%r2,off@ha
3874 . addi %r2,%r2,off@l
3877 A ppc_stub_plt_branch with an r2 offset looks like:
3879 . addis %r11,%r2,xxx@toc@ha
3880 . ld %r12,xxx@toc@l(%r11)
3881 . addis %r2,%r2,off@ha
3882 . addi %r2,%r2,off@l
3886 In cases where the "addis" instruction would add zero, the "addis" is
3887 omitted and following instructions modified slightly in some cases.
3890 enum ppc_stub_type {
3892 ppc_stub_long_branch,
3893 ppc_stub_long_branch_r2off,
3894 ppc_stub_plt_branch,
3895 ppc_stub_plt_branch_r2off,
3897 ppc_stub_plt_call_r2save,
3898 ppc_stub_global_entry,
3902 /* Information on stub grouping. */
3905 /* The stub section. */
3907 /* This is the section to which stubs in the group will be attached. */
3910 struct map_stub *next;
3911 /* Whether to emit a copy of register save/restore functions in this
3916 struct ppc_stub_hash_entry {
3918 /* Base hash table entry structure. */
3919 struct bfd_hash_entry root;
3921 enum ppc_stub_type stub_type;
3923 /* Group information. */
3924 struct map_stub *group;
3926 /* Offset within stub_sec of the beginning of this stub. */
3927 bfd_vma stub_offset;
3929 /* Given the symbol's value and its section we can determine its final
3930 value when building the stubs (so the stub knows where to jump. */
3931 bfd_vma target_value;
3932 asection *target_section;
3934 /* The symbol table entry, if any, that this was derived from. */
3935 struct ppc_link_hash_entry *h;
3936 struct plt_entry *plt_ent;
3938 /* Symbol st_other. */
3939 unsigned char other;
3942 struct ppc_branch_hash_entry {
3944 /* Base hash table entry structure. */
3945 struct bfd_hash_entry root;
3947 /* Offset within branch lookup table. */
3948 unsigned int offset;
3950 /* Generation marker. */
3954 /* Used to track dynamic relocations for local symbols. */
3955 struct ppc_dyn_relocs
3957 struct ppc_dyn_relocs *next;
3959 /* The input section of the reloc. */
3962 /* Total number of relocs copied for the input section. */
3963 unsigned int count : 31;
3965 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3966 unsigned int ifunc : 1;
3969 struct ppc_link_hash_entry
3971 struct elf_link_hash_entry elf;
3974 /* A pointer to the most recently used stub hash entry against this
3976 struct ppc_stub_hash_entry *stub_cache;
3978 /* A pointer to the next symbol starting with a '.' */
3979 struct ppc_link_hash_entry *next_dot_sym;
3982 /* Track dynamic relocs copied for this symbol. */
3983 struct elf_dyn_relocs *dyn_relocs;
3985 /* Chain of aliases referring to a weakdef. */
3986 struct ppc_link_hash_entry *weakref;
3988 /* Link between function code and descriptor symbols. */
3989 struct ppc_link_hash_entry *oh;
3991 /* Flag function code and descriptor symbols. */
3992 unsigned int is_func:1;
3993 unsigned int is_func_descriptor:1;
3994 unsigned int fake:1;
3996 /* Whether global opd/toc sym has been adjusted or not.
3997 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3998 should be set for all globals defined in any opd/toc section. */
3999 unsigned int adjust_done:1;
4001 /* Set if this is an out-of-line register save/restore function,
4002 with non-standard calling convention. */
4003 unsigned int save_res:1;
4005 /* Contexts in which symbol is used in the GOT (or TOC).
4006 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4007 corresponding relocs are encountered during check_relocs.
4008 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4009 indicate the corresponding GOT entry type is not needed.
4010 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4011 a TPREL one. We use a separate flag rather than setting TPREL
4012 just for convenience in distinguishing the two cases. */
4013 #define TLS_GD 1 /* GD reloc. */
4014 #define TLS_LD 2 /* LD reloc. */
4015 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
4016 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
4017 #define TLS_TLS 16 /* Any TLS reloc. */
4018 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4019 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4020 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4021 unsigned char tls_mask;
4024 /* ppc64 ELF linker hash table. */
4026 struct ppc_link_hash_table
4028 struct elf_link_hash_table elf;
4030 /* The stub hash table. */
4031 struct bfd_hash_table stub_hash_table;
4033 /* Another hash table for plt_branch stubs. */
4034 struct bfd_hash_table branch_hash_table;
4036 /* Hash table for function prologue tocsave. */
4037 htab_t tocsave_htab;
4039 /* Various options and other info passed from the linker. */
4040 struct ppc64_elf_params *params;
4042 /* The size of sec_info below. */
4043 unsigned int sec_info_arr_size;
4045 /* Per-section array of extra section info. Done this way rather
4046 than as part of ppc64_elf_section_data so we have the info for
4047 non-ppc64 sections. */
4050 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4055 /* The section group that this section belongs to. */
4056 struct map_stub *group;
4057 /* A temp section list pointer. */
4062 /* Linked list of groups. */
4063 struct map_stub *group;
4065 /* Temp used when calculating TOC pointers. */
4068 asection *toc_first_sec;
4070 /* Used when adding symbols. */
4071 struct ppc_link_hash_entry *dot_syms;
4073 /* Shortcuts to get to dynamic linker sections. */
4078 asection *glink_eh_frame;
4080 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4081 struct ppc_link_hash_entry *tls_get_addr;
4082 struct ppc_link_hash_entry *tls_get_addr_fd;
4084 /* The size of reliplt used by got entry relocs. */
4085 bfd_size_type got_reli_size;
4088 unsigned long stub_count[ppc_stub_global_entry];
4090 /* Number of stubs against global syms. */
4091 unsigned long stub_globals;
4093 /* Set if we're linking code with function descriptors. */
4094 unsigned int opd_abi:1;
4096 /* Support for multiple toc sections. */
4097 unsigned int do_multi_toc:1;
4098 unsigned int multi_toc_needed:1;
4099 unsigned int second_toc_pass:1;
4100 unsigned int do_toc_opt:1;
4103 unsigned int stub_error:1;
4105 /* Whether func_desc_adjust needs to be run over symbols. */
4106 unsigned int need_func_desc_adj:1;
4108 /* Incremented every time we size stubs. */
4109 unsigned int stub_iteration;
4111 /* Small local sym cache. */
4112 struct sym_cache sym_cache;
4115 /* Rename some of the generic section flags to better document how they
4118 /* Nonzero if this section has TLS related relocations. */
4119 #define has_tls_reloc sec_flg0
4121 /* Nonzero if this section has a call to __tls_get_addr. */
4122 #define has_tls_get_addr_call sec_flg1
4124 /* Nonzero if this section has any toc or got relocs. */
4125 #define has_toc_reloc sec_flg2
4127 /* Nonzero if this section has a call to another section that uses
4129 #define makes_toc_func_call sec_flg3
4131 /* Recursion protection when determining above flag. */
4132 #define call_check_in_progress sec_flg4
4133 #define call_check_done sec_flg5
4135 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4137 #define ppc_hash_table(p) \
4138 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4139 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4141 #define ppc_stub_hash_lookup(table, string, create, copy) \
4142 ((struct ppc_stub_hash_entry *) \
4143 bfd_hash_lookup ((table), (string), (create), (copy)))
4145 #define ppc_branch_hash_lookup(table, string, create, copy) \
4146 ((struct ppc_branch_hash_entry *) \
4147 bfd_hash_lookup ((table), (string), (create), (copy)))
4149 /* Create an entry in the stub hash table. */
4151 static struct bfd_hash_entry *
4152 stub_hash_newfunc (struct bfd_hash_entry *entry,
4153 struct bfd_hash_table *table,
4156 /* Allocate the structure if it has not already been allocated by a
4160 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4165 /* Call the allocation method of the superclass. */
4166 entry = bfd_hash_newfunc (entry, table, string);
4169 struct ppc_stub_hash_entry *eh;
4171 /* Initialize the local fields. */
4172 eh = (struct ppc_stub_hash_entry *) entry;
4173 eh->stub_type = ppc_stub_none;
4175 eh->stub_offset = 0;
4176 eh->target_value = 0;
4177 eh->target_section = NULL;
4186 /* Create an entry in the branch hash table. */
4188 static struct bfd_hash_entry *
4189 branch_hash_newfunc (struct bfd_hash_entry *entry,
4190 struct bfd_hash_table *table,
4193 /* Allocate the structure if it has not already been allocated by a
4197 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4202 /* Call the allocation method of the superclass. */
4203 entry = bfd_hash_newfunc (entry, table, string);
4206 struct ppc_branch_hash_entry *eh;
4208 /* Initialize the local fields. */
4209 eh = (struct ppc_branch_hash_entry *) entry;
4217 /* Create an entry in a ppc64 ELF linker hash table. */
4219 static struct bfd_hash_entry *
4220 link_hash_newfunc (struct bfd_hash_entry *entry,
4221 struct bfd_hash_table *table,
4224 /* Allocate the structure if it has not already been allocated by a
4228 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4233 /* Call the allocation method of the superclass. */
4234 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4237 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4239 memset (&eh->u.stub_cache, 0,
4240 (sizeof (struct ppc_link_hash_entry)
4241 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4243 /* When making function calls, old ABI code references function entry
4244 points (dot symbols), while new ABI code references the function
4245 descriptor symbol. We need to make any combination of reference and
4246 definition work together, without breaking archive linking.
4248 For a defined function "foo" and an undefined call to "bar":
4249 An old object defines "foo" and ".foo", references ".bar" (possibly
4251 A new object defines "foo" and references "bar".
4253 A new object thus has no problem with its undefined symbols being
4254 satisfied by definitions in an old object. On the other hand, the
4255 old object won't have ".bar" satisfied by a new object.
4257 Keep a list of newly added dot-symbols. */
4259 if (string[0] == '.')
4261 struct ppc_link_hash_table *htab;
4263 htab = (struct ppc_link_hash_table *) table;
4264 eh->u.next_dot_sym = htab->dot_syms;
4265 htab->dot_syms = eh;
4272 struct tocsave_entry {
4278 tocsave_htab_hash (const void *p)
4280 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4281 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4285 tocsave_htab_eq (const void *p1, const void *p2)
4287 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4288 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4289 return e1->sec == e2->sec && e1->offset == e2->offset;
4292 /* Destroy a ppc64 ELF linker hash table. */
4295 ppc64_elf_link_hash_table_free (bfd *obfd)
4297 struct ppc_link_hash_table *htab;
4299 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4300 if (htab->tocsave_htab)
4301 htab_delete (htab->tocsave_htab);
4302 bfd_hash_table_free (&htab->branch_hash_table);
4303 bfd_hash_table_free (&htab->stub_hash_table);
4304 _bfd_elf_link_hash_table_free (obfd);
4307 /* Create a ppc64 ELF linker hash table. */
4309 static struct bfd_link_hash_table *
4310 ppc64_elf_link_hash_table_create (bfd *abfd)
4312 struct ppc_link_hash_table *htab;
4313 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4315 htab = bfd_zmalloc (amt);
4319 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4320 sizeof (struct ppc_link_hash_entry),
4327 /* Init the stub hash table too. */
4328 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4329 sizeof (struct ppc_stub_hash_entry)))
4331 _bfd_elf_link_hash_table_free (abfd);
4335 /* And the branch hash table. */
4336 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4337 sizeof (struct ppc_branch_hash_entry)))
4339 bfd_hash_table_free (&htab->stub_hash_table);
4340 _bfd_elf_link_hash_table_free (abfd);
4344 htab->tocsave_htab = htab_try_create (1024,
4348 if (htab->tocsave_htab == NULL)
4350 ppc64_elf_link_hash_table_free (abfd);
4353 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4355 /* Initializing two fields of the union is just cosmetic. We really
4356 only care about glist, but when compiled on a 32-bit host the
4357 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4358 debugger inspection of these fields look nicer. */
4359 htab->elf.init_got_refcount.refcount = 0;
4360 htab->elf.init_got_refcount.glist = NULL;
4361 htab->elf.init_plt_refcount.refcount = 0;
4362 htab->elf.init_plt_refcount.glist = NULL;
4363 htab->elf.init_got_offset.offset = 0;
4364 htab->elf.init_got_offset.glist = NULL;
4365 htab->elf.init_plt_offset.offset = 0;
4366 htab->elf.init_plt_offset.glist = NULL;
4368 return &htab->elf.root;
4371 /* Create sections for linker generated code. */
4374 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4376 struct ppc_link_hash_table *htab;
4379 htab = ppc_hash_table (info);
4381 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4382 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4383 if (htab->params->save_restore_funcs)
4385 /* Create .sfpr for code to save and restore fp regs. */
4386 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4388 if (htab->sfpr == NULL
4389 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4393 if (bfd_link_relocatable (info))
4396 /* Create .glink for lazy dynamic linking support. */
4397 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4399 if (htab->glink == NULL
4400 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4403 if (!info->no_ld_generated_unwind_info)
4405 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4406 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4407 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4410 if (htab->glink_eh_frame == NULL
4411 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4415 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4416 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4417 if (htab->elf.iplt == NULL
4418 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4421 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4422 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4424 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4425 if (htab->elf.irelplt == NULL
4426 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4429 /* Create branch lookup table for plt_branch stubs. */
4430 flags = (SEC_ALLOC | SEC_LOAD
4431 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4432 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4434 if (htab->brlt == NULL
4435 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4438 if (!bfd_link_pic (info))
4441 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4442 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4443 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4446 if (htab->relbrlt == NULL
4447 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4453 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4456 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4457 struct ppc64_elf_params *params)
4459 struct ppc_link_hash_table *htab;
4461 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4463 /* Always hook our dynamic sections into the first bfd, which is the
4464 linker created stub bfd. This ensures that the GOT header is at
4465 the start of the output TOC section. */
4466 htab = ppc_hash_table (info);
4467 htab->elf.dynobj = params->stub_bfd;
4468 htab->params = params;
4470 return create_linkage_sections (htab->elf.dynobj, info);
4473 /* Build a name for an entry in the stub hash table. */
4476 ppc_stub_name (const asection *input_section,
4477 const asection *sym_sec,
4478 const struct ppc_link_hash_entry *h,
4479 const Elf_Internal_Rela *rel)
4484 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4485 offsets from a sym as a branch target? In fact, we could
4486 probably assume the addend is always zero. */
4487 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4491 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4492 stub_name = bfd_malloc (len);
4493 if (stub_name == NULL)
4496 len = sprintf (stub_name, "%08x.%s+%x",
4497 input_section->id & 0xffffffff,
4498 h->elf.root.root.string,
4499 (int) rel->r_addend & 0xffffffff);
4503 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4504 stub_name = bfd_malloc (len);
4505 if (stub_name == NULL)
4508 len = sprintf (stub_name, "%08x.%x:%x+%x",
4509 input_section->id & 0xffffffff,
4510 sym_sec->id & 0xffffffff,
4511 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4512 (int) rel->r_addend & 0xffffffff);
4514 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4515 stub_name[len - 2] = 0;
4519 /* Look up an entry in the stub hash. Stub entries are cached because
4520 creating the stub name takes a bit of time. */
4522 static struct ppc_stub_hash_entry *
4523 ppc_get_stub_entry (const asection *input_section,
4524 const asection *sym_sec,
4525 struct ppc_link_hash_entry *h,
4526 const Elf_Internal_Rela *rel,
4527 struct ppc_link_hash_table *htab)
4529 struct ppc_stub_hash_entry *stub_entry;
4530 struct map_stub *group;
4532 /* If this input section is part of a group of sections sharing one
4533 stub section, then use the id of the first section in the group.
4534 Stub names need to include a section id, as there may well be
4535 more than one stub used to reach say, printf, and we need to
4536 distinguish between them. */
4537 group = htab->sec_info[input_section->id].u.group;
4541 if (h != NULL && h->u.stub_cache != NULL
4542 && h->u.stub_cache->h == h
4543 && h->u.stub_cache->group == group)
4545 stub_entry = h->u.stub_cache;
4551 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4552 if (stub_name == NULL)
4555 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4556 stub_name, FALSE, FALSE);
4558 h->u.stub_cache = stub_entry;
4566 /* Add a new stub entry to the stub hash. Not all fields of the new
4567 stub entry are initialised. */
4569 static struct ppc_stub_hash_entry *
4570 ppc_add_stub (const char *stub_name,
4572 struct bfd_link_info *info)
4574 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4575 struct map_stub *group;
4578 struct ppc_stub_hash_entry *stub_entry;
4580 group = htab->sec_info[section->id].u.group;
4581 link_sec = group->link_sec;
4582 stub_sec = group->stub_sec;
4583 if (stub_sec == NULL)
4589 namelen = strlen (link_sec->name);
4590 len = namelen + sizeof (STUB_SUFFIX);
4591 s_name = bfd_alloc (htab->params->stub_bfd, len);
4595 memcpy (s_name, link_sec->name, namelen);
4596 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4597 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4598 if (stub_sec == NULL)
4600 group->stub_sec = stub_sec;
4603 /* Enter this entry into the linker stub hash table. */
4604 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4606 if (stub_entry == NULL)
4608 /* xgettext:c-format */
4609 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4610 section->owner, stub_name);
4614 stub_entry->group = group;
4615 stub_entry->stub_offset = 0;
4619 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4620 not already done. */
4623 create_got_section (bfd *abfd, struct bfd_link_info *info)
4625 asection *got, *relgot;
4627 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4629 if (!is_ppc64_elf (abfd))
4635 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4638 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4639 | SEC_LINKER_CREATED);
4641 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4643 || !bfd_set_section_alignment (abfd, got, 3))
4646 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4647 flags | SEC_READONLY);
4649 || ! bfd_set_section_alignment (abfd, relgot, 3))
4652 ppc64_elf_tdata (abfd)->got = got;
4653 ppc64_elf_tdata (abfd)->relgot = relgot;
4657 /* Follow indirect and warning symbol links. */
4659 static inline struct bfd_link_hash_entry *
4660 follow_link (struct bfd_link_hash_entry *h)
4662 while (h->type == bfd_link_hash_indirect
4663 || h->type == bfd_link_hash_warning)
4668 static inline struct elf_link_hash_entry *
4669 elf_follow_link (struct elf_link_hash_entry *h)
4671 return (struct elf_link_hash_entry *) follow_link (&h->root);
4674 static inline struct ppc_link_hash_entry *
4675 ppc_follow_link (struct ppc_link_hash_entry *h)
4677 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4680 /* Merge PLT info on FROM with that on TO. */
4683 move_plt_plist (struct ppc_link_hash_entry *from,
4684 struct ppc_link_hash_entry *to)
4686 if (from->elf.plt.plist != NULL)
4688 if (to->elf.plt.plist != NULL)
4690 struct plt_entry **entp;
4691 struct plt_entry *ent;
4693 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4695 struct plt_entry *dent;
4697 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4698 if (dent->addend == ent->addend)
4700 dent->plt.refcount += ent->plt.refcount;
4707 *entp = to->elf.plt.plist;
4710 to->elf.plt.plist = from->elf.plt.plist;
4711 from->elf.plt.plist = NULL;
4715 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4718 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4719 struct elf_link_hash_entry *dir,
4720 struct elf_link_hash_entry *ind)
4722 struct ppc_link_hash_entry *edir, *eind;
4724 edir = (struct ppc_link_hash_entry *) dir;
4725 eind = (struct ppc_link_hash_entry *) ind;
4727 edir->is_func |= eind->is_func;
4728 edir->is_func_descriptor |= eind->is_func_descriptor;
4729 edir->tls_mask |= eind->tls_mask;
4730 if (eind->oh != NULL)
4731 edir->oh = ppc_follow_link (eind->oh);
4733 /* If called to transfer flags for a weakdef during processing
4734 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4735 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4736 if (!(ELIMINATE_COPY_RELOCS
4737 && eind->elf.root.type != bfd_link_hash_indirect
4738 && edir->elf.dynamic_adjusted))
4739 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4741 if (edir->elf.versioned != versioned_hidden)
4742 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4743 edir->elf.ref_regular |= eind->elf.ref_regular;
4744 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4745 edir->elf.needs_plt |= eind->elf.needs_plt;
4746 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4748 /* If we were called to copy over info for a weak sym, don't copy
4749 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4750 in order to simplify readonly_dynrelocs and save a field in the
4751 symbol hash entry, but that means dyn_relocs can't be used in any
4752 tests about a specific symbol, or affect other symbol flags which
4754 Chain weakdefs so we can get from the weakdef back to an alias.
4755 The list is circular so that we don't need to use u.weakdef as
4756 well as this list to look at all aliases. */
4757 if (eind->elf.root.type != bfd_link_hash_indirect)
4759 struct ppc_link_hash_entry *cur, *add, *next;
4764 cur = edir->weakref;
4769 /* We can be called twice for the same symbols.
4770 Don't make multiple loops. */
4774 } while (cur != edir);
4776 next = add->weakref;
4779 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4780 edir->weakref = add;
4783 } while (add != NULL && add != eind);
4787 /* Copy over any dynamic relocs we may have on the indirect sym. */
4788 if (eind->dyn_relocs != NULL)
4790 if (edir->dyn_relocs != NULL)
4792 struct elf_dyn_relocs **pp;
4793 struct elf_dyn_relocs *p;
4795 /* Add reloc counts against the indirect sym to the direct sym
4796 list. Merge any entries against the same section. */
4797 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4799 struct elf_dyn_relocs *q;
4801 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4802 if (q->sec == p->sec)
4804 q->pc_count += p->pc_count;
4805 q->count += p->count;
4812 *pp = edir->dyn_relocs;
4815 edir->dyn_relocs = eind->dyn_relocs;
4816 eind->dyn_relocs = NULL;
4819 /* Copy over got entries that we may have already seen to the
4820 symbol which just became indirect. */
4821 if (eind->elf.got.glist != NULL)
4823 if (edir->elf.got.glist != NULL)
4825 struct got_entry **entp;
4826 struct got_entry *ent;
4828 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4830 struct got_entry *dent;
4832 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4833 if (dent->addend == ent->addend
4834 && dent->owner == ent->owner
4835 && dent->tls_type == ent->tls_type)
4837 dent->got.refcount += ent->got.refcount;
4844 *entp = edir->elf.got.glist;
4847 edir->elf.got.glist = eind->elf.got.glist;
4848 eind->elf.got.glist = NULL;
4851 /* And plt entries. */
4852 move_plt_plist (eind, edir);
4854 if (eind->elf.dynindx != -1)
4856 if (edir->elf.dynindx != -1)
4857 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4858 edir->elf.dynstr_index);
4859 edir->elf.dynindx = eind->elf.dynindx;
4860 edir->elf.dynstr_index = eind->elf.dynstr_index;
4861 eind->elf.dynindx = -1;
4862 eind->elf.dynstr_index = 0;
4866 /* Find the function descriptor hash entry from the given function code
4867 hash entry FH. Link the entries via their OH fields. */
4869 static struct ppc_link_hash_entry *
4870 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4872 struct ppc_link_hash_entry *fdh = fh->oh;
4876 const char *fd_name = fh->elf.root.root.string + 1;
4878 fdh = (struct ppc_link_hash_entry *)
4879 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4883 fdh->is_func_descriptor = 1;
4889 fdh = ppc_follow_link (fdh);
4890 fdh->is_func_descriptor = 1;
4895 /* Make a fake function descriptor sym for the undefined code sym FH. */
4897 static struct ppc_link_hash_entry *
4898 make_fdh (struct bfd_link_info *info,
4899 struct ppc_link_hash_entry *fh)
4901 bfd *abfd = fh->elf.root.u.undef.abfd;
4902 struct bfd_link_hash_entry *bh = NULL;
4903 struct ppc_link_hash_entry *fdh;
4904 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4908 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4909 fh->elf.root.root.string + 1,
4910 flags, bfd_und_section_ptr, 0,
4911 NULL, FALSE, FALSE, &bh))
4914 fdh = (struct ppc_link_hash_entry *) bh;
4915 fdh->elf.non_elf = 0;
4917 fdh->is_func_descriptor = 1;
4924 /* Fix function descriptor symbols defined in .opd sections to be
4928 ppc64_elf_add_symbol_hook (bfd *ibfd,
4929 struct bfd_link_info *info,
4930 Elf_Internal_Sym *isym,
4932 flagword *flags ATTRIBUTE_UNUSED,
4936 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4937 && (ibfd->flags & DYNAMIC) == 0
4938 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4939 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4942 && strcmp ((*sec)->name, ".opd") == 0)
4946 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4947 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4948 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4950 /* If the symbol is a function defined in .opd, and the function
4951 code is in a discarded group, let it appear to be undefined. */
4952 if (!bfd_link_relocatable (info)
4953 && (*sec)->reloc_count != 0
4954 && opd_entry_value (*sec, *value, &code_sec, NULL,
4955 FALSE) != (bfd_vma) -1
4956 && discarded_section (code_sec))
4958 *sec = bfd_und_section_ptr;
4959 isym->st_shndx = SHN_UNDEF;
4962 else if (*sec != NULL
4963 && strcmp ((*sec)->name, ".toc") == 0
4964 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4966 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4968 htab->params->object_in_toc = 1;
4971 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4973 if (abiversion (ibfd) == 0)
4974 set_abiversion (ibfd, 2);
4975 else if (abiversion (ibfd) == 1)
4977 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4978 " for ABI version 1\n"), name);
4979 bfd_set_error (bfd_error_bad_value);
4987 /* Merge non-visibility st_other attributes: local entry point. */
4990 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4991 const Elf_Internal_Sym *isym,
4992 bfd_boolean definition,
4993 bfd_boolean dynamic)
4995 if (definition && !dynamic)
4996 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4997 | ELF_ST_VISIBILITY (h->other));
5000 /* Hook called on merging a symbol. We use this to clear "fake" since
5001 we now have a real symbol. */
5004 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5005 const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5006 asection **psec ATTRIBUTE_UNUSED,
5007 bfd_boolean newdef ATTRIBUTE_UNUSED,
5008 bfd_boolean olddef ATTRIBUTE_UNUSED,
5009 bfd *oldbfd ATTRIBUTE_UNUSED,
5010 const asection *oldsec ATTRIBUTE_UNUSED)
5012 ((struct ppc_link_hash_entry *) h)->fake = 0;
5016 /* This function makes an old ABI object reference to ".bar" cause the
5017 inclusion of a new ABI object archive that defines "bar".
5018 NAME is a symbol defined in an archive. Return a symbol in the hash
5019 table that might be satisfied by the archive symbols. */
5021 static struct elf_link_hash_entry *
5022 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5023 struct bfd_link_info *info,
5026 struct elf_link_hash_entry *h;
5030 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5032 /* Don't return this sym if it is a fake function descriptor
5033 created by add_symbol_adjust. */
5034 && !((struct ppc_link_hash_entry *) h)->fake)
5040 len = strlen (name);
5041 dot_name = bfd_alloc (abfd, len + 2);
5042 if (dot_name == NULL)
5043 return (struct elf_link_hash_entry *) 0 - 1;
5045 memcpy (dot_name + 1, name, len + 1);
5046 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5047 bfd_release (abfd, dot_name);
5051 /* This function satisfies all old ABI object references to ".bar" if a
5052 new ABI object defines "bar". Well, at least, undefined dot symbols
5053 are made weak. This stops later archive searches from including an
5054 object if we already have a function descriptor definition. It also
5055 prevents the linker complaining about undefined symbols.
5056 We also check and correct mismatched symbol visibility here. The
5057 most restrictive visibility of the function descriptor and the
5058 function entry symbol is used. */
5061 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5063 struct ppc_link_hash_table *htab;
5064 struct ppc_link_hash_entry *fdh;
5066 if (eh->elf.root.type == bfd_link_hash_warning)
5067 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5069 if (eh->elf.root.type == bfd_link_hash_indirect)
5072 if (eh->elf.root.root.string[0] != '.')
5075 htab = ppc_hash_table (info);
5079 fdh = lookup_fdh (eh, htab);
5081 && !bfd_link_relocatable (info)
5082 && (eh->elf.root.type == bfd_link_hash_undefined
5083 || eh->elf.root.type == bfd_link_hash_undefweak)
5084 && eh->elf.ref_regular)
5086 /* Make an undefined function descriptor sym, in order to
5087 pull in an --as-needed shared lib. Archives are handled
5089 fdh = make_fdh (info, eh);
5096 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5097 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5099 /* Make both descriptor and entry symbol have the most
5100 constraining visibility of either symbol. */
5101 if (entry_vis < descr_vis)
5102 fdh->elf.other += entry_vis - descr_vis;
5103 else if (entry_vis > descr_vis)
5104 eh->elf.other += descr_vis - entry_vis;
5106 /* Propagate reference flags from entry symbol to function
5107 descriptor symbol. */
5108 fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5109 fdh->elf.ref_regular |= eh->elf.ref_regular;
5110 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5112 if (!fdh->elf.forced_local
5113 && fdh->elf.dynindx == -1
5114 && fdh->elf.versioned != versioned_hidden
5115 && (bfd_link_dll (info)
5116 || fdh->elf.def_dynamic
5117 || fdh->elf.ref_dynamic)
5118 && (eh->elf.ref_regular
5119 || eh->elf.def_regular))
5121 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5129 /* Set up opd section info and abiversion for IBFD, and process list
5130 of dot-symbols we made in link_hash_newfunc. */
5133 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5135 struct ppc_link_hash_table *htab;
5136 struct ppc_link_hash_entry **p, *eh;
5137 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5139 if (opd != NULL && opd->size != 0)
5141 if (abiversion (ibfd) == 0)
5142 set_abiversion (ibfd, 1);
5143 else if (abiversion (ibfd) >= 2)
5145 /* xgettext:c-format */
5146 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5148 ibfd, abiversion (ibfd));
5149 bfd_set_error (bfd_error_bad_value);
5153 if ((ibfd->flags & DYNAMIC) == 0
5154 && (opd->flags & SEC_RELOC) != 0
5155 && opd->reloc_count != 0
5156 && !bfd_is_abs_section (opd->output_section))
5158 /* Garbage collection needs some extra help with .opd sections.
5159 We don't want to necessarily keep everything referenced by
5160 relocs in .opd, as that would keep all functions. Instead,
5161 if we reference an .opd symbol (a function descriptor), we
5162 want to keep the function code symbol's section. This is
5163 easy for global symbols, but for local syms we need to keep
5164 information about the associated function section. */
5166 asection **opd_sym_map;
5168 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5169 opd_sym_map = bfd_zalloc (ibfd, amt);
5170 if (opd_sym_map == NULL)
5172 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5173 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5174 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5178 if (!is_ppc64_elf (info->output_bfd))
5180 htab = ppc_hash_table (info);
5184 /* For input files without an explicit abiversion in e_flags
5185 we should have flagged any with symbol st_other bits set
5186 as ELFv1 and above flagged those with .opd as ELFv2.
5187 Set the output abiversion if not yet set, and for any input
5188 still ambiguous, take its abiversion from the output.
5189 Differences in ABI are reported later. */
5190 if (abiversion (info->output_bfd) == 0)
5191 set_abiversion (info->output_bfd, abiversion (ibfd));
5192 else if (abiversion (ibfd) == 0)
5193 set_abiversion (ibfd, abiversion (info->output_bfd));
5195 p = &htab->dot_syms;
5196 while ((eh = *p) != NULL)
5199 if (&eh->elf == htab->elf.hgot)
5201 else if (htab->elf.hgot == NULL
5202 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5203 htab->elf.hgot = &eh->elf;
5204 else if (abiversion (ibfd) <= 1)
5206 htab->need_func_desc_adj = 1;
5207 if (!add_symbol_adjust (eh, info))
5210 p = &eh->u.next_dot_sym;
5215 /* Undo hash table changes when an --as-needed input file is determined
5216 not to be needed. */
5219 ppc64_elf_notice_as_needed (bfd *ibfd,
5220 struct bfd_link_info *info,
5221 enum notice_asneeded_action act)
5223 if (act == notice_not_needed)
5225 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5230 htab->dot_syms = NULL;
5232 return _bfd_elf_notice_as_needed (ibfd, info, act);
5235 /* If --just-symbols against a final linked binary, then assume we need
5236 toc adjusting stubs when calling functions defined there. */
5239 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5241 if ((sec->flags & SEC_CODE) != 0
5242 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5243 && is_ppc64_elf (sec->owner))
5245 if (abiversion (sec->owner) >= 2
5246 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5247 sec->has_toc_reloc = 1;
5249 _bfd_elf_link_just_syms (sec, info);
5252 static struct plt_entry **
5253 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5254 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5256 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5257 struct plt_entry **local_plt;
5258 unsigned char *local_got_tls_masks;
5260 if (local_got_ents == NULL)
5262 bfd_size_type size = symtab_hdr->sh_info;
5264 size *= (sizeof (*local_got_ents)
5265 + sizeof (*local_plt)
5266 + sizeof (*local_got_tls_masks));
5267 local_got_ents = bfd_zalloc (abfd, size);
5268 if (local_got_ents == NULL)
5270 elf_local_got_ents (abfd) = local_got_ents;
5273 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5275 struct got_entry *ent;
5277 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5278 if (ent->addend == r_addend
5279 && ent->owner == abfd
5280 && ent->tls_type == tls_type)
5284 bfd_size_type amt = sizeof (*ent);
5285 ent = bfd_alloc (abfd, amt);
5288 ent->next = local_got_ents[r_symndx];
5289 ent->addend = r_addend;
5291 ent->tls_type = tls_type;
5292 ent->is_indirect = FALSE;
5293 ent->got.refcount = 0;
5294 local_got_ents[r_symndx] = ent;
5296 ent->got.refcount += 1;
5299 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5300 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5301 local_got_tls_masks[r_symndx] |= tls_type;
5303 return local_plt + r_symndx;
5307 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5309 struct plt_entry *ent;
5311 for (ent = *plist; ent != NULL; ent = ent->next)
5312 if (ent->addend == addend)
5316 bfd_size_type amt = sizeof (*ent);
5317 ent = bfd_alloc (abfd, amt);
5321 ent->addend = addend;
5322 ent->plt.refcount = 0;
5325 ent->plt.refcount += 1;
5330 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5332 return (r_type == R_PPC64_REL24
5333 || r_type == R_PPC64_REL14
5334 || r_type == R_PPC64_REL14_BRTAKEN
5335 || r_type == R_PPC64_REL14_BRNTAKEN
5336 || r_type == R_PPC64_ADDR24
5337 || r_type == R_PPC64_ADDR14
5338 || r_type == R_PPC64_ADDR14_BRTAKEN
5339 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5342 /* Look through the relocs for a section during the first phase, and
5343 calculate needed space in the global offset table, procedure
5344 linkage table, and dynamic reloc sections. */
5347 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5348 asection *sec, const Elf_Internal_Rela *relocs)
5350 struct ppc_link_hash_table *htab;
5351 Elf_Internal_Shdr *symtab_hdr;
5352 struct elf_link_hash_entry **sym_hashes;
5353 const Elf_Internal_Rela *rel;
5354 const Elf_Internal_Rela *rel_end;
5356 asection **opd_sym_map;
5357 struct elf_link_hash_entry *tga, *dottga;
5359 if (bfd_link_relocatable (info))
5362 /* Don't do anything special with non-loaded, non-alloced sections.
5363 In particular, any relocs in such sections should not affect GOT
5364 and PLT reference counting (ie. we don't allow them to create GOT
5365 or PLT entries), there's no possibility or desire to optimize TLS
5366 relocs, and there's not much point in propagating relocs to shared
5367 libs that the dynamic linker won't relocate. */
5368 if ((sec->flags & SEC_ALLOC) == 0)
5371 BFD_ASSERT (is_ppc64_elf (abfd));
5373 htab = ppc_hash_table (info);
5377 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5378 FALSE, FALSE, TRUE);
5379 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5380 FALSE, FALSE, TRUE);
5381 symtab_hdr = &elf_symtab_hdr (abfd);
5382 sym_hashes = elf_sym_hashes (abfd);
5385 if (ppc64_elf_section_data (sec) != NULL
5386 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5387 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5389 rel_end = relocs + sec->reloc_count;
5390 for (rel = relocs; rel < rel_end; rel++)
5392 unsigned long r_symndx;
5393 struct elf_link_hash_entry *h;
5394 enum elf_ppc64_reloc_type r_type;
5396 struct _ppc64_elf_section_data *ppc64_sec;
5397 struct plt_entry **ifunc, **plt_list;
5399 r_symndx = ELF64_R_SYM (rel->r_info);
5400 if (r_symndx < symtab_hdr->sh_info)
5404 struct ppc_link_hash_entry *eh;
5406 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5407 h = elf_follow_link (h);
5408 eh = (struct ppc_link_hash_entry *) h;
5410 /* PR15323, ref flags aren't set for references in the same
5412 h->root.non_ir_ref = 1;
5413 if (eh->is_func && eh->oh != NULL)
5414 eh->oh->elf.root.non_ir_ref = 1;
5416 if (h == htab->elf.hgot)
5417 sec->has_toc_reloc = 1;
5424 if (h->type == STT_GNU_IFUNC)
5427 ifunc = &h->plt.plist;
5432 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5437 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5439 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5440 rel->r_addend, PLT_IFUNC);
5446 r_type = ELF64_R_TYPE (rel->r_info);
5451 /* These special tls relocs tie a call to __tls_get_addr with
5452 its parameter symbol. */
5455 case R_PPC64_GOT_TLSLD16:
5456 case R_PPC64_GOT_TLSLD16_LO:
5457 case R_PPC64_GOT_TLSLD16_HI:
5458 case R_PPC64_GOT_TLSLD16_HA:
5459 tls_type = TLS_TLS | TLS_LD;
5462 case R_PPC64_GOT_TLSGD16:
5463 case R_PPC64_GOT_TLSGD16_LO:
5464 case R_PPC64_GOT_TLSGD16_HI:
5465 case R_PPC64_GOT_TLSGD16_HA:
5466 tls_type = TLS_TLS | TLS_GD;
5469 case R_PPC64_GOT_TPREL16_DS:
5470 case R_PPC64_GOT_TPREL16_LO_DS:
5471 case R_PPC64_GOT_TPREL16_HI:
5472 case R_PPC64_GOT_TPREL16_HA:
5473 if (bfd_link_pic (info))
5474 info->flags |= DF_STATIC_TLS;
5475 tls_type = TLS_TLS | TLS_TPREL;
5478 case R_PPC64_GOT_DTPREL16_DS:
5479 case R_PPC64_GOT_DTPREL16_LO_DS:
5480 case R_PPC64_GOT_DTPREL16_HI:
5481 case R_PPC64_GOT_DTPREL16_HA:
5482 tls_type = TLS_TLS | TLS_DTPREL;
5484 sec->has_tls_reloc = 1;
5488 case R_PPC64_GOT16_DS:
5489 case R_PPC64_GOT16_HA:
5490 case R_PPC64_GOT16_HI:
5491 case R_PPC64_GOT16_LO:
5492 case R_PPC64_GOT16_LO_DS:
5493 /* This symbol requires a global offset table entry. */
5494 sec->has_toc_reloc = 1;
5495 if (r_type == R_PPC64_GOT_TLSLD16
5496 || r_type == R_PPC64_GOT_TLSGD16
5497 || r_type == R_PPC64_GOT_TPREL16_DS
5498 || r_type == R_PPC64_GOT_DTPREL16_DS
5499 || r_type == R_PPC64_GOT16
5500 || r_type == R_PPC64_GOT16_DS)
5502 htab->do_multi_toc = 1;
5503 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5506 if (ppc64_elf_tdata (abfd)->got == NULL
5507 && !create_got_section (abfd, info))
5512 struct ppc_link_hash_entry *eh;
5513 struct got_entry *ent;
5515 eh = (struct ppc_link_hash_entry *) h;
5516 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5517 if (ent->addend == rel->r_addend
5518 && ent->owner == abfd
5519 && ent->tls_type == tls_type)
5523 bfd_size_type amt = sizeof (*ent);
5524 ent = bfd_alloc (abfd, amt);
5527 ent->next = eh->elf.got.glist;
5528 ent->addend = rel->r_addend;
5530 ent->tls_type = tls_type;
5531 ent->is_indirect = FALSE;
5532 ent->got.refcount = 0;
5533 eh->elf.got.glist = ent;
5535 ent->got.refcount += 1;
5536 eh->tls_mask |= tls_type;
5539 /* This is a global offset table entry for a local symbol. */
5540 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5541 rel->r_addend, tls_type))
5544 /* We may also need a plt entry if the symbol turns out to be
5546 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5548 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5553 case R_PPC64_PLT16_HA:
5554 case R_PPC64_PLT16_HI:
5555 case R_PPC64_PLT16_LO:
5558 /* This symbol requires a procedure linkage table entry. */
5563 if (h->root.root.string[0] == '.'
5564 && h->root.root.string[1] != '\0')
5565 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5566 plt_list = &h->plt.plist;
5568 if (plt_list == NULL)
5570 /* It does not make sense to have a procedure linkage
5571 table entry for a non-ifunc local symbol. */
5572 info->callbacks->einfo
5573 /* xgettext:c-format */
5574 (_("%H: %s reloc against local symbol\n"),
5575 abfd, sec, rel->r_offset,
5576 ppc64_elf_howto_table[r_type]->name);
5577 bfd_set_error (bfd_error_bad_value);
5580 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5584 /* The following relocations don't need to propagate the
5585 relocation if linking a shared object since they are
5586 section relative. */
5587 case R_PPC64_SECTOFF:
5588 case R_PPC64_SECTOFF_LO:
5589 case R_PPC64_SECTOFF_HI:
5590 case R_PPC64_SECTOFF_HA:
5591 case R_PPC64_SECTOFF_DS:
5592 case R_PPC64_SECTOFF_LO_DS:
5593 case R_PPC64_DTPREL16:
5594 case R_PPC64_DTPREL16_LO:
5595 case R_PPC64_DTPREL16_HI:
5596 case R_PPC64_DTPREL16_HA:
5597 case R_PPC64_DTPREL16_DS:
5598 case R_PPC64_DTPREL16_LO_DS:
5599 case R_PPC64_DTPREL16_HIGH:
5600 case R_PPC64_DTPREL16_HIGHA:
5601 case R_PPC64_DTPREL16_HIGHER:
5602 case R_PPC64_DTPREL16_HIGHERA:
5603 case R_PPC64_DTPREL16_HIGHEST:
5604 case R_PPC64_DTPREL16_HIGHESTA:
5609 case R_PPC64_REL16_LO:
5610 case R_PPC64_REL16_HI:
5611 case R_PPC64_REL16_HA:
5612 case R_PPC64_REL16DX_HA:
5615 /* Not supported as a dynamic relocation. */
5616 case R_PPC64_ADDR64_LOCAL:
5617 if (bfd_link_pic (info))
5619 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5621 /* xgettext:c-format */
5622 info->callbacks->einfo (_("%H: %s reloc unsupported "
5623 "in shared libraries and PIEs.\n"),
5624 abfd, sec, rel->r_offset,
5625 ppc64_elf_howto_table[r_type]->name);
5626 bfd_set_error (bfd_error_bad_value);
5632 case R_PPC64_TOC16_DS:
5633 htab->do_multi_toc = 1;
5634 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5636 case R_PPC64_TOC16_LO:
5637 case R_PPC64_TOC16_HI:
5638 case R_PPC64_TOC16_HA:
5639 case R_PPC64_TOC16_LO_DS:
5640 sec->has_toc_reloc = 1;
5647 /* This relocation describes the C++ object vtable hierarchy.
5648 Reconstruct it for later use during GC. */
5649 case R_PPC64_GNU_VTINHERIT:
5650 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5654 /* This relocation describes which C++ vtable entries are actually
5655 used. Record for later use during GC. */
5656 case R_PPC64_GNU_VTENTRY:
5657 BFD_ASSERT (h != NULL);
5659 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5664 case R_PPC64_REL14_BRTAKEN:
5665 case R_PPC64_REL14_BRNTAKEN:
5667 asection *dest = NULL;
5669 /* Heuristic: If jumping outside our section, chances are
5670 we are going to need a stub. */
5673 /* If the sym is weak it may be overridden later, so
5674 don't assume we know where a weak sym lives. */
5675 if (h->root.type == bfd_link_hash_defined)
5676 dest = h->root.u.def.section;
5680 Elf_Internal_Sym *isym;
5682 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5687 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5691 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5700 if (h->root.root.string[0] == '.'
5701 && h->root.root.string[1] != '\0')
5702 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5704 if (h == tga || h == dottga)
5706 sec->has_tls_reloc = 1;
5708 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5709 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5710 /* We have a new-style __tls_get_addr call with
5714 /* Mark this section as having an old-style call. */
5715 sec->has_tls_get_addr_call = 1;
5717 plt_list = &h->plt.plist;
5720 /* We may need a .plt entry if the function this reloc
5721 refers to is in a shared lib. */
5723 && !update_plt_info (abfd, plt_list, rel->r_addend))
5727 case R_PPC64_ADDR14:
5728 case R_PPC64_ADDR14_BRNTAKEN:
5729 case R_PPC64_ADDR14_BRTAKEN:
5730 case R_PPC64_ADDR24:
5733 case R_PPC64_TPREL64:
5734 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5735 if (bfd_link_pic (info))
5736 info->flags |= DF_STATIC_TLS;
5739 case R_PPC64_DTPMOD64:
5740 if (rel + 1 < rel_end
5741 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5742 && rel[1].r_offset == rel->r_offset + 8)
5743 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5745 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5748 case R_PPC64_DTPREL64:
5749 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5751 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5752 && rel[-1].r_offset == rel->r_offset - 8)
5753 /* This is the second reloc of a dtpmod, dtprel pair.
5754 Don't mark with TLS_DTPREL. */
5758 sec->has_tls_reloc = 1;
5761 struct ppc_link_hash_entry *eh;
5762 eh = (struct ppc_link_hash_entry *) h;
5763 eh->tls_mask |= tls_type;
5766 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5767 rel->r_addend, tls_type))
5770 ppc64_sec = ppc64_elf_section_data (sec);
5771 if (ppc64_sec->sec_type != sec_toc)
5775 /* One extra to simplify get_tls_mask. */
5776 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5777 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5778 if (ppc64_sec->u.toc.symndx == NULL)
5780 amt = sec->size * sizeof (bfd_vma) / 8;
5781 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5782 if (ppc64_sec->u.toc.add == NULL)
5784 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5785 ppc64_sec->sec_type = sec_toc;
5787 BFD_ASSERT (rel->r_offset % 8 == 0);
5788 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5789 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5791 /* Mark the second slot of a GD or LD entry.
5792 -1 to indicate GD and -2 to indicate LD. */
5793 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5794 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5795 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5796 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5799 case R_PPC64_TPREL16:
5800 case R_PPC64_TPREL16_LO:
5801 case R_PPC64_TPREL16_HI:
5802 case R_PPC64_TPREL16_HA:
5803 case R_PPC64_TPREL16_DS:
5804 case R_PPC64_TPREL16_LO_DS:
5805 case R_PPC64_TPREL16_HIGH:
5806 case R_PPC64_TPREL16_HIGHA:
5807 case R_PPC64_TPREL16_HIGHER:
5808 case R_PPC64_TPREL16_HIGHERA:
5809 case R_PPC64_TPREL16_HIGHEST:
5810 case R_PPC64_TPREL16_HIGHESTA:
5811 if (bfd_link_pic (info))
5813 info->flags |= DF_STATIC_TLS;
5818 case R_PPC64_ADDR64:
5819 if (opd_sym_map != NULL
5820 && rel + 1 < rel_end
5821 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5824 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5828 Elf_Internal_Sym *isym;
5830 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5835 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5836 if (s != NULL && s != sec)
5837 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5842 case R_PPC64_ADDR16:
5843 case R_PPC64_ADDR16_DS:
5844 case R_PPC64_ADDR16_HA:
5845 case R_PPC64_ADDR16_HI:
5846 case R_PPC64_ADDR16_HIGH:
5847 case R_PPC64_ADDR16_HIGHA:
5848 case R_PPC64_ADDR16_HIGHER:
5849 case R_PPC64_ADDR16_HIGHERA:
5850 case R_PPC64_ADDR16_HIGHEST:
5851 case R_PPC64_ADDR16_HIGHESTA:
5852 case R_PPC64_ADDR16_LO:
5853 case R_PPC64_ADDR16_LO_DS:
5854 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5855 && rel->r_addend == 0)
5857 /* We may need a .plt entry if this reloc refers to a
5858 function in a shared lib. */
5859 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5861 h->pointer_equality_needed = 1;
5868 case R_PPC64_ADDR32:
5869 case R_PPC64_UADDR16:
5870 case R_PPC64_UADDR32:
5871 case R_PPC64_UADDR64:
5873 if (h != NULL && !bfd_link_pic (info))
5874 /* We may need a copy reloc. */
5877 /* Don't propagate .opd relocs. */
5878 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5881 /* If we are creating a shared library, and this is a reloc
5882 against a global symbol, or a non PC relative reloc
5883 against a local symbol, then we need to copy the reloc
5884 into the shared library. However, if we are linking with
5885 -Bsymbolic, we do not need to copy a reloc against a
5886 global symbol which is defined in an object we are
5887 including in the link (i.e., DEF_REGULAR is set). At
5888 this point we have not seen all the input files, so it is
5889 possible that DEF_REGULAR is not set now but will be set
5890 later (it is never cleared). In case of a weak definition,
5891 DEF_REGULAR may be cleared later by a strong definition in
5892 a shared library. We account for that possibility below by
5893 storing information in the dyn_relocs field of the hash
5894 table entry. A similar situation occurs when creating
5895 shared libraries and symbol visibility changes render the
5898 If on the other hand, we are creating an executable, we
5899 may need to keep relocations for symbols satisfied by a
5900 dynamic library if we manage to avoid copy relocs for the
5903 if ((bfd_link_pic (info)
5904 && (must_be_dyn_reloc (info, r_type)
5906 && (!SYMBOLIC_BIND (info, h)
5907 || h->root.type == bfd_link_hash_defweak
5908 || !h->def_regular))))
5909 || (ELIMINATE_COPY_RELOCS
5910 && !bfd_link_pic (info)
5912 && (h->root.type == bfd_link_hash_defweak
5913 || !h->def_regular))
5914 || (!bfd_link_pic (info)
5917 /* We must copy these reloc types into the output file.
5918 Create a reloc section in dynobj and make room for
5922 sreloc = _bfd_elf_make_dynamic_reloc_section
5923 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5929 /* If this is a global symbol, we count the number of
5930 relocations we need for this symbol. */
5933 struct elf_dyn_relocs *p;
5934 struct elf_dyn_relocs **head;
5936 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5938 if (p == NULL || p->sec != sec)
5940 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5950 if (!must_be_dyn_reloc (info, r_type))
5955 /* Track dynamic relocs needed for local syms too.
5956 We really need local syms available to do this
5958 struct ppc_dyn_relocs *p;
5959 struct ppc_dyn_relocs **head;
5960 bfd_boolean is_ifunc;
5963 Elf_Internal_Sym *isym;
5965 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5970 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5974 vpp = &elf_section_data (s)->local_dynrel;
5975 head = (struct ppc_dyn_relocs **) vpp;
5976 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5978 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5980 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5982 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5988 p->ifunc = is_ifunc;
6004 /* Merge backend specific data from an object file to the output
6005 object file when linking. */
6008 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6010 bfd *obfd = info->output_bfd;
6011 unsigned long iflags, oflags;
6013 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6016 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6019 if (!_bfd_generic_verify_endian_match (ibfd, info))
6022 iflags = elf_elfheader (ibfd)->e_flags;
6023 oflags = elf_elfheader (obfd)->e_flags;
6025 if (iflags & ~EF_PPC64_ABI)
6028 /* xgettext:c-format */
6029 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6030 bfd_set_error (bfd_error_bad_value);
6033 else if (iflags != oflags && iflags != 0)
6036 /* xgettext:c-format */
6037 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6038 ibfd, iflags, oflags);
6039 bfd_set_error (bfd_error_bad_value);
6043 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6045 /* Merge Tag_compatibility attributes and any common GNU ones. */
6046 _bfd_elf_merge_object_attributes (ibfd, info);
6052 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6054 /* Print normal ELF private data. */
6055 _bfd_elf_print_private_bfd_data (abfd, ptr);
6057 if (elf_elfheader (abfd)->e_flags != 0)
6061 fprintf (file, _("private flags = 0x%lx:"),
6062 elf_elfheader (abfd)->e_flags);
6064 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6065 fprintf (file, _(" [abiv%ld]"),
6066 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6073 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6074 of the code entry point, and its section, which must be in the same
6075 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6078 opd_entry_value (asection *opd_sec,
6080 asection **code_sec,
6082 bfd_boolean in_code_sec)
6084 bfd *opd_bfd = opd_sec->owner;
6085 Elf_Internal_Rela *relocs;
6086 Elf_Internal_Rela *lo, *hi, *look;
6089 /* No relocs implies we are linking a --just-symbols object, or looking
6090 at a final linked executable with addr2line or somesuch. */
6091 if (opd_sec->reloc_count == 0)
6093 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6095 if (contents == NULL)
6097 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6098 return (bfd_vma) -1;
6099 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6102 /* PR 17512: file: 64b9dfbb. */
6103 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6104 return (bfd_vma) -1;
6106 val = bfd_get_64 (opd_bfd, contents + offset);
6107 if (code_sec != NULL)
6109 asection *sec, *likely = NULL;
6115 && val < sec->vma + sec->size)
6121 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6123 && (sec->flags & SEC_LOAD) != 0
6124 && (sec->flags & SEC_ALLOC) != 0)
6129 if (code_off != NULL)
6130 *code_off = val - likely->vma;
6136 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6138 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6140 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6141 /* PR 17512: file: df8e1fd6. */
6143 return (bfd_vma) -1;
6145 /* Go find the opd reloc at the sym address. */
6147 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6151 look = lo + (hi - lo) / 2;
6152 if (look->r_offset < offset)
6154 else if (look->r_offset > offset)
6158 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6160 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6161 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6163 unsigned long symndx = ELF64_R_SYM (look->r_info);
6164 asection *sec = NULL;
6166 if (symndx >= symtab_hdr->sh_info
6167 && elf_sym_hashes (opd_bfd) != NULL)
6169 struct elf_link_hash_entry **sym_hashes;
6170 struct elf_link_hash_entry *rh;
6172 sym_hashes = elf_sym_hashes (opd_bfd);
6173 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6176 rh = elf_follow_link (rh);
6177 if (rh->root.type != bfd_link_hash_defined
6178 && rh->root.type != bfd_link_hash_defweak)
6180 if (rh->root.u.def.section->owner == opd_bfd)
6182 val = rh->root.u.def.value;
6183 sec = rh->root.u.def.section;
6190 Elf_Internal_Sym *sym;
6192 if (symndx < symtab_hdr->sh_info)
6194 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6197 size_t symcnt = symtab_hdr->sh_info;
6198 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6203 symtab_hdr->contents = (bfd_byte *) sym;
6209 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6215 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6218 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6219 val = sym->st_value;
6222 val += look->r_addend;
6223 if (code_off != NULL)
6225 if (code_sec != NULL)
6227 if (in_code_sec && *code_sec != sec)
6232 if (sec->output_section != NULL)
6233 val += sec->output_section->vma + sec->output_offset;
6242 /* If the ELF symbol SYM might be a function in SEC, return the
6243 function size and set *CODE_OFF to the function's entry point,
6244 otherwise return zero. */
6246 static bfd_size_type
6247 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6252 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6253 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6257 if (!(sym->flags & BSF_SYNTHETIC))
6258 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6260 if (strcmp (sym->section->name, ".opd") == 0)
6262 struct _opd_sec_data *opd = get_opd_info (sym->section);
6263 bfd_vma symval = sym->value;
6266 && opd->adjust != NULL
6267 && elf_section_data (sym->section)->relocs != NULL)
6269 /* opd_entry_value will use cached relocs that have been
6270 adjusted, but with raw symbols. That means both local
6271 and global symbols need adjusting. */
6272 long adjust = opd->adjust[OPD_NDX (symval)];
6278 if (opd_entry_value (sym->section, symval,
6279 &sec, code_off, TRUE) == (bfd_vma) -1)
6281 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6282 symbol. This size has nothing to do with the code size of the
6283 function, which is what we're supposed to return, but the
6284 code size isn't available without looking up the dot-sym.
6285 However, doing that would be a waste of time particularly
6286 since elf_find_function will look at the dot-sym anyway.
6287 Now, elf_find_function will keep the largest size of any
6288 function sym found at the code address of interest, so return
6289 1 here to avoid it incorrectly caching a larger function size
6290 for a small function. This does mean we return the wrong
6291 size for a new-ABI function of size 24, but all that does is
6292 disable caching for such functions. */
6298 if (sym->section != sec)
6300 *code_off = sym->value;
6307 /* Return true if symbol is defined in a regular object file. */
6310 is_static_defined (struct elf_link_hash_entry *h)
6312 return ((h->root.type == bfd_link_hash_defined
6313 || h->root.type == bfd_link_hash_defweak)
6314 && h->root.u.def.section != NULL
6315 && h->root.u.def.section->output_section != NULL);
6318 /* If FDH is a function descriptor symbol, return the associated code
6319 entry symbol if it is defined. Return NULL otherwise. */
6321 static struct ppc_link_hash_entry *
6322 defined_code_entry (struct ppc_link_hash_entry *fdh)
6324 if (fdh->is_func_descriptor)
6326 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6327 if (fh->elf.root.type == bfd_link_hash_defined
6328 || fh->elf.root.type == bfd_link_hash_defweak)
6334 /* If FH is a function code entry symbol, return the associated
6335 function descriptor symbol if it is defined. Return NULL otherwise. */
6337 static struct ppc_link_hash_entry *
6338 defined_func_desc (struct ppc_link_hash_entry *fh)
6341 && fh->oh->is_func_descriptor)
6343 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6344 if (fdh->elf.root.type == bfd_link_hash_defined
6345 || fdh->elf.root.type == bfd_link_hash_defweak)
6351 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6353 /* Garbage collect sections, after first dealing with dot-symbols. */
6356 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6358 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6360 if (htab != NULL && htab->need_func_desc_adj)
6362 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6363 htab->need_func_desc_adj = 0;
6365 return bfd_elf_gc_sections (abfd, info);
6368 /* Mark all our entry sym sections, both opd and code section. */
6371 ppc64_elf_gc_keep (struct bfd_link_info *info)
6373 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6374 struct bfd_sym_chain *sym;
6379 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6381 struct ppc_link_hash_entry *eh, *fh;
6384 eh = (struct ppc_link_hash_entry *)
6385 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6388 if (eh->elf.root.type != bfd_link_hash_defined
6389 && eh->elf.root.type != bfd_link_hash_defweak)
6392 fh = defined_code_entry (eh);
6395 sec = fh->elf.root.u.def.section;
6396 sec->flags |= SEC_KEEP;
6398 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6399 && opd_entry_value (eh->elf.root.u.def.section,
6400 eh->elf.root.u.def.value,
6401 &sec, NULL, FALSE) != (bfd_vma) -1)
6402 sec->flags |= SEC_KEEP;
6404 sec = eh->elf.root.u.def.section;
6405 sec->flags |= SEC_KEEP;
6409 /* Mark sections containing dynamically referenced symbols. When
6410 building shared libraries, we must assume that any visible symbol is
6414 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6416 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6417 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6418 struct ppc_link_hash_entry *fdh;
6419 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6421 /* Dynamic linking info is on the func descriptor sym. */
6422 fdh = defined_func_desc (eh);
6426 if ((eh->elf.root.type == bfd_link_hash_defined
6427 || eh->elf.root.type == bfd_link_hash_defweak)
6428 && (eh->elf.ref_dynamic
6429 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6430 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6431 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6432 && (!bfd_link_executable (info)
6433 || info->gc_keep_exported
6434 || info->export_dynamic
6437 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6438 && (eh->elf.versioned >= versioned
6439 || !bfd_hide_sym_by_version (info->version_info,
6440 eh->elf.root.root.string)))))
6443 struct ppc_link_hash_entry *fh;
6445 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6447 /* Function descriptor syms cause the associated
6448 function code sym section to be marked. */
6449 fh = defined_code_entry (eh);
6452 code_sec = fh->elf.root.u.def.section;
6453 code_sec->flags |= SEC_KEEP;
6455 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6456 && opd_entry_value (eh->elf.root.u.def.section,
6457 eh->elf.root.u.def.value,
6458 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6459 code_sec->flags |= SEC_KEEP;
6465 /* Return the section that should be marked against GC for a given
6469 ppc64_elf_gc_mark_hook (asection *sec,
6470 struct bfd_link_info *info,
6471 Elf_Internal_Rela *rel,
6472 struct elf_link_hash_entry *h,
6473 Elf_Internal_Sym *sym)
6477 /* Syms return NULL if we're marking .opd, so we avoid marking all
6478 function sections, as all functions are referenced in .opd. */
6480 if (get_opd_info (sec) != NULL)
6485 enum elf_ppc64_reloc_type r_type;
6486 struct ppc_link_hash_entry *eh, *fh, *fdh;
6488 r_type = ELF64_R_TYPE (rel->r_info);
6491 case R_PPC64_GNU_VTINHERIT:
6492 case R_PPC64_GNU_VTENTRY:
6496 switch (h->root.type)
6498 case bfd_link_hash_defined:
6499 case bfd_link_hash_defweak:
6500 eh = (struct ppc_link_hash_entry *) h;
6501 fdh = defined_func_desc (eh);
6504 /* -mcall-aixdesc code references the dot-symbol on
6505 a call reloc. Mark the function descriptor too
6506 against garbage collection. */
6508 if (fdh->elf.u.weakdef != NULL)
6509 fdh->elf.u.weakdef->mark = 1;
6513 /* Function descriptor syms cause the associated
6514 function code sym section to be marked. */
6515 fh = defined_code_entry (eh);
6518 /* They also mark their opd section. */
6519 eh->elf.root.u.def.section->gc_mark = 1;
6521 rsec = fh->elf.root.u.def.section;
6523 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6524 && opd_entry_value (eh->elf.root.u.def.section,
6525 eh->elf.root.u.def.value,
6526 &rsec, NULL, FALSE) != (bfd_vma) -1)
6527 eh->elf.root.u.def.section->gc_mark = 1;
6529 rsec = h->root.u.def.section;
6532 case bfd_link_hash_common:
6533 rsec = h->root.u.c.p->section;
6537 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6543 struct _opd_sec_data *opd;
6545 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6546 opd = get_opd_info (rsec);
6547 if (opd != NULL && opd->func_sec != NULL)
6551 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6558 /* Update the .got, .plt. and dynamic reloc reference counts for the
6559 section being removed. */
6562 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6563 asection *sec, const Elf_Internal_Rela *relocs)
6565 struct ppc_link_hash_table *htab;
6566 Elf_Internal_Shdr *symtab_hdr;
6567 struct elf_link_hash_entry **sym_hashes;
6568 struct got_entry **local_got_ents;
6569 const Elf_Internal_Rela *rel, *relend;
6571 if (bfd_link_relocatable (info))
6574 if ((sec->flags & SEC_ALLOC) == 0)
6577 elf_section_data (sec)->local_dynrel = NULL;
6579 htab = ppc_hash_table (info);
6583 symtab_hdr = &elf_symtab_hdr (abfd);
6584 sym_hashes = elf_sym_hashes (abfd);
6585 local_got_ents = elf_local_got_ents (abfd);
6587 relend = relocs + sec->reloc_count;
6588 for (rel = relocs; rel < relend; rel++)
6590 unsigned long r_symndx;
6591 enum elf_ppc64_reloc_type r_type;
6592 struct elf_link_hash_entry *h = NULL;
6593 struct plt_entry **plt_list;
6594 unsigned char tls_type = 0;
6596 r_symndx = ELF64_R_SYM (rel->r_info);
6597 r_type = ELF64_R_TYPE (rel->r_info);
6598 if (r_symndx >= symtab_hdr->sh_info)
6600 struct ppc_link_hash_entry *eh;
6601 struct elf_dyn_relocs **pp;
6602 struct elf_dyn_relocs *p;
6604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6605 h = elf_follow_link (h);
6606 eh = (struct ppc_link_hash_entry *) h;
6608 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6611 /* Everything must go for SEC. */
6619 case R_PPC64_GOT_TLSLD16:
6620 case R_PPC64_GOT_TLSLD16_LO:
6621 case R_PPC64_GOT_TLSLD16_HI:
6622 case R_PPC64_GOT_TLSLD16_HA:
6623 tls_type = TLS_TLS | TLS_LD;
6626 case R_PPC64_GOT_TLSGD16:
6627 case R_PPC64_GOT_TLSGD16_LO:
6628 case R_PPC64_GOT_TLSGD16_HI:
6629 case R_PPC64_GOT_TLSGD16_HA:
6630 tls_type = TLS_TLS | TLS_GD;
6633 case R_PPC64_GOT_TPREL16_DS:
6634 case R_PPC64_GOT_TPREL16_LO_DS:
6635 case R_PPC64_GOT_TPREL16_HI:
6636 case R_PPC64_GOT_TPREL16_HA:
6637 tls_type = TLS_TLS | TLS_TPREL;
6640 case R_PPC64_GOT_DTPREL16_DS:
6641 case R_PPC64_GOT_DTPREL16_LO_DS:
6642 case R_PPC64_GOT_DTPREL16_HI:
6643 case R_PPC64_GOT_DTPREL16_HA:
6644 tls_type = TLS_TLS | TLS_DTPREL;
6648 case R_PPC64_GOT16_DS:
6649 case R_PPC64_GOT16_HA:
6650 case R_PPC64_GOT16_HI:
6651 case R_PPC64_GOT16_LO:
6652 case R_PPC64_GOT16_LO_DS:
6655 struct got_entry *ent;
6660 ent = local_got_ents[r_symndx];
6662 for (; ent != NULL; ent = ent->next)
6663 if (ent->addend == rel->r_addend
6664 && ent->owner == abfd
6665 && ent->tls_type == tls_type)
6669 if (ent->got.refcount > 0)
6670 ent->got.refcount -= 1;
6674 case R_PPC64_PLT16_HA:
6675 case R_PPC64_PLT16_HI:
6676 case R_PPC64_PLT16_LO:
6680 case R_PPC64_REL14_BRNTAKEN:
6681 case R_PPC64_REL14_BRTAKEN:
6685 plt_list = &h->plt.plist;
6686 else if (local_got_ents != NULL)
6688 struct plt_entry **local_plt = (struct plt_entry **)
6689 (local_got_ents + symtab_hdr->sh_info);
6690 unsigned char *local_got_tls_masks = (unsigned char *)
6691 (local_plt + symtab_hdr->sh_info);
6692 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6693 plt_list = local_plt + r_symndx;
6697 struct plt_entry *ent;
6699 for (ent = *plt_list; ent != NULL; ent = ent->next)
6700 if (ent->addend == rel->r_addend)
6702 if (ent != NULL && ent->plt.refcount > 0)
6703 ent->plt.refcount -= 1;
6714 /* The maximum size of .sfpr. */
6715 #define SFPR_MAX (218*4)
6717 struct sfpr_def_parms
6719 const char name[12];
6720 unsigned char lo, hi;
6721 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6722 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6725 /* Auto-generate _save*, _rest* functions in .sfpr.
6726 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6730 sfpr_define (struct bfd_link_info *info,
6731 const struct sfpr_def_parms *parm,
6734 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6736 size_t len = strlen (parm->name);
6737 bfd_boolean writing = FALSE;
6743 memcpy (sym, parm->name, len);
6746 for (i = parm->lo; i <= parm->hi; i++)
6748 struct ppc_link_hash_entry *h;
6750 sym[len + 0] = i / 10 + '0';
6751 sym[len + 1] = i % 10 + '0';
6752 h = (struct ppc_link_hash_entry *)
6753 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6754 if (stub_sec != NULL)
6757 && h->elf.root.type == bfd_link_hash_defined
6758 && h->elf.root.u.def.section == htab->sfpr)
6760 struct elf_link_hash_entry *s;
6762 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6763 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6766 if (s->root.type == bfd_link_hash_new
6767 || (s->root.type = bfd_link_hash_defined
6768 && s->root.u.def.section == stub_sec))
6770 s->root.type = bfd_link_hash_defined;
6771 s->root.u.def.section = stub_sec;
6772 s->root.u.def.value = (stub_sec->size
6773 + h->elf.root.u.def.value);
6776 s->ref_regular_nonweak = 1;
6777 s->forced_local = 1;
6779 s->root.linker_def = 1;
6787 if (!h->elf.def_regular)
6789 h->elf.root.type = bfd_link_hash_defined;
6790 h->elf.root.u.def.section = htab->sfpr;
6791 h->elf.root.u.def.value = htab->sfpr->size;
6792 h->elf.type = STT_FUNC;
6793 h->elf.def_regular = 1;
6795 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6797 if (htab->sfpr->contents == NULL)
6799 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6800 if (htab->sfpr->contents == NULL)
6807 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6809 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6811 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6812 htab->sfpr->size = p - htab->sfpr->contents;
6820 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6822 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6827 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6829 p = savegpr0 (abfd, p, r);
6830 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6832 bfd_put_32 (abfd, BLR, p);
6837 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6839 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6844 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6846 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6848 p = restgpr0 (abfd, p, r);
6849 bfd_put_32 (abfd, MTLR_R0, p);
6853 p = restgpr0 (abfd, p, 30);
6854 p = restgpr0 (abfd, p, 31);
6856 bfd_put_32 (abfd, BLR, p);
6861 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6863 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6868 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6870 p = savegpr1 (abfd, p, r);
6871 bfd_put_32 (abfd, BLR, p);
6876 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6878 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6883 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6885 p = restgpr1 (abfd, p, r);
6886 bfd_put_32 (abfd, BLR, p);
6891 savefpr (bfd *abfd, bfd_byte *p, int r)
6893 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6898 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6900 p = savefpr (abfd, p, r);
6901 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6903 bfd_put_32 (abfd, BLR, p);
6908 restfpr (bfd *abfd, bfd_byte *p, int r)
6910 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6915 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6917 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6919 p = restfpr (abfd, p, r);
6920 bfd_put_32 (abfd, MTLR_R0, p);
6924 p = restfpr (abfd, p, 30);
6925 p = restfpr (abfd, p, 31);
6927 bfd_put_32 (abfd, BLR, p);
6932 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6934 p = savefpr (abfd, p, r);
6935 bfd_put_32 (abfd, BLR, p);
6940 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6942 p = restfpr (abfd, p, r);
6943 bfd_put_32 (abfd, BLR, p);
6948 savevr (bfd *abfd, bfd_byte *p, int r)
6950 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6952 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6957 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6959 p = savevr (abfd, p, r);
6960 bfd_put_32 (abfd, BLR, p);
6965 restvr (bfd *abfd, bfd_byte *p, int r)
6967 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6969 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6974 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6976 p = restvr (abfd, p, r);
6977 bfd_put_32 (abfd, BLR, p);
6981 /* Called via elf_link_hash_traverse to transfer dynamic linking
6982 information on function code symbol entries to their corresponding
6983 function descriptor symbol entries. */
6986 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6988 struct bfd_link_info *info;
6989 struct ppc_link_hash_table *htab;
6990 struct ppc_link_hash_entry *fh;
6991 struct ppc_link_hash_entry *fdh;
6992 bfd_boolean force_local;
6994 fh = (struct ppc_link_hash_entry *) h;
6995 if (fh->elf.root.type == bfd_link_hash_indirect)
7001 if (fh->elf.root.root.string[0] != '.'
7002 || fh->elf.root.root.string[1] == '\0')
7006 htab = ppc_hash_table (info);
7010 /* Find the corresponding function descriptor symbol. */
7011 fdh = lookup_fdh (fh, htab);
7013 /* Resolve undefined references to dot-symbols as the value
7014 in the function descriptor, if we have one in a regular object.
7015 This is to satisfy cases like ".quad .foo". Calls to functions
7016 in dynamic objects are handled elsewhere. */
7017 if ((fh->elf.root.type == bfd_link_hash_undefined
7018 || fh->elf.root.type == bfd_link_hash_undefweak)
7019 && (fdh->elf.root.type == bfd_link_hash_defined
7020 || fdh->elf.root.type == bfd_link_hash_defweak)
7021 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7022 && opd_entry_value (fdh->elf.root.u.def.section,
7023 fdh->elf.root.u.def.value,
7024 &fh->elf.root.u.def.section,
7025 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7027 fh->elf.root.type = fdh->elf.root.type;
7028 fh->elf.forced_local = 1;
7029 fh->elf.def_regular = fdh->elf.def_regular;
7030 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7033 if (!fh->elf.dynamic)
7035 struct plt_entry *ent;
7037 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7038 if (ent->plt.refcount > 0)
7044 /* Create a descriptor as undefined if necessary. */
7046 && !bfd_link_executable (info)
7047 && (fh->elf.root.type == bfd_link_hash_undefined
7048 || fh->elf.root.type == bfd_link_hash_undefweak))
7050 fdh = make_fdh (info, fh);
7055 /* We can't support overriding of symbols on a fake descriptor. */
7058 && (fh->elf.root.type == bfd_link_hash_defined
7059 || fh->elf.root.type == bfd_link_hash_defweak))
7060 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7062 /* Transfer dynamic linking information to the function descriptor. */
7065 fdh->elf.ref_regular |= fh->elf.ref_regular;
7066 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7067 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7068 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7069 fdh->elf.dynamic |= fh->elf.dynamic;
7070 fdh->elf.needs_plt |= (fh->elf.needs_plt
7071 || fh->elf.type == STT_FUNC
7072 || fh->elf.type == STT_GNU_IFUNC);
7073 move_plt_plist (fh, fdh);
7075 if (!fdh->elf.forced_local
7076 && fh->elf.dynindx != -1)
7077 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7081 /* Now that the info is on the function descriptor, clear the
7082 function code sym info. Any function code syms for which we
7083 don't have a definition in a regular file, we force local.
7084 This prevents a shared library from exporting syms that have
7085 been imported from another library. Function code syms that
7086 are really in the library we must leave global to prevent the
7087 linker dragging in a definition from a static library. */
7088 force_local = (!fh->elf.def_regular
7090 || !fdh->elf.def_regular
7091 || fdh->elf.forced_local);
7092 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7097 static const struct sfpr_def_parms save_res_funcs[] =
7099 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7100 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7101 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7102 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7103 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7104 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7105 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7106 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7107 { "._savef", 14, 31, savefpr, savefpr1_tail },
7108 { "._restf", 14, 31, restfpr, restfpr1_tail },
7109 { "_savevr_", 20, 31, savevr, savevr_tail },
7110 { "_restvr_", 20, 31, restvr, restvr_tail }
7113 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7114 this hook to a) provide some gcc support functions, and b) transfer
7115 dynamic linking information gathered so far on function code symbol
7116 entries, to their corresponding function descriptor symbol entries. */
7119 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7120 struct bfd_link_info *info)
7122 struct ppc_link_hash_table *htab;
7124 htab = ppc_hash_table (info);
7128 /* Provide any missing _save* and _rest* functions. */
7129 if (htab->sfpr != NULL)
7133 htab->sfpr->size = 0;
7134 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7135 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7137 if (htab->sfpr->size == 0)
7138 htab->sfpr->flags |= SEC_EXCLUDE;
7141 if (bfd_link_relocatable (info))
7144 if (htab->elf.hgot != NULL)
7146 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7147 /* Make .TOC. defined so as to prevent it being made dynamic.
7148 The wrong value here is fixed later in ppc64_elf_set_toc. */
7149 if (!htab->elf.hgot->def_regular
7150 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7152 htab->elf.hgot->root.type = bfd_link_hash_defined;
7153 htab->elf.hgot->root.u.def.value = 0;
7154 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7155 htab->elf.hgot->def_regular = 1;
7156 htab->elf.hgot->root.linker_def = 1;
7158 htab->elf.hgot->type = STT_OBJECT;
7159 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7163 if (htab->need_func_desc_adj)
7165 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7166 htab->need_func_desc_adj = 0;
7172 /* Return true if we have dynamic relocs against H that apply to
7173 read-only sections. */
7176 readonly_dynrelocs (struct elf_link_hash_entry *h)
7178 struct ppc_link_hash_entry *eh;
7179 struct elf_dyn_relocs *p;
7181 eh = (struct ppc_link_hash_entry *) h;
7182 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7184 asection *s = p->sec->output_section;
7186 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7192 /* Return true if we have dynamic relocs against H or any of its weak
7193 aliases, that apply to read-only sections. */
7196 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7198 struct ppc_link_hash_entry *eh;
7200 eh = (struct ppc_link_hash_entry *) h;
7203 if (readonly_dynrelocs (&eh->elf))
7206 } while (eh != NULL && &eh->elf != h);
7211 /* Return whether EH has pc-relative dynamic relocs. */
7214 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7216 struct elf_dyn_relocs *p;
7218 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7219 if (p->pc_count != 0)
7224 /* Return true if a global entry stub will be created for H. Valid
7225 for ELFv2 before plt entries have been allocated. */
7228 global_entry_stub (struct elf_link_hash_entry *h)
7230 struct plt_entry *pent;
7232 if (!h->pointer_equality_needed
7236 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7237 if (pent->plt.refcount > 0
7238 && pent->addend == 0)
7244 /* Adjust a symbol defined by a dynamic object and referenced by a
7245 regular object. The current definition is in some section of the
7246 dynamic object, but we're not including those sections. We have to
7247 change the definition to something the rest of the link can
7251 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7252 struct elf_link_hash_entry *h)
7254 struct ppc_link_hash_table *htab;
7257 htab = ppc_hash_table (info);
7261 /* Deal with function syms. */
7262 if (h->type == STT_FUNC
7263 || h->type == STT_GNU_IFUNC
7266 /* Clear procedure linkage table information for any symbol that
7267 won't need a .plt entry. */
7268 struct plt_entry *ent;
7269 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7270 if (ent->plt.refcount > 0)
7273 || (h->type != STT_GNU_IFUNC
7274 && (SYMBOL_CALLS_LOCAL (info, h)
7275 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7276 && h->root.type == bfd_link_hash_undefweak)))
7277 || ((struct ppc_link_hash_entry *) h)->save_res)
7279 h->plt.plist = NULL;
7281 h->pointer_equality_needed = 0;
7283 else if (abiversion (info->output_bfd) >= 2)
7285 /* Taking a function's address in a read/write section
7286 doesn't require us to define the function symbol in the
7287 executable on a global entry stub. A dynamic reloc can
7288 be used instead. The reason we prefer a few more dynamic
7289 relocs is that calling via a global entry stub costs a
7290 few more instructions, and pointer_equality_needed causes
7291 extra work in ld.so when resolving these symbols. */
7292 if (global_entry_stub (h)
7293 && !alias_readonly_dynrelocs (h))
7295 h->pointer_equality_needed = 0;
7296 /* After adjust_dynamic_symbol, non_got_ref set in
7297 the non-pic case means that dyn_relocs for this
7298 symbol should be discarded. */
7302 /* If making a plt entry, then we don't need copy relocs. */
7307 h->plt.plist = NULL;
7309 /* If this is a weak symbol, and there is a real definition, the
7310 processor independent code will have arranged for us to see the
7311 real definition first, and we can just use the same value. */
7312 if (h->u.weakdef != NULL)
7314 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7315 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7316 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7317 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7318 if (ELIMINATE_COPY_RELOCS)
7319 h->non_got_ref = h->u.weakdef->non_got_ref;
7323 /* If we are creating a shared library, we must presume that the
7324 only references to the symbol are via the global offset table.
7325 For such cases we need not do anything here; the relocations will
7326 be handled correctly by relocate_section. */
7327 if (bfd_link_pic (info))
7330 /* If there are no references to this symbol that do not use the
7331 GOT, we don't need to generate a copy reloc. */
7332 if (!h->non_got_ref)
7335 /* Don't generate a copy reloc for symbols defined in the executable. */
7336 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7338 /* If -z nocopyreloc was given, don't generate them either. */
7339 || info->nocopyreloc
7341 /* If we didn't find any dynamic relocs in read-only sections, then
7342 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7343 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7345 /* Protected variables do not work with .dynbss. The copy in
7346 .dynbss won't be used by the shared library with the protected
7347 definition for the variable. Text relocations are preferable
7348 to an incorrect program. */
7349 || h->protected_def)
7355 if (h->plt.plist != NULL)
7357 /* We should never get here, but unfortunately there are versions
7358 of gcc out there that improperly (for this ABI) put initialized
7359 function pointers, vtable refs and suchlike in read-only
7360 sections. Allow them to proceed, but warn that this might
7361 break at runtime. */
7362 info->callbacks->einfo
7363 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7364 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7365 h->root.root.string);
7368 /* This is a reference to a symbol defined by a dynamic object which
7369 is not a function. */
7371 /* We must allocate the symbol in our .dynbss section, which will
7372 become part of the .bss section of the executable. There will be
7373 an entry for this symbol in the .dynsym section. The dynamic
7374 object will contain position independent code, so all references
7375 from the dynamic object to this symbol will go through the global
7376 offset table. The dynamic linker will use the .dynsym entry to
7377 determine the address it must put in the global offset table, so
7378 both the dynamic object and the regular object will refer to the
7379 same memory location for the variable. */
7381 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7382 to copy the initial value out of the dynamic object and into the
7383 runtime process image. We need to remember the offset into the
7384 .rela.bss section we are going to use. */
7385 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7387 s = htab->elf.sdynrelro;
7388 srel = htab->elf.sreldynrelro;
7392 s = htab->elf.sdynbss;
7393 srel = htab->elf.srelbss;
7395 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7397 srel->size += sizeof (Elf64_External_Rela);
7401 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7404 /* If given a function descriptor symbol, hide both the function code
7405 sym and the descriptor. */
7407 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7408 struct elf_link_hash_entry *h,
7409 bfd_boolean force_local)
7411 struct ppc_link_hash_entry *eh;
7412 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7414 eh = (struct ppc_link_hash_entry *) h;
7415 if (eh->is_func_descriptor)
7417 struct ppc_link_hash_entry *fh = eh->oh;
7422 struct elf_link_hash_table *htab = elf_hash_table (info);
7425 /* We aren't supposed to use alloca in BFD because on
7426 systems which do not have alloca the version in libiberty
7427 calls xmalloc, which might cause the program to crash
7428 when it runs out of memory. This function doesn't have a
7429 return status, so there's no way to gracefully return an
7430 error. So cheat. We know that string[-1] can be safely
7431 accessed; It's either a string in an ELF string table,
7432 or allocated in an objalloc structure. */
7434 p = eh->elf.root.root.string - 1;
7437 fh = (struct ppc_link_hash_entry *)
7438 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7441 /* Unfortunately, if it so happens that the string we were
7442 looking for was allocated immediately before this string,
7443 then we overwrote the string terminator. That's the only
7444 reason the lookup should fail. */
7447 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7448 while (q >= eh->elf.root.root.string && *q == *p)
7450 if (q < eh->elf.root.root.string && *p == '.')
7451 fh = (struct ppc_link_hash_entry *)
7452 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7461 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7466 get_sym_h (struct elf_link_hash_entry **hp,
7467 Elf_Internal_Sym **symp,
7469 unsigned char **tls_maskp,
7470 Elf_Internal_Sym **locsymsp,
7471 unsigned long r_symndx,
7474 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7476 if (r_symndx >= symtab_hdr->sh_info)
7478 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7479 struct elf_link_hash_entry *h;
7481 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7482 h = elf_follow_link (h);
7490 if (symsecp != NULL)
7492 asection *symsec = NULL;
7493 if (h->root.type == bfd_link_hash_defined
7494 || h->root.type == bfd_link_hash_defweak)
7495 symsec = h->root.u.def.section;
7499 if (tls_maskp != NULL)
7501 struct ppc_link_hash_entry *eh;
7503 eh = (struct ppc_link_hash_entry *) h;
7504 *tls_maskp = &eh->tls_mask;
7509 Elf_Internal_Sym *sym;
7510 Elf_Internal_Sym *locsyms = *locsymsp;
7512 if (locsyms == NULL)
7514 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7515 if (locsyms == NULL)
7516 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7517 symtab_hdr->sh_info,
7518 0, NULL, NULL, NULL);
7519 if (locsyms == NULL)
7521 *locsymsp = locsyms;
7523 sym = locsyms + r_symndx;
7531 if (symsecp != NULL)
7532 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7534 if (tls_maskp != NULL)
7536 struct got_entry **lgot_ents;
7537 unsigned char *tls_mask;
7540 lgot_ents = elf_local_got_ents (ibfd);
7541 if (lgot_ents != NULL)
7543 struct plt_entry **local_plt = (struct plt_entry **)
7544 (lgot_ents + symtab_hdr->sh_info);
7545 unsigned char *lgot_masks = (unsigned char *)
7546 (local_plt + symtab_hdr->sh_info);
7547 tls_mask = &lgot_masks[r_symndx];
7549 *tls_maskp = tls_mask;
7555 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7556 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7557 type suitable for optimization, and 1 otherwise. */
7560 get_tls_mask (unsigned char **tls_maskp,
7561 unsigned long *toc_symndx,
7562 bfd_vma *toc_addend,
7563 Elf_Internal_Sym **locsymsp,
7564 const Elf_Internal_Rela *rel,
7567 unsigned long r_symndx;
7569 struct elf_link_hash_entry *h;
7570 Elf_Internal_Sym *sym;
7574 r_symndx = ELF64_R_SYM (rel->r_info);
7575 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7578 if ((*tls_maskp != NULL && **tls_maskp != 0)
7580 || ppc64_elf_section_data (sec) == NULL
7581 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7584 /* Look inside a TOC section too. */
7587 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7588 off = h->root.u.def.value;
7591 off = sym->st_value;
7592 off += rel->r_addend;
7593 BFD_ASSERT (off % 8 == 0);
7594 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7595 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7596 if (toc_symndx != NULL)
7597 *toc_symndx = r_symndx;
7598 if (toc_addend != NULL)
7599 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7600 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7602 if ((h == NULL || is_static_defined (h))
7603 && (next_r == -1 || next_r == -2))
7608 /* Find (or create) an entry in the tocsave hash table. */
7610 static struct tocsave_entry *
7611 tocsave_find (struct ppc_link_hash_table *htab,
7612 enum insert_option insert,
7613 Elf_Internal_Sym **local_syms,
7614 const Elf_Internal_Rela *irela,
7617 unsigned long r_indx;
7618 struct elf_link_hash_entry *h;
7619 Elf_Internal_Sym *sym;
7620 struct tocsave_entry ent, *p;
7622 struct tocsave_entry **slot;
7624 r_indx = ELF64_R_SYM (irela->r_info);
7625 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7627 if (ent.sec == NULL || ent.sec->output_section == NULL)
7630 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7635 ent.offset = h->root.u.def.value;
7637 ent.offset = sym->st_value;
7638 ent.offset += irela->r_addend;
7640 hash = tocsave_htab_hash (&ent);
7641 slot = ((struct tocsave_entry **)
7642 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7648 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7657 /* Adjust all global syms defined in opd sections. In gcc generated
7658 code for the old ABI, these will already have been done. */
7661 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7663 struct ppc_link_hash_entry *eh;
7665 struct _opd_sec_data *opd;
7667 if (h->root.type == bfd_link_hash_indirect)
7670 if (h->root.type != bfd_link_hash_defined
7671 && h->root.type != bfd_link_hash_defweak)
7674 eh = (struct ppc_link_hash_entry *) h;
7675 if (eh->adjust_done)
7678 sym_sec = eh->elf.root.u.def.section;
7679 opd = get_opd_info (sym_sec);
7680 if (opd != NULL && opd->adjust != NULL)
7682 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7685 /* This entry has been deleted. */
7686 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7689 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7690 if (discarded_section (dsec))
7692 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7696 eh->elf.root.u.def.value = 0;
7697 eh->elf.root.u.def.section = dsec;
7700 eh->elf.root.u.def.value += adjust;
7701 eh->adjust_done = 1;
7706 /* Handles decrementing dynamic reloc counts for the reloc specified by
7707 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7708 have already been determined. */
7711 dec_dynrel_count (bfd_vma r_info,
7713 struct bfd_link_info *info,
7714 Elf_Internal_Sym **local_syms,
7715 struct elf_link_hash_entry *h,
7716 Elf_Internal_Sym *sym)
7718 enum elf_ppc64_reloc_type r_type;
7719 asection *sym_sec = NULL;
7721 /* Can this reloc be dynamic? This switch, and later tests here
7722 should be kept in sync with the code in check_relocs. */
7723 r_type = ELF64_R_TYPE (r_info);
7729 case R_PPC64_TPREL16:
7730 case R_PPC64_TPREL16_LO:
7731 case R_PPC64_TPREL16_HI:
7732 case R_PPC64_TPREL16_HA:
7733 case R_PPC64_TPREL16_DS:
7734 case R_PPC64_TPREL16_LO_DS:
7735 case R_PPC64_TPREL16_HIGH:
7736 case R_PPC64_TPREL16_HIGHA:
7737 case R_PPC64_TPREL16_HIGHER:
7738 case R_PPC64_TPREL16_HIGHERA:
7739 case R_PPC64_TPREL16_HIGHEST:
7740 case R_PPC64_TPREL16_HIGHESTA:
7741 if (!bfd_link_pic (info))
7744 case R_PPC64_TPREL64:
7745 case R_PPC64_DTPMOD64:
7746 case R_PPC64_DTPREL64:
7747 case R_PPC64_ADDR64:
7751 case R_PPC64_ADDR14:
7752 case R_PPC64_ADDR14_BRNTAKEN:
7753 case R_PPC64_ADDR14_BRTAKEN:
7754 case R_PPC64_ADDR16:
7755 case R_PPC64_ADDR16_DS:
7756 case R_PPC64_ADDR16_HA:
7757 case R_PPC64_ADDR16_HI:
7758 case R_PPC64_ADDR16_HIGH:
7759 case R_PPC64_ADDR16_HIGHA:
7760 case R_PPC64_ADDR16_HIGHER:
7761 case R_PPC64_ADDR16_HIGHERA:
7762 case R_PPC64_ADDR16_HIGHEST:
7763 case R_PPC64_ADDR16_HIGHESTA:
7764 case R_PPC64_ADDR16_LO:
7765 case R_PPC64_ADDR16_LO_DS:
7766 case R_PPC64_ADDR24:
7767 case R_PPC64_ADDR32:
7768 case R_PPC64_UADDR16:
7769 case R_PPC64_UADDR32:
7770 case R_PPC64_UADDR64:
7775 if (local_syms != NULL)
7777 unsigned long r_symndx;
7778 bfd *ibfd = sec->owner;
7780 r_symndx = ELF64_R_SYM (r_info);
7781 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7785 if ((bfd_link_pic (info)
7786 && (must_be_dyn_reloc (info, r_type)
7788 && (!SYMBOLIC_BIND (info, h)
7789 || h->root.type == bfd_link_hash_defweak
7790 || !h->def_regular))))
7791 || (ELIMINATE_COPY_RELOCS
7792 && !bfd_link_pic (info)
7794 && (h->root.type == bfd_link_hash_defweak
7795 || !h->def_regular)))
7802 struct elf_dyn_relocs *p;
7803 struct elf_dyn_relocs **pp;
7804 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7806 /* elf_gc_sweep may have already removed all dyn relocs associated
7807 with local syms for a given section. Also, symbol flags are
7808 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7809 report a dynreloc miscount. */
7810 if (*pp == NULL && info->gc_sections)
7813 while ((p = *pp) != NULL)
7817 if (!must_be_dyn_reloc (info, r_type))
7829 struct ppc_dyn_relocs *p;
7830 struct ppc_dyn_relocs **pp;
7832 bfd_boolean is_ifunc;
7834 if (local_syms == NULL)
7835 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7836 if (sym_sec == NULL)
7839 vpp = &elf_section_data (sym_sec)->local_dynrel;
7840 pp = (struct ppc_dyn_relocs **) vpp;
7842 if (*pp == NULL && info->gc_sections)
7845 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7846 while ((p = *pp) != NULL)
7848 if (p->sec == sec && p->ifunc == is_ifunc)
7859 /* xgettext:c-format */
7860 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7862 bfd_set_error (bfd_error_bad_value);
7866 /* Remove unused Official Procedure Descriptor entries. Currently we
7867 only remove those associated with functions in discarded link-once
7868 sections, or weakly defined functions that have been overridden. It
7869 would be possible to remove many more entries for statically linked
7873 ppc64_elf_edit_opd (struct bfd_link_info *info)
7876 bfd_boolean some_edited = FALSE;
7877 asection *need_pad = NULL;
7878 struct ppc_link_hash_table *htab;
7880 htab = ppc_hash_table (info);
7884 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7887 Elf_Internal_Rela *relstart, *rel, *relend;
7888 Elf_Internal_Shdr *symtab_hdr;
7889 Elf_Internal_Sym *local_syms;
7890 struct _opd_sec_data *opd;
7891 bfd_boolean need_edit, add_aux_fields, broken;
7892 bfd_size_type cnt_16b = 0;
7894 if (!is_ppc64_elf (ibfd))
7897 sec = bfd_get_section_by_name (ibfd, ".opd");
7898 if (sec == NULL || sec->size == 0)
7901 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7904 if (sec->output_section == bfd_abs_section_ptr)
7907 /* Look through the section relocs. */
7908 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7912 symtab_hdr = &elf_symtab_hdr (ibfd);
7914 /* Read the relocations. */
7915 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7917 if (relstart == NULL)
7920 /* First run through the relocs to check they are sane, and to
7921 determine whether we need to edit this opd section. */
7925 relend = relstart + sec->reloc_count;
7926 for (rel = relstart; rel < relend; )
7928 enum elf_ppc64_reloc_type r_type;
7929 unsigned long r_symndx;
7931 struct elf_link_hash_entry *h;
7932 Elf_Internal_Sym *sym;
7935 /* .opd contains an array of 16 or 24 byte entries. We're
7936 only interested in the reloc pointing to a function entry
7938 offset = rel->r_offset;
7939 if (rel + 1 == relend
7940 || rel[1].r_offset != offset + 8)
7942 /* If someone messes with .opd alignment then after a
7943 "ld -r" we might have padding in the middle of .opd.
7944 Also, there's nothing to prevent someone putting
7945 something silly in .opd with the assembler. No .opd
7946 optimization for them! */
7949 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7954 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7955 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7958 /* xgettext:c-format */
7959 (_("%B: unexpected reloc type %u in .opd section"),
7965 r_symndx = ELF64_R_SYM (rel->r_info);
7966 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7970 if (sym_sec == NULL || sym_sec->owner == NULL)
7972 const char *sym_name;
7974 sym_name = h->root.root.string;
7976 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7980 /* xgettext:c-format */
7981 (_("%B: undefined sym `%s' in .opd section"),
7987 /* opd entries are always for functions defined in the
7988 current input bfd. If the symbol isn't defined in the
7989 input bfd, then we won't be using the function in this
7990 bfd; It must be defined in a linkonce section in another
7991 bfd, or is weak. It's also possible that we are
7992 discarding the function due to a linker script /DISCARD/,
7993 which we test for via the output_section. */
7994 if (sym_sec->owner != ibfd
7995 || sym_sec->output_section == bfd_abs_section_ptr)
7999 if (rel + 1 == relend
8000 || (rel + 2 < relend
8001 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8006 if (sec->size == offset + 24)
8011 if (sec->size == offset + 16)
8018 else if (rel + 1 < relend
8019 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8020 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8022 if (rel[0].r_offset == offset + 16)
8024 else if (rel[0].r_offset != offset + 24)
8031 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8033 if (!broken && (need_edit || add_aux_fields))
8035 Elf_Internal_Rela *write_rel;
8036 Elf_Internal_Shdr *rel_hdr;
8037 bfd_byte *rptr, *wptr;
8038 bfd_byte *new_contents;
8041 new_contents = NULL;
8042 amt = OPD_NDX (sec->size) * sizeof (long);
8043 opd = &ppc64_elf_section_data (sec)->u.opd;
8044 opd->adjust = bfd_zalloc (sec->owner, amt);
8045 if (opd->adjust == NULL)
8047 ppc64_elf_section_data (sec)->sec_type = sec_opd;
8049 /* This seems a waste of time as input .opd sections are all
8050 zeros as generated by gcc, but I suppose there's no reason
8051 this will always be so. We might start putting something in
8052 the third word of .opd entries. */
8053 if ((sec->flags & SEC_IN_MEMORY) == 0)
8056 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8061 if (local_syms != NULL
8062 && symtab_hdr->contents != (unsigned char *) local_syms)
8064 if (elf_section_data (sec)->relocs != relstart)
8068 sec->contents = loc;
8069 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8072 elf_section_data (sec)->relocs = relstart;
8074 new_contents = sec->contents;
8077 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8078 if (new_contents == NULL)
8082 wptr = new_contents;
8083 rptr = sec->contents;
8084 write_rel = relstart;
8085 for (rel = relstart; rel < relend; )
8087 unsigned long r_symndx;
8089 struct elf_link_hash_entry *h;
8090 struct ppc_link_hash_entry *fdh = NULL;
8091 Elf_Internal_Sym *sym;
8093 Elf_Internal_Rela *next_rel;
8096 r_symndx = ELF64_R_SYM (rel->r_info);
8097 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8102 if (next_rel + 1 == relend
8103 || (next_rel + 2 < relend
8104 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8107 /* See if the .opd entry is full 24 byte or
8108 16 byte (with fd_aux entry overlapped with next
8111 if (next_rel == relend)
8113 if (sec->size == rel->r_offset + 16)
8116 else if (next_rel->r_offset == rel->r_offset + 16)
8120 && h->root.root.string[0] == '.')
8122 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8125 fdh = ppc_follow_link (fdh);
8126 if (fdh->elf.root.type != bfd_link_hash_defined
8127 && fdh->elf.root.type != bfd_link_hash_defweak)
8132 skip = (sym_sec->owner != ibfd
8133 || sym_sec->output_section == bfd_abs_section_ptr);
8136 if (fdh != NULL && sym_sec->owner == ibfd)
8138 /* Arrange for the function descriptor sym
8140 fdh->elf.root.u.def.value = 0;
8141 fdh->elf.root.u.def.section = sym_sec;
8143 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8145 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8150 if (!dec_dynrel_count (rel->r_info, sec, info,
8154 if (++rel == next_rel)
8157 r_symndx = ELF64_R_SYM (rel->r_info);
8158 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8165 /* We'll be keeping this opd entry. */
8170 /* Redefine the function descriptor symbol to
8171 this location in the opd section. It is
8172 necessary to update the value here rather
8173 than using an array of adjustments as we do
8174 for local symbols, because various places
8175 in the generic ELF code use the value
8176 stored in u.def.value. */
8177 fdh->elf.root.u.def.value = wptr - new_contents;
8178 fdh->adjust_done = 1;
8181 /* Local syms are a bit tricky. We could
8182 tweak them as they can be cached, but
8183 we'd need to look through the local syms
8184 for the function descriptor sym which we
8185 don't have at the moment. So keep an
8186 array of adjustments. */
8187 adjust = (wptr - new_contents) - (rptr - sec->contents);
8188 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8191 memcpy (wptr, rptr, opd_ent_size);
8192 wptr += opd_ent_size;
8193 if (add_aux_fields && opd_ent_size == 16)
8195 memset (wptr, '\0', 8);
8199 /* We need to adjust any reloc offsets to point to the
8201 for ( ; rel != next_rel; ++rel)
8203 rel->r_offset += adjust;
8204 if (write_rel != rel)
8205 memcpy (write_rel, rel, sizeof (*rel));
8210 rptr += opd_ent_size;
8213 sec->size = wptr - new_contents;
8214 sec->reloc_count = write_rel - relstart;
8217 free (sec->contents);
8218 sec->contents = new_contents;
8221 /* Fudge the header size too, as this is used later in
8222 elf_bfd_final_link if we are emitting relocs. */
8223 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8224 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8227 else if (elf_section_data (sec)->relocs != relstart)
8230 if (local_syms != NULL
8231 && symtab_hdr->contents != (unsigned char *) local_syms)
8233 if (!info->keep_memory)
8236 symtab_hdr->contents = (unsigned char *) local_syms;
8241 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8243 /* If we are doing a final link and the last .opd entry is just 16 byte
8244 long, add a 8 byte padding after it. */
8245 if (need_pad != NULL && !bfd_link_relocatable (info))
8249 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8251 BFD_ASSERT (need_pad->size > 0);
8253 p = bfd_malloc (need_pad->size + 8);
8257 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8258 p, 0, need_pad->size))
8261 need_pad->contents = p;
8262 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8266 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8270 need_pad->contents = p;
8273 memset (need_pad->contents + need_pad->size, 0, 8);
8274 need_pad->size += 8;
8280 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8283 ppc64_elf_tls_setup (struct bfd_link_info *info)
8285 struct ppc_link_hash_table *htab;
8287 htab = ppc_hash_table (info);
8291 if (abiversion (info->output_bfd) == 1)
8294 if (htab->params->no_multi_toc)
8295 htab->do_multi_toc = 0;
8296 else if (!htab->do_multi_toc)
8297 htab->params->no_multi_toc = 1;
8299 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8300 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8301 FALSE, FALSE, TRUE));
8302 /* Move dynamic linking info to the function descriptor sym. */
8303 if (htab->tls_get_addr != NULL)
8304 func_desc_adjust (&htab->tls_get_addr->elf, info);
8305 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8306 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8307 FALSE, FALSE, TRUE));
8308 if (htab->params->tls_get_addr_opt)
8310 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8312 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8313 FALSE, FALSE, TRUE);
8315 func_desc_adjust (opt, info);
8316 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8317 FALSE, FALSE, TRUE);
8319 && (opt_fd->root.type == bfd_link_hash_defined
8320 || opt_fd->root.type == bfd_link_hash_defweak))
8322 /* If glibc supports an optimized __tls_get_addr call stub,
8323 signalled by the presence of __tls_get_addr_opt, and we'll
8324 be calling __tls_get_addr via a plt call stub, then
8325 make __tls_get_addr point to __tls_get_addr_opt. */
8326 tga_fd = &htab->tls_get_addr_fd->elf;
8327 if (htab->elf.dynamic_sections_created
8329 && (tga_fd->type == STT_FUNC
8330 || tga_fd->needs_plt)
8331 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8332 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8333 && tga_fd->root.type == bfd_link_hash_undefweak)))
8335 struct plt_entry *ent;
8337 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8338 if (ent->plt.refcount > 0)
8342 tga_fd->root.type = bfd_link_hash_indirect;
8343 tga_fd->root.u.i.link = &opt_fd->root;
8344 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8346 if (opt_fd->dynindx != -1)
8348 /* Use __tls_get_addr_opt in dynamic relocations. */
8349 opt_fd->dynindx = -1;
8350 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8351 opt_fd->dynstr_index);
8352 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8355 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8356 tga = &htab->tls_get_addr->elf;
8357 if (opt != NULL && tga != NULL)
8359 tga->root.type = bfd_link_hash_indirect;
8360 tga->root.u.i.link = &opt->root;
8361 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8363 _bfd_elf_link_hash_hide_symbol (info, opt,
8365 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8367 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8368 htab->tls_get_addr_fd->is_func_descriptor = 1;
8369 if (htab->tls_get_addr != NULL)
8371 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8372 htab->tls_get_addr->is_func = 1;
8377 else if (htab->params->tls_get_addr_opt < 0)
8378 htab->params->tls_get_addr_opt = 0;
8380 return _bfd_elf_tls_setup (info->output_bfd, info);
8383 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8387 branch_reloc_hash_match (const bfd *ibfd,
8388 const Elf_Internal_Rela *rel,
8389 const struct ppc_link_hash_entry *hash1,
8390 const struct ppc_link_hash_entry *hash2)
8392 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8393 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8394 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8396 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8398 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8399 struct elf_link_hash_entry *h;
8401 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8402 h = elf_follow_link (h);
8403 if (h == &hash1->elf || h == &hash2->elf)
8409 /* Run through all the TLS relocs looking for optimization
8410 opportunities. The linker has been hacked (see ppc64elf.em) to do
8411 a preliminary section layout so that we know the TLS segment
8412 offsets. We can't optimize earlier because some optimizations need
8413 to know the tp offset, and we need to optimize before allocating
8414 dynamic relocations. */
8417 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8421 struct ppc_link_hash_table *htab;
8422 unsigned char *toc_ref;
8425 if (!bfd_link_executable (info))
8428 htab = ppc_hash_table (info);
8432 /* Make two passes over the relocs. On the first pass, mark toc
8433 entries involved with tls relocs, and check that tls relocs
8434 involved in setting up a tls_get_addr call are indeed followed by
8435 such a call. If they are not, we can't do any tls optimization.
8436 On the second pass twiddle tls_mask flags to notify
8437 relocate_section that optimization can be done, and adjust got
8438 and plt refcounts. */
8440 for (pass = 0; pass < 2; ++pass)
8441 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8443 Elf_Internal_Sym *locsyms = NULL;
8444 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8446 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8447 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8449 Elf_Internal_Rela *relstart, *rel, *relend;
8450 bfd_boolean found_tls_get_addr_arg = 0;
8452 /* Read the relocations. */
8453 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8455 if (relstart == NULL)
8461 relend = relstart + sec->reloc_count;
8462 for (rel = relstart; rel < relend; rel++)
8464 enum elf_ppc64_reloc_type r_type;
8465 unsigned long r_symndx;
8466 struct elf_link_hash_entry *h;
8467 Elf_Internal_Sym *sym;
8469 unsigned char *tls_mask;
8470 unsigned char tls_set, tls_clear, tls_type = 0;
8472 bfd_boolean ok_tprel, is_local;
8473 long toc_ref_index = 0;
8474 int expecting_tls_get_addr = 0;
8475 bfd_boolean ret = FALSE;
8477 r_symndx = ELF64_R_SYM (rel->r_info);
8478 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8482 if (elf_section_data (sec)->relocs != relstart)
8484 if (toc_ref != NULL)
8487 && (elf_symtab_hdr (ibfd).contents
8488 != (unsigned char *) locsyms))
8495 if (h->root.type == bfd_link_hash_defined
8496 || h->root.type == bfd_link_hash_defweak)
8497 value = h->root.u.def.value;
8498 else if (h->root.type == bfd_link_hash_undefweak)
8502 found_tls_get_addr_arg = 0;
8507 /* Symbols referenced by TLS relocs must be of type
8508 STT_TLS. So no need for .opd local sym adjust. */
8509 value = sym->st_value;
8518 && h->root.type == bfd_link_hash_undefweak)
8520 else if (sym_sec != NULL
8521 && sym_sec->output_section != NULL)
8523 value += sym_sec->output_offset;
8524 value += sym_sec->output_section->vma;
8525 value -= htab->elf.tls_sec->vma;
8526 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8527 < (bfd_vma) 1 << 32);
8531 r_type = ELF64_R_TYPE (rel->r_info);
8532 /* If this section has old-style __tls_get_addr calls
8533 without marker relocs, then check that each
8534 __tls_get_addr call reloc is preceded by a reloc
8535 that conceivably belongs to the __tls_get_addr arg
8536 setup insn. If we don't find matching arg setup
8537 relocs, don't do any tls optimization. */
8539 && sec->has_tls_get_addr_call
8541 && (h == &htab->tls_get_addr->elf
8542 || h == &htab->tls_get_addr_fd->elf)
8543 && !found_tls_get_addr_arg
8544 && is_branch_reloc (r_type))
8546 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8547 "TLS optimization disabled\n"),
8548 ibfd, sec, rel->r_offset);
8553 found_tls_get_addr_arg = 0;
8556 case R_PPC64_GOT_TLSLD16:
8557 case R_PPC64_GOT_TLSLD16_LO:
8558 expecting_tls_get_addr = 1;
8559 found_tls_get_addr_arg = 1;
8562 case R_PPC64_GOT_TLSLD16_HI:
8563 case R_PPC64_GOT_TLSLD16_HA:
8564 /* These relocs should never be against a symbol
8565 defined in a shared lib. Leave them alone if
8566 that turns out to be the case. */
8573 tls_type = TLS_TLS | TLS_LD;
8576 case R_PPC64_GOT_TLSGD16:
8577 case R_PPC64_GOT_TLSGD16_LO:
8578 expecting_tls_get_addr = 1;
8579 found_tls_get_addr_arg = 1;
8582 case R_PPC64_GOT_TLSGD16_HI:
8583 case R_PPC64_GOT_TLSGD16_HA:
8589 tls_set = TLS_TLS | TLS_TPRELGD;
8591 tls_type = TLS_TLS | TLS_GD;
8594 case R_PPC64_GOT_TPREL16_DS:
8595 case R_PPC64_GOT_TPREL16_LO_DS:
8596 case R_PPC64_GOT_TPREL16_HI:
8597 case R_PPC64_GOT_TPREL16_HA:
8602 tls_clear = TLS_TPREL;
8603 tls_type = TLS_TLS | TLS_TPREL;
8610 found_tls_get_addr_arg = 1;
8615 case R_PPC64_TOC16_LO:
8616 if (sym_sec == NULL || sym_sec != toc)
8619 /* Mark this toc entry as referenced by a TLS
8620 code sequence. We can do that now in the
8621 case of R_PPC64_TLS, and after checking for
8622 tls_get_addr for the TOC16 relocs. */
8623 if (toc_ref == NULL)
8624 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8625 if (toc_ref == NULL)
8629 value = h->root.u.def.value;
8631 value = sym->st_value;
8632 value += rel->r_addend;
8635 BFD_ASSERT (value < toc->size
8636 && toc->output_offset % 8 == 0);
8637 toc_ref_index = (value + toc->output_offset) / 8;
8638 if (r_type == R_PPC64_TLS
8639 || r_type == R_PPC64_TLSGD
8640 || r_type == R_PPC64_TLSLD)
8642 toc_ref[toc_ref_index] = 1;
8646 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8651 expecting_tls_get_addr = 2;
8654 case R_PPC64_TPREL64:
8658 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8663 tls_set = TLS_EXPLICIT;
8664 tls_clear = TLS_TPREL;
8669 case R_PPC64_DTPMOD64:
8673 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8675 if (rel + 1 < relend
8677 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8678 && rel[1].r_offset == rel->r_offset + 8)
8682 tls_set = TLS_EXPLICIT | TLS_GD;
8685 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8694 tls_set = TLS_EXPLICIT;
8705 if (!expecting_tls_get_addr
8706 || !sec->has_tls_get_addr_call)
8709 if (rel + 1 < relend
8710 && branch_reloc_hash_match (ibfd, rel + 1,
8712 htab->tls_get_addr_fd))
8714 if (expecting_tls_get_addr == 2)
8716 /* Check for toc tls entries. */
8717 unsigned char *toc_tls;
8720 retval = get_tls_mask (&toc_tls, NULL, NULL,
8725 if (toc_tls != NULL)
8727 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8728 found_tls_get_addr_arg = 1;
8730 toc_ref[toc_ref_index] = 1;
8736 if (expecting_tls_get_addr != 1)
8739 /* Uh oh, we didn't find the expected call. We
8740 could just mark this symbol to exclude it
8741 from tls optimization but it's safer to skip
8742 the entire optimization. */
8743 /* xgettext:c-format */
8744 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8745 "TLS optimization disabled\n"),
8746 ibfd, sec, rel->r_offset);
8751 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8753 struct plt_entry *ent;
8754 for (ent = htab->tls_get_addr->elf.plt.plist;
8757 if (ent->addend == 0)
8759 if (ent->plt.refcount > 0)
8761 ent->plt.refcount -= 1;
8762 expecting_tls_get_addr = 0;
8768 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8770 struct plt_entry *ent;
8771 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8774 if (ent->addend == 0)
8776 if (ent->plt.refcount > 0)
8777 ent->plt.refcount -= 1;
8785 if ((tls_set & TLS_EXPLICIT) == 0)
8787 struct got_entry *ent;
8789 /* Adjust got entry for this reloc. */
8793 ent = elf_local_got_ents (ibfd)[r_symndx];
8795 for (; ent != NULL; ent = ent->next)
8796 if (ent->addend == rel->r_addend
8797 && ent->owner == ibfd
8798 && ent->tls_type == tls_type)
8805 /* We managed to get rid of a got entry. */
8806 if (ent->got.refcount > 0)
8807 ent->got.refcount -= 1;
8812 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8813 we'll lose one or two dyn relocs. */
8814 if (!dec_dynrel_count (rel->r_info, sec, info,
8818 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8820 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8826 *tls_mask |= tls_set;
8827 *tls_mask &= ~tls_clear;
8830 if (elf_section_data (sec)->relocs != relstart)
8835 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8837 if (!info->keep_memory)
8840 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8844 if (toc_ref != NULL)
8849 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8850 the values of any global symbols in a toc section that has been
8851 edited. Globals in toc sections should be a rarity, so this function
8852 sets a flag if any are found in toc sections other than the one just
8853 edited, so that futher hash table traversals can be avoided. */
8855 struct adjust_toc_info
8858 unsigned long *skip;
8859 bfd_boolean global_toc_syms;
8862 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8865 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8867 struct ppc_link_hash_entry *eh;
8868 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8871 if (h->root.type != bfd_link_hash_defined
8872 && h->root.type != bfd_link_hash_defweak)
8875 eh = (struct ppc_link_hash_entry *) h;
8876 if (eh->adjust_done)
8879 if (eh->elf.root.u.def.section == toc_inf->toc)
8881 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8882 i = toc_inf->toc->rawsize >> 3;
8884 i = eh->elf.root.u.def.value >> 3;
8886 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8889 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8892 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8893 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8896 eh->elf.root.u.def.value -= toc_inf->skip[i];
8897 eh->adjust_done = 1;
8899 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8900 toc_inf->global_toc_syms = TRUE;
8905 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8906 on a _LO variety toc/got reloc. */
8909 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8911 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8912 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8913 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8914 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8915 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8916 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8917 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8918 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8919 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8920 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8921 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8922 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8923 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8924 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8925 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8926 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8927 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8928 /* Exclude lfqu by testing reloc. If relocs are ever
8929 defined for the reduced D field in psq_lu then those
8930 will need testing too. */
8931 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8932 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8934 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8935 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8936 /* Exclude stfqu. psq_stu as above for psq_lu. */
8937 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8938 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8939 && (insn & 1) == 0));
8942 /* Examine all relocs referencing .toc sections in order to remove
8943 unused .toc entries. */
8946 ppc64_elf_edit_toc (struct bfd_link_info *info)
8949 struct adjust_toc_info toc_inf;
8950 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8952 htab->do_toc_opt = 1;
8953 toc_inf.global_toc_syms = TRUE;
8954 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8956 asection *toc, *sec;
8957 Elf_Internal_Shdr *symtab_hdr;
8958 Elf_Internal_Sym *local_syms;
8959 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8960 unsigned long *skip, *drop;
8961 unsigned char *used;
8962 unsigned char *keep, last, some_unused;
8964 if (!is_ppc64_elf (ibfd))
8967 toc = bfd_get_section_by_name (ibfd, ".toc");
8970 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8971 || discarded_section (toc))
8976 symtab_hdr = &elf_symtab_hdr (ibfd);
8978 /* Look at sections dropped from the final link. */
8981 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8983 if (sec->reloc_count == 0
8984 || !discarded_section (sec)
8985 || get_opd_info (sec)
8986 || (sec->flags & SEC_ALLOC) == 0
8987 || (sec->flags & SEC_DEBUGGING) != 0)
8990 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8991 if (relstart == NULL)
8994 /* Run through the relocs to see which toc entries might be
8996 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8998 enum elf_ppc64_reloc_type r_type;
8999 unsigned long r_symndx;
9001 struct elf_link_hash_entry *h;
9002 Elf_Internal_Sym *sym;
9005 r_type = ELF64_R_TYPE (rel->r_info);
9012 case R_PPC64_TOC16_LO:
9013 case R_PPC64_TOC16_HI:
9014 case R_PPC64_TOC16_HA:
9015 case R_PPC64_TOC16_DS:
9016 case R_PPC64_TOC16_LO_DS:
9020 r_symndx = ELF64_R_SYM (rel->r_info);
9021 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9029 val = h->root.u.def.value;
9031 val = sym->st_value;
9032 val += rel->r_addend;
9034 if (val >= toc->size)
9037 /* Anything in the toc ought to be aligned to 8 bytes.
9038 If not, don't mark as unused. */
9044 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9049 skip[val >> 3] = ref_from_discarded;
9052 if (elf_section_data (sec)->relocs != relstart)
9056 /* For largetoc loads of address constants, we can convert
9057 . addis rx,2,addr@got@ha
9058 . ld ry,addr@got@l(rx)
9060 . addis rx,2,addr@toc@ha
9061 . addi ry,rx,addr@toc@l
9062 when addr is within 2G of the toc pointer. This then means
9063 that the word storing "addr" in the toc is no longer needed. */
9065 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9066 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9067 && toc->reloc_count != 0)
9069 /* Read toc relocs. */
9070 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9072 if (toc_relocs == NULL)
9075 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9077 enum elf_ppc64_reloc_type r_type;
9078 unsigned long r_symndx;
9080 struct elf_link_hash_entry *h;
9081 Elf_Internal_Sym *sym;
9084 r_type = ELF64_R_TYPE (rel->r_info);
9085 if (r_type != R_PPC64_ADDR64)
9088 r_symndx = ELF64_R_SYM (rel->r_info);
9089 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9094 || sym_sec->output_section == NULL
9095 || discarded_section (sym_sec))
9098 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9103 if (h->type == STT_GNU_IFUNC)
9105 val = h->root.u.def.value;
9109 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9111 val = sym->st_value;
9113 val += rel->r_addend;
9114 val += sym_sec->output_section->vma + sym_sec->output_offset;
9116 /* We don't yet know the exact toc pointer value, but we
9117 know it will be somewhere in the toc section. Don't
9118 optimize if the difference from any possible toc
9119 pointer is outside [ff..f80008000, 7fff7fff]. */
9120 addr = toc->output_section->vma + TOC_BASE_OFF;
9121 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9124 addr = toc->output_section->vma + toc->output_section->rawsize;
9125 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9130 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9135 skip[rel->r_offset >> 3]
9136 |= can_optimize | ((rel - toc_relocs) << 2);
9143 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9147 if (local_syms != NULL
9148 && symtab_hdr->contents != (unsigned char *) local_syms)
9152 && elf_section_data (sec)->relocs != relstart)
9154 if (toc_relocs != NULL
9155 && elf_section_data (toc)->relocs != toc_relocs)
9162 /* Now check all kept sections that might reference the toc.
9163 Check the toc itself last. */
9164 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9167 sec = (sec == toc ? NULL
9168 : sec->next == NULL ? toc
9169 : sec->next == toc && toc->next ? toc->next
9174 if (sec->reloc_count == 0
9175 || discarded_section (sec)
9176 || get_opd_info (sec)
9177 || (sec->flags & SEC_ALLOC) == 0
9178 || (sec->flags & SEC_DEBUGGING) != 0)
9181 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9183 if (relstart == NULL)
9189 /* Mark toc entries referenced as used. */
9193 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9195 enum elf_ppc64_reloc_type r_type;
9196 unsigned long r_symndx;
9198 struct elf_link_hash_entry *h;
9199 Elf_Internal_Sym *sym;
9201 enum {no_check, check_lo, check_ha} insn_check;
9203 r_type = ELF64_R_TYPE (rel->r_info);
9207 insn_check = no_check;
9210 case R_PPC64_GOT_TLSLD16_HA:
9211 case R_PPC64_GOT_TLSGD16_HA:
9212 case R_PPC64_GOT_TPREL16_HA:
9213 case R_PPC64_GOT_DTPREL16_HA:
9214 case R_PPC64_GOT16_HA:
9215 case R_PPC64_TOC16_HA:
9216 insn_check = check_ha;
9219 case R_PPC64_GOT_TLSLD16_LO:
9220 case R_PPC64_GOT_TLSGD16_LO:
9221 case R_PPC64_GOT_TPREL16_LO_DS:
9222 case R_PPC64_GOT_DTPREL16_LO_DS:
9223 case R_PPC64_GOT16_LO:
9224 case R_PPC64_GOT16_LO_DS:
9225 case R_PPC64_TOC16_LO:
9226 case R_PPC64_TOC16_LO_DS:
9227 insn_check = check_lo;
9231 if (insn_check != no_check)
9233 bfd_vma off = rel->r_offset & ~3;
9234 unsigned char buf[4];
9237 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9242 insn = bfd_get_32 (ibfd, buf);
9243 if (insn_check == check_lo
9244 ? !ok_lo_toc_insn (insn, r_type)
9245 : ((insn & ((0x3f << 26) | 0x1f << 16))
9246 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9250 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9251 sprintf (str, "%#08x", insn);
9252 info->callbacks->einfo
9253 /* xgettext:c-format */
9254 (_("%H: toc optimization is not supported for"
9255 " %s instruction.\n"),
9256 ibfd, sec, rel->r_offset & ~3, str);
9263 case R_PPC64_TOC16_LO:
9264 case R_PPC64_TOC16_HI:
9265 case R_PPC64_TOC16_HA:
9266 case R_PPC64_TOC16_DS:
9267 case R_PPC64_TOC16_LO_DS:
9268 /* In case we're taking addresses of toc entries. */
9269 case R_PPC64_ADDR64:
9276 r_symndx = ELF64_R_SYM (rel->r_info);
9277 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9288 val = h->root.u.def.value;
9290 val = sym->st_value;
9291 val += rel->r_addend;
9293 if (val >= toc->size)
9296 if ((skip[val >> 3] & can_optimize) != 0)
9303 case R_PPC64_TOC16_HA:
9306 case R_PPC64_TOC16_LO_DS:
9307 off = rel->r_offset;
9308 off += (bfd_big_endian (ibfd) ? -2 : 3);
9309 if (!bfd_get_section_contents (ibfd, sec, &opc,
9315 if ((opc & (0x3f << 2)) == (58u << 2))
9320 /* Wrong sort of reloc, or not a ld. We may
9321 as well clear ref_from_discarded too. */
9328 /* For the toc section, we only mark as used if this
9329 entry itself isn't unused. */
9330 else if ((used[rel->r_offset >> 3]
9331 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9334 /* Do all the relocs again, to catch reference
9343 if (elf_section_data (sec)->relocs != relstart)
9347 /* Merge the used and skip arrays. Assume that TOC
9348 doublewords not appearing as either used or unused belong
9349 to to an entry more than one doubleword in size. */
9350 for (drop = skip, keep = used, last = 0, some_unused = 0;
9351 drop < skip + (toc->size + 7) / 8;
9356 *drop &= ~ref_from_discarded;
9357 if ((*drop & can_optimize) != 0)
9361 else if ((*drop & ref_from_discarded) != 0)
9364 last = ref_from_discarded;
9374 bfd_byte *contents, *src;
9376 Elf_Internal_Sym *sym;
9377 bfd_boolean local_toc_syms = FALSE;
9379 /* Shuffle the toc contents, and at the same time convert the
9380 skip array from booleans into offsets. */
9381 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9384 elf_section_data (toc)->this_hdr.contents = contents;
9386 for (src = contents, off = 0, drop = skip;
9387 src < contents + toc->size;
9390 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9395 memcpy (src - off, src, 8);
9399 toc->rawsize = toc->size;
9400 toc->size = src - contents - off;
9402 /* Adjust addends for relocs against the toc section sym,
9403 and optimize any accesses we can. */
9404 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9406 if (sec->reloc_count == 0
9407 || discarded_section (sec))
9410 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9412 if (relstart == NULL)
9415 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9417 enum elf_ppc64_reloc_type r_type;
9418 unsigned long r_symndx;
9420 struct elf_link_hash_entry *h;
9423 r_type = ELF64_R_TYPE (rel->r_info);
9430 case R_PPC64_TOC16_LO:
9431 case R_PPC64_TOC16_HI:
9432 case R_PPC64_TOC16_HA:
9433 case R_PPC64_TOC16_DS:
9434 case R_PPC64_TOC16_LO_DS:
9435 case R_PPC64_ADDR64:
9439 r_symndx = ELF64_R_SYM (rel->r_info);
9440 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9448 val = h->root.u.def.value;
9451 val = sym->st_value;
9453 local_toc_syms = TRUE;
9456 val += rel->r_addend;
9458 if (val > toc->rawsize)
9460 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9462 else if ((skip[val >> 3] & can_optimize) != 0)
9464 Elf_Internal_Rela *tocrel
9465 = toc_relocs + (skip[val >> 3] >> 2);
9466 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9470 case R_PPC64_TOC16_HA:
9471 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9474 case R_PPC64_TOC16_LO_DS:
9475 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9479 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9481 info->callbacks->einfo
9482 /* xgettext:c-format */
9483 (_("%H: %s references "
9484 "optimized away TOC entry\n"),
9485 ibfd, sec, rel->r_offset,
9486 ppc64_elf_howto_table[r_type]->name);
9487 bfd_set_error (bfd_error_bad_value);
9490 rel->r_addend = tocrel->r_addend;
9491 elf_section_data (sec)->relocs = relstart;
9495 if (h != NULL || sym->st_value != 0)
9498 rel->r_addend -= skip[val >> 3];
9499 elf_section_data (sec)->relocs = relstart;
9502 if (elf_section_data (sec)->relocs != relstart)
9506 /* We shouldn't have local or global symbols defined in the TOC,
9507 but handle them anyway. */
9508 if (local_syms != NULL)
9509 for (sym = local_syms;
9510 sym < local_syms + symtab_hdr->sh_info;
9512 if (sym->st_value != 0
9513 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9517 if (sym->st_value > toc->rawsize)
9518 i = toc->rawsize >> 3;
9520 i = sym->st_value >> 3;
9522 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9526 (_("%s defined on removed toc entry"),
9527 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9530 while ((skip[i] & (ref_from_discarded | can_optimize)));
9531 sym->st_value = (bfd_vma) i << 3;
9534 sym->st_value -= skip[i];
9535 symtab_hdr->contents = (unsigned char *) local_syms;
9538 /* Adjust any global syms defined in this toc input section. */
9539 if (toc_inf.global_toc_syms)
9542 toc_inf.skip = skip;
9543 toc_inf.global_toc_syms = FALSE;
9544 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9548 if (toc->reloc_count != 0)
9550 Elf_Internal_Shdr *rel_hdr;
9551 Elf_Internal_Rela *wrel;
9554 /* Remove unused toc relocs, and adjust those we keep. */
9555 if (toc_relocs == NULL)
9556 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9558 if (toc_relocs == NULL)
9562 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9563 if ((skip[rel->r_offset >> 3]
9564 & (ref_from_discarded | can_optimize)) == 0)
9566 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9567 wrel->r_info = rel->r_info;
9568 wrel->r_addend = rel->r_addend;
9571 else if (!dec_dynrel_count (rel->r_info, toc, info,
9572 &local_syms, NULL, NULL))
9575 elf_section_data (toc)->relocs = toc_relocs;
9576 toc->reloc_count = wrel - toc_relocs;
9577 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9578 sz = rel_hdr->sh_entsize;
9579 rel_hdr->sh_size = toc->reloc_count * sz;
9582 else if (toc_relocs != NULL
9583 && elf_section_data (toc)->relocs != toc_relocs)
9586 if (local_syms != NULL
9587 && symtab_hdr->contents != (unsigned char *) local_syms)
9589 if (!info->keep_memory)
9592 symtab_hdr->contents = (unsigned char *) local_syms;
9600 /* Return true iff input section I references the TOC using
9601 instructions limited to +/-32k offsets. */
9604 ppc64_elf_has_small_toc_reloc (asection *i)
9606 return (is_ppc64_elf (i->owner)
9607 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9610 /* Allocate space for one GOT entry. */
9613 allocate_got (struct elf_link_hash_entry *h,
9614 struct bfd_link_info *info,
9615 struct got_entry *gent)
9617 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9618 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9619 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9621 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9622 ? 2 : 1) * sizeof (Elf64_External_Rela);
9623 asection *got = ppc64_elf_tdata (gent->owner)->got;
9625 gent->got.offset = got->size;
9626 got->size += entsize;
9628 if (h->type == STT_GNU_IFUNC)
9630 htab->elf.irelplt->size += rentsize;
9631 htab->got_reli_size += rentsize;
9633 else if ((bfd_link_pic (info)
9634 || (htab->elf.dynamic_sections_created
9636 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9637 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9638 || h->root.type != bfd_link_hash_undefweak))
9640 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9641 relgot->size += rentsize;
9645 /* This function merges got entries in the same toc group. */
9648 merge_got_entries (struct got_entry **pent)
9650 struct got_entry *ent, *ent2;
9652 for (ent = *pent; ent != NULL; ent = ent->next)
9653 if (!ent->is_indirect)
9654 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9655 if (!ent2->is_indirect
9656 && ent2->addend == ent->addend
9657 && ent2->tls_type == ent->tls_type
9658 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9660 ent2->is_indirect = TRUE;
9661 ent2->got.ent = ent;
9665 /* If H is undefined weak, make it dynamic if that makes sense. */
9668 ensure_undefweak_dynamic (struct bfd_link_info *info,
9669 struct elf_link_hash_entry *h)
9671 struct elf_link_hash_table *htab = elf_hash_table (info);
9673 if (htab->dynamic_sections_created
9674 && h->root.type == bfd_link_hash_undefweak
9677 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9678 return bfd_elf_link_record_dynamic_symbol (info, h);
9682 /* Allocate space in .plt, .got and associated reloc sections for
9686 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9688 struct bfd_link_info *info;
9689 struct ppc_link_hash_table *htab;
9691 struct ppc_link_hash_entry *eh;
9692 struct got_entry **pgent, *gent;
9694 if (h->root.type == bfd_link_hash_indirect)
9697 info = (struct bfd_link_info *) inf;
9698 htab = ppc_hash_table (info);
9702 eh = (struct ppc_link_hash_entry *) h;
9703 /* Run through the TLS GD got entries first if we're changing them
9705 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9706 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9707 if (gent->got.refcount > 0
9708 && (gent->tls_type & TLS_GD) != 0)
9710 /* This was a GD entry that has been converted to TPREL. If
9711 there happens to be a TPREL entry we can use that one. */
9712 struct got_entry *ent;
9713 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9714 if (ent->got.refcount > 0
9715 && (ent->tls_type & TLS_TPREL) != 0
9716 && ent->addend == gent->addend
9717 && ent->owner == gent->owner)
9719 gent->got.refcount = 0;
9723 /* If not, then we'll be using our own TPREL entry. */
9724 if (gent->got.refcount != 0)
9725 gent->tls_type = TLS_TLS | TLS_TPREL;
9728 /* Remove any list entry that won't generate a word in the GOT before
9729 we call merge_got_entries. Otherwise we risk merging to empty
9731 pgent = &h->got.glist;
9732 while ((gent = *pgent) != NULL)
9733 if (gent->got.refcount > 0)
9735 if ((gent->tls_type & TLS_LD) != 0
9738 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9739 *pgent = gent->next;
9742 pgent = &gent->next;
9745 *pgent = gent->next;
9747 if (!htab->do_multi_toc)
9748 merge_got_entries (&h->got.glist);
9750 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9751 if (!gent->is_indirect)
9753 /* Make sure this symbol is output as a dynamic symbol.
9754 Undefined weak syms won't yet be marked as dynamic. */
9755 if (!ensure_undefweak_dynamic (info, h))
9758 if (!is_ppc64_elf (gent->owner))
9761 allocate_got (h, info, gent);
9764 if (!htab->elf.dynamic_sections_created
9765 && h->type != STT_GNU_IFUNC)
9766 eh->dyn_relocs = NULL;
9768 if (eh->dyn_relocs != NULL)
9770 struct elf_dyn_relocs *p, **pp;
9772 /* In the shared -Bsymbolic case, discard space allocated for
9773 dynamic pc-relative relocs against symbols which turn out to
9774 be defined in regular objects. For the normal shared case,
9775 discard space for relocs that have become local due to symbol
9776 visibility changes. */
9778 if (bfd_link_pic (info))
9780 /* Relocs that use pc_count are those that appear on a call
9781 insn, or certain REL relocs (see must_be_dyn_reloc) that
9782 can be generated via assembly. We want calls to
9783 protected symbols to resolve directly to the function
9784 rather than going via the plt. If people want function
9785 pointer comparisons to work as expected then they should
9786 avoid writing weird assembly. */
9787 if (SYMBOL_CALLS_LOCAL (info, h))
9789 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9791 p->count -= p->pc_count;
9800 /* Also discard relocs on undefined weak syms with
9801 non-default visibility. */
9802 if (eh->dyn_relocs != NULL
9803 && h->root.type == bfd_link_hash_undefweak)
9805 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9806 eh->dyn_relocs = NULL;
9808 /* Make sure this symbol is output as a dynamic symbol.
9809 Undefined weak syms won't yet be marked as dynamic. */
9810 else if (!ensure_undefweak_dynamic (info, h))
9814 else if (h->type == STT_GNU_IFUNC)
9816 /* A plt entry is always created when making direct calls to
9817 an ifunc, even when building a static executable, but
9818 that doesn't cover all cases. We may have only an ifunc
9819 initialised function pointer for a given ifunc symbol.
9821 For ELFv2, dynamic relocations are not required when
9822 generating a global entry PLT stub. */
9823 if (abiversion (info->output_bfd) >= 2)
9825 if (global_entry_stub (h))
9826 eh->dyn_relocs = NULL;
9829 /* For ELFv1 we have function descriptors. Descriptors need
9830 to be treated like PLT entries and thus have dynamic
9831 relocations. One exception is when the function
9832 descriptor is copied into .dynbss (which should only
9833 happen with ancient versions of gcc). */
9834 else if (h->needs_copy)
9835 eh->dyn_relocs = NULL;
9837 else if (ELIMINATE_COPY_RELOCS)
9839 /* For the non-pic case, discard space for relocs against
9840 symbols which turn out to need copy relocs or are not
9845 /* Make sure this symbol is output as a dynamic symbol.
9846 Undefined weak syms won't yet be marked as dynamic. */
9847 if (!ensure_undefweak_dynamic (info, h))
9850 if (h->dynindx == -1)
9851 eh->dyn_relocs = NULL;
9854 eh->dyn_relocs = NULL;
9857 /* Finally, allocate space. */
9858 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9860 asection *sreloc = elf_section_data (p->sec)->sreloc;
9861 if (eh->elf.type == STT_GNU_IFUNC)
9862 sreloc = htab->elf.irelplt;
9863 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9867 if ((htab->elf.dynamic_sections_created
9868 && h->dynindx != -1)
9869 || h->type == STT_GNU_IFUNC)
9871 struct plt_entry *pent;
9872 bfd_boolean doneone = FALSE;
9873 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9874 if (pent->plt.refcount > 0)
9876 if (!htab->elf.dynamic_sections_created
9877 || h->dynindx == -1)
9880 pent->plt.offset = s->size;
9881 s->size += PLT_ENTRY_SIZE (htab);
9882 s = htab->elf.irelplt;
9886 /* If this is the first .plt entry, make room for the special
9890 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9892 pent->plt.offset = s->size;
9894 /* Make room for this entry. */
9895 s->size += PLT_ENTRY_SIZE (htab);
9897 /* Make room for the .glink code. */
9900 s->size += GLINK_CALL_STUB_SIZE;
9903 /* We need bigger stubs past index 32767. */
9904 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9911 /* We also need to make an entry in the .rela.plt section. */
9912 s = htab->elf.srelplt;
9914 s->size += sizeof (Elf64_External_Rela);
9918 pent->plt.offset = (bfd_vma) -1;
9921 h->plt.plist = NULL;
9927 h->plt.plist = NULL;
9934 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9935 to set up space for global entry stubs. These are put in glink,
9936 after the branch table. */
9939 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9941 struct bfd_link_info *info;
9942 struct ppc_link_hash_table *htab;
9943 struct plt_entry *pent;
9946 if (h->root.type == bfd_link_hash_indirect)
9949 if (!h->pointer_equality_needed)
9956 htab = ppc_hash_table (info);
9961 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9962 if (pent->plt.offset != (bfd_vma) -1
9963 && pent->addend == 0)
9965 /* For ELFv2, if this symbol is not defined in a regular file
9966 and we are not generating a shared library or pie, then we
9967 need to define the symbol in the executable on a call stub.
9968 This is to avoid text relocations. */
9969 s->size = (s->size + 15) & -16;
9970 h->root.type = bfd_link_hash_defined;
9971 h->root.u.def.section = s;
9972 h->root.u.def.value = s->size;
9979 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9980 read-only sections. */
9983 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9985 if (h->root.type == bfd_link_hash_indirect)
9988 if (readonly_dynrelocs (h))
9990 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9992 /* Not an error, just cut short the traversal. */
9998 /* Set the sizes of the dynamic sections. */
10001 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10002 struct bfd_link_info *info)
10004 struct ppc_link_hash_table *htab;
10007 bfd_boolean relocs;
10009 struct got_entry *first_tlsld;
10011 htab = ppc_hash_table (info);
10015 dynobj = htab->elf.dynobj;
10016 if (dynobj == NULL)
10019 if (htab->elf.dynamic_sections_created)
10021 /* Set the contents of the .interp section to the interpreter. */
10022 if (bfd_link_executable (info) && !info->nointerp)
10024 s = bfd_get_linker_section (dynobj, ".interp");
10027 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10028 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10032 /* Set up .got offsets for local syms, and space for local dynamic
10034 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10036 struct got_entry **lgot_ents;
10037 struct got_entry **end_lgot_ents;
10038 struct plt_entry **local_plt;
10039 struct plt_entry **end_local_plt;
10040 unsigned char *lgot_masks;
10041 bfd_size_type locsymcount;
10042 Elf_Internal_Shdr *symtab_hdr;
10044 if (!is_ppc64_elf (ibfd))
10047 for (s = ibfd->sections; s != NULL; s = s->next)
10049 struct ppc_dyn_relocs *p;
10051 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10053 if (!bfd_is_abs_section (p->sec)
10054 && bfd_is_abs_section (p->sec->output_section))
10056 /* Input section has been discarded, either because
10057 it is a copy of a linkonce section or due to
10058 linker script /DISCARD/, so we'll be discarding
10061 else if (p->count != 0)
10063 asection *srel = elf_section_data (p->sec)->sreloc;
10065 srel = htab->elf.irelplt;
10066 srel->size += p->count * sizeof (Elf64_External_Rela);
10067 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10068 info->flags |= DF_TEXTREL;
10073 lgot_ents = elf_local_got_ents (ibfd);
10077 symtab_hdr = &elf_symtab_hdr (ibfd);
10078 locsymcount = symtab_hdr->sh_info;
10079 end_lgot_ents = lgot_ents + locsymcount;
10080 local_plt = (struct plt_entry **) end_lgot_ents;
10081 end_local_plt = local_plt + locsymcount;
10082 lgot_masks = (unsigned char *) end_local_plt;
10083 s = ppc64_elf_tdata (ibfd)->got;
10084 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10086 struct got_entry **pent, *ent;
10089 while ((ent = *pent) != NULL)
10090 if (ent->got.refcount > 0)
10092 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10094 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10099 unsigned int ent_size = 8;
10100 unsigned int rel_size = sizeof (Elf64_External_Rela);
10102 ent->got.offset = s->size;
10103 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10108 s->size += ent_size;
10109 if ((*lgot_masks & PLT_IFUNC) != 0)
10111 htab->elf.irelplt->size += rel_size;
10112 htab->got_reli_size += rel_size;
10114 else if (bfd_link_pic (info))
10116 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10117 srel->size += rel_size;
10126 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10127 for (; local_plt < end_local_plt; ++local_plt)
10129 struct plt_entry *ent;
10131 for (ent = *local_plt; ent != NULL; ent = ent->next)
10132 if (ent->plt.refcount > 0)
10134 s = htab->elf.iplt;
10135 ent->plt.offset = s->size;
10136 s->size += PLT_ENTRY_SIZE (htab);
10138 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10141 ent->plt.offset = (bfd_vma) -1;
10145 /* Allocate global sym .plt and .got entries, and space for global
10146 sym dynamic relocs. */
10147 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10148 /* Stash the end of glink branch table. */
10149 if (htab->glink != NULL)
10150 htab->glink->rawsize = htab->glink->size;
10152 if (!htab->opd_abi && !bfd_link_pic (info))
10153 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10155 first_tlsld = NULL;
10156 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10158 struct got_entry *ent;
10160 if (!is_ppc64_elf (ibfd))
10163 ent = ppc64_tlsld_got (ibfd);
10164 if (ent->got.refcount > 0)
10166 if (!htab->do_multi_toc && first_tlsld != NULL)
10168 ent->is_indirect = TRUE;
10169 ent->got.ent = first_tlsld;
10173 if (first_tlsld == NULL)
10175 s = ppc64_elf_tdata (ibfd)->got;
10176 ent->got.offset = s->size;
10179 if (bfd_link_pic (info))
10181 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10182 srel->size += sizeof (Elf64_External_Rela);
10187 ent->got.offset = (bfd_vma) -1;
10190 /* We now have determined the sizes of the various dynamic sections.
10191 Allocate memory for them. */
10193 for (s = dynobj->sections; s != NULL; s = s->next)
10195 if ((s->flags & SEC_LINKER_CREATED) == 0)
10198 if (s == htab->brlt || s == htab->relbrlt)
10199 /* These haven't been allocated yet; don't strip. */
10201 else if (s == htab->elf.sgot
10202 || s == htab->elf.splt
10203 || s == htab->elf.iplt
10204 || s == htab->glink
10205 || s == htab->elf.sdynbss
10206 || s == htab->elf.sdynrelro)
10208 /* Strip this section if we don't need it; see the
10211 else if (s == htab->glink_eh_frame)
10213 if (!bfd_is_abs_section (s->output_section))
10214 /* Not sized yet. */
10217 else if (CONST_STRNEQ (s->name, ".rela"))
10221 if (s != htab->elf.srelplt)
10224 /* We use the reloc_count field as a counter if we need
10225 to copy relocs into the output file. */
10226 s->reloc_count = 0;
10231 /* It's not one of our sections, so don't allocate space. */
10237 /* If we don't need this section, strip it from the
10238 output file. This is mostly to handle .rela.bss and
10239 .rela.plt. We must create both sections in
10240 create_dynamic_sections, because they must be created
10241 before the linker maps input sections to output
10242 sections. The linker does that before
10243 adjust_dynamic_symbol is called, and it is that
10244 function which decides whether anything needs to go
10245 into these sections. */
10246 s->flags |= SEC_EXCLUDE;
10250 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10253 /* Allocate memory for the section contents. We use bfd_zalloc
10254 here in case unused entries are not reclaimed before the
10255 section's contents are written out. This should not happen,
10256 but this way if it does we get a R_PPC64_NONE reloc in .rela
10257 sections instead of garbage.
10258 We also rely on the section contents being zero when writing
10259 the GOT and .dynrelro. */
10260 s->contents = bfd_zalloc (dynobj, s->size);
10261 if (s->contents == NULL)
10265 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10267 if (!is_ppc64_elf (ibfd))
10270 s = ppc64_elf_tdata (ibfd)->got;
10271 if (s != NULL && s != htab->elf.sgot)
10274 s->flags |= SEC_EXCLUDE;
10277 s->contents = bfd_zalloc (ibfd, s->size);
10278 if (s->contents == NULL)
10282 s = ppc64_elf_tdata (ibfd)->relgot;
10286 s->flags |= SEC_EXCLUDE;
10289 s->contents = bfd_zalloc (ibfd, s->size);
10290 if (s->contents == NULL)
10293 s->reloc_count = 0;
10298 if (htab->elf.dynamic_sections_created)
10300 bfd_boolean tls_opt;
10302 /* Add some entries to the .dynamic section. We fill in the
10303 values later, in ppc64_elf_finish_dynamic_sections, but we
10304 must add the entries now so that we get the correct size for
10305 the .dynamic section. The DT_DEBUG entry is filled in by the
10306 dynamic linker and used by the debugger. */
10307 #define add_dynamic_entry(TAG, VAL) \
10308 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10310 if (bfd_link_executable (info))
10312 if (!add_dynamic_entry (DT_DEBUG, 0))
10316 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10318 if (!add_dynamic_entry (DT_PLTGOT, 0)
10319 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10320 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10321 || !add_dynamic_entry (DT_JMPREL, 0)
10322 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10326 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10328 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10329 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10333 tls_opt = (htab->params->tls_get_addr_opt
10334 && htab->tls_get_addr_fd != NULL
10335 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10336 if (tls_opt || !htab->opd_abi)
10338 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10344 if (!add_dynamic_entry (DT_RELA, 0)
10345 || !add_dynamic_entry (DT_RELASZ, 0)
10346 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10349 /* If any dynamic relocs apply to a read-only section,
10350 then we need a DT_TEXTREL entry. */
10351 if ((info->flags & DF_TEXTREL) == 0)
10352 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10354 if ((info->flags & DF_TEXTREL) != 0)
10356 if (!add_dynamic_entry (DT_TEXTREL, 0))
10361 #undef add_dynamic_entry
10366 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10369 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10371 if (h->plt.plist != NULL
10373 && !h->pointer_equality_needed)
10376 return _bfd_elf_hash_symbol (h);
10379 /* Determine the type of stub needed, if any, for a call. */
10381 static inline enum ppc_stub_type
10382 ppc_type_of_stub (asection *input_sec,
10383 const Elf_Internal_Rela *rel,
10384 struct ppc_link_hash_entry **hash,
10385 struct plt_entry **plt_ent,
10386 bfd_vma destination,
10387 unsigned long local_off)
10389 struct ppc_link_hash_entry *h = *hash;
10391 bfd_vma branch_offset;
10392 bfd_vma max_branch_offset;
10393 enum elf_ppc64_reloc_type r_type;
10397 struct plt_entry *ent;
10398 struct ppc_link_hash_entry *fdh = h;
10400 && h->oh->is_func_descriptor)
10402 fdh = ppc_follow_link (h->oh);
10406 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10407 if (ent->addend == rel->r_addend
10408 && ent->plt.offset != (bfd_vma) -1)
10411 return ppc_stub_plt_call;
10414 /* Here, we know we don't have a plt entry. If we don't have a
10415 either a defined function descriptor or a defined entry symbol
10416 in a regular object file, then it is pointless trying to make
10417 any other type of stub. */
10418 if (!is_static_defined (&fdh->elf)
10419 && !is_static_defined (&h->elf))
10420 return ppc_stub_none;
10422 else if (elf_local_got_ents (input_sec->owner) != NULL)
10424 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10425 struct plt_entry **local_plt = (struct plt_entry **)
10426 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10427 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10429 if (local_plt[r_symndx] != NULL)
10431 struct plt_entry *ent;
10433 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10434 if (ent->addend == rel->r_addend
10435 && ent->plt.offset != (bfd_vma) -1)
10438 return ppc_stub_plt_call;
10443 /* Determine where the call point is. */
10444 location = (input_sec->output_offset
10445 + input_sec->output_section->vma
10448 branch_offset = destination - location;
10449 r_type = ELF64_R_TYPE (rel->r_info);
10451 /* Determine if a long branch stub is needed. */
10452 max_branch_offset = 1 << 25;
10453 if (r_type != R_PPC64_REL24)
10454 max_branch_offset = 1 << 15;
10456 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10457 /* We need a stub. Figure out whether a long_branch or plt_branch
10458 is needed later. */
10459 return ppc_stub_long_branch;
10461 return ppc_stub_none;
10464 /* With power7 weakly ordered memory model, it is possible for ld.so
10465 to update a plt entry in one thread and have another thread see a
10466 stale zero toc entry. To avoid this we need some sort of acquire
10467 barrier in the call stub. One solution is to make the load of the
10468 toc word seem to appear to depend on the load of the function entry
10469 word. Another solution is to test for r2 being zero, and branch to
10470 the appropriate glink entry if so.
10472 . fake dep barrier compare
10473 . ld 12,xxx(2) ld 12,xxx(2)
10474 . mtctr 12 mtctr 12
10475 . xor 11,12,12 ld 2,xxx+8(2)
10476 . add 2,2,11 cmpldi 2,0
10477 . ld 2,xxx+8(2) bnectr+
10478 . bctr b <glink_entry>
10480 The solution involving the compare turns out to be faster, so
10481 that's what we use unless the branch won't reach. */
10483 #define ALWAYS_USE_FAKE_DEP 0
10484 #define ALWAYS_EMIT_R2SAVE 0
10486 #define PPC_LO(v) ((v) & 0xffff)
10487 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10488 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10490 static inline unsigned int
10491 plt_stub_size (struct ppc_link_hash_table *htab,
10492 struct ppc_stub_hash_entry *stub_entry,
10495 unsigned size = 12;
10497 if (ALWAYS_EMIT_R2SAVE
10498 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10500 if (PPC_HA (off) != 0)
10505 if (htab->params->plt_static_chain)
10507 if (htab->params->plt_thread_safe
10508 && htab->elf.dynamic_sections_created
10509 && stub_entry->h != NULL
10510 && stub_entry->h->elf.dynindx != -1)
10512 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10515 if (stub_entry->h != NULL
10516 && (stub_entry->h == htab->tls_get_addr_fd
10517 || stub_entry->h == htab->tls_get_addr)
10518 && htab->params->tls_get_addr_opt)
10523 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10524 then return the padding needed to do so. */
10525 static inline unsigned int
10526 plt_stub_pad (struct ppc_link_hash_table *htab,
10527 struct ppc_stub_hash_entry *stub_entry,
10530 int stub_align = 1 << htab->params->plt_stub_align;
10531 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10532 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10534 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10535 > ((stub_size - 1) & -stub_align))
10536 return stub_align - (stub_off & (stub_align - 1));
10540 /* Build a .plt call stub. */
10542 static inline bfd_byte *
10543 build_plt_stub (struct ppc_link_hash_table *htab,
10544 struct ppc_stub_hash_entry *stub_entry,
10545 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10547 bfd *obfd = htab->params->stub_bfd;
10548 bfd_boolean plt_load_toc = htab->opd_abi;
10549 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10550 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10551 && htab->elf.dynamic_sections_created
10552 && stub_entry->h != NULL
10553 && stub_entry->h->elf.dynindx != -1);
10554 bfd_boolean use_fake_dep = plt_thread_safe;
10555 bfd_vma cmp_branch_off = 0;
10557 if (!ALWAYS_USE_FAKE_DEP
10560 && !((stub_entry->h == htab->tls_get_addr_fd
10561 || stub_entry->h == htab->tls_get_addr)
10562 && htab->params->tls_get_addr_opt))
10564 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10565 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10566 / PLT_ENTRY_SIZE (htab));
10567 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10570 if (pltindex > 32768)
10571 glinkoff += (pltindex - 32768) * 4;
10573 + htab->glink->output_offset
10574 + htab->glink->output_section->vma);
10575 from = (p - stub_entry->group->stub_sec->contents
10576 + 4 * (ALWAYS_EMIT_R2SAVE
10577 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10578 + 4 * (PPC_HA (offset) != 0)
10579 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10580 != PPC_HA (offset))
10581 + 4 * (plt_static_chain != 0)
10583 + stub_entry->group->stub_sec->output_offset
10584 + stub_entry->group->stub_sec->output_section->vma);
10585 cmp_branch_off = to - from;
10586 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10589 if (PPC_HA (offset) != 0)
10593 if (ALWAYS_EMIT_R2SAVE
10594 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10595 r[0].r_offset += 4;
10596 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10597 r[1].r_offset = r[0].r_offset + 4;
10598 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10599 r[1].r_addend = r[0].r_addend;
10602 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10604 r[2].r_offset = r[1].r_offset + 4;
10605 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10606 r[2].r_addend = r[0].r_addend;
10610 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10611 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10612 r[2].r_addend = r[0].r_addend + 8;
10613 if (plt_static_chain)
10615 r[3].r_offset = r[2].r_offset + 4;
10616 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10617 r[3].r_addend = r[0].r_addend + 16;
10622 if (ALWAYS_EMIT_R2SAVE
10623 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10624 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10627 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10628 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10632 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10633 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10636 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10638 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10641 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10646 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10647 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10649 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10650 if (plt_static_chain)
10651 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10658 if (ALWAYS_EMIT_R2SAVE
10659 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10660 r[0].r_offset += 4;
10661 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10664 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10666 r[1].r_offset = r[0].r_offset + 4;
10667 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10668 r[1].r_addend = r[0].r_addend;
10672 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10673 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10674 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10675 if (plt_static_chain)
10677 r[2].r_offset = r[1].r_offset + 4;
10678 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10679 r[2].r_addend = r[0].r_addend + 8;
10684 if (ALWAYS_EMIT_R2SAVE
10685 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10686 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10687 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10689 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10691 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10694 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10699 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10700 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10702 if (plt_static_chain)
10703 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10704 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10707 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10709 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10710 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10711 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10714 bfd_put_32 (obfd, BCTR, p), p += 4;
10718 /* Build a special .plt call stub for __tls_get_addr. */
10720 #define LD_R11_0R3 0xe9630000
10721 #define LD_R12_0R3 0xe9830000
10722 #define MR_R0_R3 0x7c601b78
10723 #define CMPDI_R11_0 0x2c2b0000
10724 #define ADD_R3_R12_R13 0x7c6c6a14
10725 #define BEQLR 0x4d820020
10726 #define MR_R3_R0 0x7c030378
10727 #define STD_R11_0R1 0xf9610000
10728 #define BCTRL 0x4e800421
10729 #define LD_R11_0R1 0xe9610000
10730 #define MTLR_R11 0x7d6803a6
10732 static inline bfd_byte *
10733 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10734 struct ppc_stub_hash_entry *stub_entry,
10735 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10737 bfd *obfd = htab->params->stub_bfd;
10739 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10740 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10741 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10742 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10743 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10744 bfd_put_32 (obfd, BEQLR, p), p += 4;
10745 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10746 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10747 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10750 r[0].r_offset += 9 * 4;
10751 p = build_plt_stub (htab, stub_entry, p, offset, r);
10752 bfd_put_32 (obfd, BCTRL, p - 4);
10754 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10755 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10756 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10757 bfd_put_32 (obfd, BLR, p), p += 4;
10762 static Elf_Internal_Rela *
10763 get_relocs (asection *sec, int count)
10765 Elf_Internal_Rela *relocs;
10766 struct bfd_elf_section_data *elfsec_data;
10768 elfsec_data = elf_section_data (sec);
10769 relocs = elfsec_data->relocs;
10770 if (relocs == NULL)
10772 bfd_size_type relsize;
10773 relsize = sec->reloc_count * sizeof (*relocs);
10774 relocs = bfd_alloc (sec->owner, relsize);
10775 if (relocs == NULL)
10777 elfsec_data->relocs = relocs;
10778 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10779 sizeof (Elf_Internal_Shdr));
10780 if (elfsec_data->rela.hdr == NULL)
10782 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10783 * sizeof (Elf64_External_Rela));
10784 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10785 sec->reloc_count = 0;
10787 relocs += sec->reloc_count;
10788 sec->reloc_count += count;
10793 get_r2off (struct bfd_link_info *info,
10794 struct ppc_stub_hash_entry *stub_entry)
10796 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10797 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10801 /* Support linking -R objects. Get the toc pointer from the
10804 if (!htab->opd_abi)
10806 asection *opd = stub_entry->h->elf.root.u.def.section;
10807 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10809 if (strcmp (opd->name, ".opd") != 0
10810 || opd->reloc_count != 0)
10812 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10813 stub_entry->h->elf.root.root.string);
10814 bfd_set_error (bfd_error_bad_value);
10815 return (bfd_vma) -1;
10817 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10818 return (bfd_vma) -1;
10819 r2off = bfd_get_64 (opd->owner, buf);
10820 r2off -= elf_gp (info->output_bfd);
10822 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10827 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10829 struct ppc_stub_hash_entry *stub_entry;
10830 struct ppc_branch_hash_entry *br_entry;
10831 struct bfd_link_info *info;
10832 struct ppc_link_hash_table *htab;
10837 Elf_Internal_Rela *r;
10840 /* Massage our args to the form they really have. */
10841 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10844 htab = ppc_hash_table (info);
10848 /* Make a note of the offset within the stubs for this entry. */
10849 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10850 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10852 htab->stub_count[stub_entry->stub_type - 1] += 1;
10853 switch (stub_entry->stub_type)
10855 case ppc_stub_long_branch:
10856 case ppc_stub_long_branch_r2off:
10857 /* Branches are relative. This is where we are going to. */
10858 dest = (stub_entry->target_value
10859 + stub_entry->target_section->output_offset
10860 + stub_entry->target_section->output_section->vma);
10861 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10864 /* And this is where we are coming from. */
10865 off -= (stub_entry->stub_offset
10866 + stub_entry->group->stub_sec->output_offset
10867 + stub_entry->group->stub_sec->output_section->vma);
10870 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10872 bfd_vma r2off = get_r2off (info, stub_entry);
10874 if (r2off == (bfd_vma) -1)
10876 htab->stub_error = TRUE;
10879 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10882 if (PPC_HA (r2off) != 0)
10884 bfd_put_32 (htab->params->stub_bfd,
10885 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10889 if (PPC_LO (r2off) != 0)
10891 bfd_put_32 (htab->params->stub_bfd,
10892 ADDI_R2_R2 | PPC_LO (r2off), loc);
10898 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10900 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10902 info->callbacks->einfo
10903 (_("%P: long branch stub `%s' offset overflow\n"),
10904 stub_entry->root.string);
10905 htab->stub_error = TRUE;
10909 if (info->emitrelocations)
10911 r = get_relocs (stub_entry->group->stub_sec, 1);
10914 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10915 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10916 r->r_addend = dest;
10917 if (stub_entry->h != NULL)
10919 struct elf_link_hash_entry **hashes;
10920 unsigned long symndx;
10921 struct ppc_link_hash_entry *h;
10923 hashes = elf_sym_hashes (htab->params->stub_bfd);
10924 if (hashes == NULL)
10926 bfd_size_type hsize;
10928 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10929 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10930 if (hashes == NULL)
10932 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10933 htab->stub_globals = 1;
10935 symndx = htab->stub_globals++;
10937 hashes[symndx] = &h->elf;
10938 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10939 if (h->oh != NULL && h->oh->is_func)
10940 h = ppc_follow_link (h->oh);
10941 if (h->elf.root.u.def.section != stub_entry->target_section)
10942 /* H is an opd symbol. The addend must be zero. */
10946 off = (h->elf.root.u.def.value
10947 + h->elf.root.u.def.section->output_offset
10948 + h->elf.root.u.def.section->output_section->vma);
10949 r->r_addend -= off;
10955 case ppc_stub_plt_branch:
10956 case ppc_stub_plt_branch_r2off:
10957 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10958 stub_entry->root.string + 9,
10960 if (br_entry == NULL)
10962 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10963 stub_entry->root.string);
10964 htab->stub_error = TRUE;
10968 dest = (stub_entry->target_value
10969 + stub_entry->target_section->output_offset
10970 + stub_entry->target_section->output_section->vma);
10971 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10972 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10974 bfd_put_64 (htab->brlt->owner, dest,
10975 htab->brlt->contents + br_entry->offset);
10977 if (br_entry->iter == htab->stub_iteration)
10979 br_entry->iter = 0;
10981 if (htab->relbrlt != NULL)
10983 /* Create a reloc for the branch lookup table entry. */
10984 Elf_Internal_Rela rela;
10987 rela.r_offset = (br_entry->offset
10988 + htab->brlt->output_offset
10989 + htab->brlt->output_section->vma);
10990 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10991 rela.r_addend = dest;
10993 rl = htab->relbrlt->contents;
10994 rl += (htab->relbrlt->reloc_count++
10995 * sizeof (Elf64_External_Rela));
10996 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10998 else if (info->emitrelocations)
11000 r = get_relocs (htab->brlt, 1);
11003 /* brlt, being SEC_LINKER_CREATED does not go through the
11004 normal reloc processing. Symbols and offsets are not
11005 translated from input file to output file form, so
11006 set up the offset per the output file. */
11007 r->r_offset = (br_entry->offset
11008 + htab->brlt->output_offset
11009 + htab->brlt->output_section->vma);
11010 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11011 r->r_addend = dest;
11015 dest = (br_entry->offset
11016 + htab->brlt->output_offset
11017 + htab->brlt->output_section->vma);
11020 - elf_gp (htab->brlt->output_section->owner)
11021 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11023 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11025 info->callbacks->einfo
11026 (_("%P: linkage table error against `%T'\n"),
11027 stub_entry->root.string);
11028 bfd_set_error (bfd_error_bad_value);
11029 htab->stub_error = TRUE;
11033 if (info->emitrelocations)
11035 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11038 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11039 if (bfd_big_endian (info->output_bfd))
11040 r[0].r_offset += 2;
11041 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11042 r[0].r_offset += 4;
11043 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11044 r[0].r_addend = dest;
11045 if (PPC_HA (off) != 0)
11047 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11048 r[1].r_offset = r[0].r_offset + 4;
11049 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11050 r[1].r_addend = r[0].r_addend;
11054 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11056 if (PPC_HA (off) != 0)
11059 bfd_put_32 (htab->params->stub_bfd,
11060 ADDIS_R12_R2 | PPC_HA (off), loc);
11062 bfd_put_32 (htab->params->stub_bfd,
11063 LD_R12_0R12 | PPC_LO (off), loc);
11068 bfd_put_32 (htab->params->stub_bfd,
11069 LD_R12_0R2 | PPC_LO (off), loc);
11074 bfd_vma r2off = get_r2off (info, stub_entry);
11076 if (r2off == (bfd_vma) -1)
11078 htab->stub_error = TRUE;
11082 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11085 if (PPC_HA (off) != 0)
11088 bfd_put_32 (htab->params->stub_bfd,
11089 ADDIS_R12_R2 | PPC_HA (off), loc);
11091 bfd_put_32 (htab->params->stub_bfd,
11092 LD_R12_0R12 | PPC_LO (off), loc);
11095 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11097 if (PPC_HA (r2off) != 0)
11101 bfd_put_32 (htab->params->stub_bfd,
11102 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11104 if (PPC_LO (r2off) != 0)
11108 bfd_put_32 (htab->params->stub_bfd,
11109 ADDI_R2_R2 | PPC_LO (r2off), loc);
11113 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11115 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11118 case ppc_stub_plt_call:
11119 case ppc_stub_plt_call_r2save:
11120 if (stub_entry->h != NULL
11121 && stub_entry->h->is_func_descriptor
11122 && stub_entry->h->oh != NULL)
11124 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11126 /* If the old-ABI "dot-symbol" is undefined make it weak so
11127 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11128 if (fh->elf.root.type == bfd_link_hash_undefined
11129 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11130 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11131 fh->elf.root.type = bfd_link_hash_undefweak;
11134 /* Now build the stub. */
11135 dest = stub_entry->plt_ent->plt.offset & ~1;
11136 if (dest >= (bfd_vma) -2)
11139 plt = htab->elf.splt;
11140 if (!htab->elf.dynamic_sections_created
11141 || stub_entry->h == NULL
11142 || stub_entry->h->elf.dynindx == -1)
11143 plt = htab->elf.iplt;
11145 dest += plt->output_offset + plt->output_section->vma;
11147 if (stub_entry->h == NULL
11148 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11150 Elf_Internal_Rela rela;
11153 rela.r_offset = dest;
11155 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11157 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11158 rela.r_addend = (stub_entry->target_value
11159 + stub_entry->target_section->output_offset
11160 + stub_entry->target_section->output_section->vma);
11162 rl = (htab->elf.irelplt->contents
11163 + (htab->elf.irelplt->reloc_count++
11164 * sizeof (Elf64_External_Rela)));
11165 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11166 stub_entry->plt_ent->plt.offset |= 1;
11170 - elf_gp (plt->output_section->owner)
11171 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11173 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11175 info->callbacks->einfo
11176 /* xgettext:c-format */
11177 (_("%P: linkage table error against `%T'\n"),
11178 stub_entry->h != NULL
11179 ? stub_entry->h->elf.root.root.string
11181 bfd_set_error (bfd_error_bad_value);
11182 htab->stub_error = TRUE;
11186 if (htab->params->plt_stub_align != 0)
11188 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11190 stub_entry->group->stub_sec->size += pad;
11191 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11196 if (info->emitrelocations)
11198 r = get_relocs (stub_entry->group->stub_sec,
11199 ((PPC_HA (off) != 0)
11201 ? 2 + (htab->params->plt_static_chain
11202 && PPC_HA (off + 16) == PPC_HA (off))
11206 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11207 if (bfd_big_endian (info->output_bfd))
11208 r[0].r_offset += 2;
11209 r[0].r_addend = dest;
11211 if (stub_entry->h != NULL
11212 && (stub_entry->h == htab->tls_get_addr_fd
11213 || stub_entry->h == htab->tls_get_addr)
11214 && htab->params->tls_get_addr_opt)
11215 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11217 p = build_plt_stub (htab, stub_entry, loc, off, r);
11221 case ppc_stub_save_res:
11229 stub_entry->group->stub_sec->size += size;
11231 if (htab->params->emit_stub_syms)
11233 struct elf_link_hash_entry *h;
11236 const char *const stub_str[] = { "long_branch",
11237 "long_branch_r2off",
11239 "plt_branch_r2off",
11243 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11244 len2 = strlen (stub_entry->root.string);
11245 name = bfd_malloc (len1 + len2 + 2);
11248 memcpy (name, stub_entry->root.string, 9);
11249 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11250 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11251 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11254 if (h->root.type == bfd_link_hash_new)
11256 h->root.type = bfd_link_hash_defined;
11257 h->root.u.def.section = stub_entry->group->stub_sec;
11258 h->root.u.def.value = stub_entry->stub_offset;
11259 h->ref_regular = 1;
11260 h->def_regular = 1;
11261 h->ref_regular_nonweak = 1;
11262 h->forced_local = 1;
11264 h->root.linker_def = 1;
11271 /* As above, but don't actually build the stub. Just bump offset so
11272 we know stub section sizes, and select plt_branch stubs where
11273 long_branch stubs won't do. */
11276 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11278 struct ppc_stub_hash_entry *stub_entry;
11279 struct bfd_link_info *info;
11280 struct ppc_link_hash_table *htab;
11284 /* Massage our args to the form they really have. */
11285 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11288 htab = ppc_hash_table (info);
11292 if (stub_entry->h != NULL
11293 && stub_entry->h->save_res
11294 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11295 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11297 /* Don't make stubs to out-of-line register save/restore
11298 functions. Instead, emit copies of the functions. */
11299 stub_entry->group->needs_save_res = 1;
11300 stub_entry->stub_type = ppc_stub_save_res;
11304 if (stub_entry->stub_type == ppc_stub_plt_call
11305 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11308 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11309 if (off >= (bfd_vma) -2)
11311 plt = htab->elf.splt;
11312 if (!htab->elf.dynamic_sections_created
11313 || stub_entry->h == NULL
11314 || stub_entry->h->elf.dynindx == -1)
11315 plt = htab->elf.iplt;
11316 off += (plt->output_offset
11317 + plt->output_section->vma
11318 - elf_gp (plt->output_section->owner)
11319 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11321 size = plt_stub_size (htab, stub_entry, off);
11322 if (htab->params->plt_stub_align)
11323 size += plt_stub_pad (htab, stub_entry, off);
11324 if (info->emitrelocations)
11326 stub_entry->group->stub_sec->reloc_count
11327 += ((PPC_HA (off) != 0)
11329 ? 2 + (htab->params->plt_static_chain
11330 && PPC_HA (off + 16) == PPC_HA (off))
11332 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11337 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11340 bfd_vma local_off = 0;
11342 off = (stub_entry->target_value
11343 + stub_entry->target_section->output_offset
11344 + stub_entry->target_section->output_section->vma);
11345 off -= (stub_entry->group->stub_sec->size
11346 + stub_entry->group->stub_sec->output_offset
11347 + stub_entry->group->stub_sec->output_section->vma);
11349 /* Reset the stub type from the plt variant in case we now
11350 can reach with a shorter stub. */
11351 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11352 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11355 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11357 r2off = get_r2off (info, stub_entry);
11358 if (r2off == (bfd_vma) -1)
11360 htab->stub_error = TRUE;
11364 if (PPC_HA (r2off) != 0)
11366 if (PPC_LO (r2off) != 0)
11371 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11373 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11374 Do the same for -R objects without function descriptors. */
11375 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11376 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11378 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11380 struct ppc_branch_hash_entry *br_entry;
11382 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11383 stub_entry->root.string + 9,
11385 if (br_entry == NULL)
11387 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11388 stub_entry->root.string);
11389 htab->stub_error = TRUE;
11393 if (br_entry->iter != htab->stub_iteration)
11395 br_entry->iter = htab->stub_iteration;
11396 br_entry->offset = htab->brlt->size;
11397 htab->brlt->size += 8;
11399 if (htab->relbrlt != NULL)
11400 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11401 else if (info->emitrelocations)
11403 htab->brlt->reloc_count += 1;
11404 htab->brlt->flags |= SEC_RELOC;
11408 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11409 off = (br_entry->offset
11410 + htab->brlt->output_offset
11411 + htab->brlt->output_section->vma
11412 - elf_gp (htab->brlt->output_section->owner)
11413 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11415 if (info->emitrelocations)
11417 stub_entry->group->stub_sec->reloc_count
11418 += 1 + (PPC_HA (off) != 0);
11419 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11422 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11425 if (PPC_HA (off) != 0)
11431 if (PPC_HA (off) != 0)
11434 if (PPC_HA (r2off) != 0)
11436 if (PPC_LO (r2off) != 0)
11440 else if (info->emitrelocations)
11442 stub_entry->group->stub_sec->reloc_count += 1;
11443 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11447 stub_entry->group->stub_sec->size += size;
11451 /* Set up various things so that we can make a list of input sections
11452 for each output section included in the link. Returns -1 on error,
11453 0 when no stubs will be needed, and 1 on success. */
11456 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11460 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11465 htab->sec_info_arr_size = bfd_get_next_section_id ();
11466 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11467 htab->sec_info = bfd_zmalloc (amt);
11468 if (htab->sec_info == NULL)
11471 /* Set toc_off for com, und, abs and ind sections. */
11472 for (id = 0; id < 3; id++)
11473 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11478 /* Set up for first pass at multitoc partitioning. */
11481 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11483 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11485 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11486 htab->toc_bfd = NULL;
11487 htab->toc_first_sec = NULL;
11490 /* The linker repeatedly calls this function for each TOC input section
11491 and linker generated GOT section. Group input bfds such that the toc
11492 within a group is less than 64k in size. */
11495 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11497 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11498 bfd_vma addr, off, limit;
11503 if (!htab->second_toc_pass)
11505 /* Keep track of the first .toc or .got section for this input bfd. */
11506 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11510 htab->toc_bfd = isec->owner;
11511 htab->toc_first_sec = isec;
11514 addr = isec->output_offset + isec->output_section->vma;
11515 off = addr - htab->toc_curr;
11516 limit = 0x80008000;
11517 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11519 if (off + isec->size > limit)
11521 addr = (htab->toc_first_sec->output_offset
11522 + htab->toc_first_sec->output_section->vma);
11523 htab->toc_curr = addr;
11524 htab->toc_curr &= -TOC_BASE_ALIGN;
11527 /* toc_curr is the base address of this toc group. Set elf_gp
11528 for the input section to be the offset relative to the
11529 output toc base plus 0x8000. Making the input elf_gp an
11530 offset allows us to move the toc as a whole without
11531 recalculating input elf_gp. */
11532 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11533 off += TOC_BASE_OFF;
11535 /* Die if someone uses a linker script that doesn't keep input
11536 file .toc and .got together. */
11538 && elf_gp (isec->owner) != 0
11539 && elf_gp (isec->owner) != off)
11542 elf_gp (isec->owner) = off;
11546 /* During the second pass toc_first_sec points to the start of
11547 a toc group, and toc_curr is used to track the old elf_gp.
11548 We use toc_bfd to ensure we only look at each bfd once. */
11549 if (htab->toc_bfd == isec->owner)
11551 htab->toc_bfd = isec->owner;
11553 if (htab->toc_first_sec == NULL
11554 || htab->toc_curr != elf_gp (isec->owner))
11556 htab->toc_curr = elf_gp (isec->owner);
11557 htab->toc_first_sec = isec;
11559 addr = (htab->toc_first_sec->output_offset
11560 + htab->toc_first_sec->output_section->vma);
11561 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11562 elf_gp (isec->owner) = off;
11567 /* Called via elf_link_hash_traverse to merge GOT entries for global
11571 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11573 if (h->root.type == bfd_link_hash_indirect)
11576 merge_got_entries (&h->got.glist);
11581 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11585 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11587 struct got_entry *gent;
11589 if (h->root.type == bfd_link_hash_indirect)
11592 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11593 if (!gent->is_indirect)
11594 allocate_got (h, (struct bfd_link_info *) inf, gent);
11598 /* Called on the first multitoc pass after the last call to
11599 ppc64_elf_next_toc_section. This function removes duplicate GOT
11603 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11605 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11606 struct bfd *ibfd, *ibfd2;
11607 bfd_boolean done_something;
11609 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11611 if (!htab->do_multi_toc)
11614 /* Merge global sym got entries within a toc group. */
11615 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11617 /* And tlsld_got. */
11618 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11620 struct got_entry *ent, *ent2;
11622 if (!is_ppc64_elf (ibfd))
11625 ent = ppc64_tlsld_got (ibfd);
11626 if (!ent->is_indirect
11627 && ent->got.offset != (bfd_vma) -1)
11629 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11631 if (!is_ppc64_elf (ibfd2))
11634 ent2 = ppc64_tlsld_got (ibfd2);
11635 if (!ent2->is_indirect
11636 && ent2->got.offset != (bfd_vma) -1
11637 && elf_gp (ibfd2) == elf_gp (ibfd))
11639 ent2->is_indirect = TRUE;
11640 ent2->got.ent = ent;
11646 /* Zap sizes of got sections. */
11647 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11648 htab->elf.irelplt->size -= htab->got_reli_size;
11649 htab->got_reli_size = 0;
11651 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11653 asection *got, *relgot;
11655 if (!is_ppc64_elf (ibfd))
11658 got = ppc64_elf_tdata (ibfd)->got;
11661 got->rawsize = got->size;
11663 relgot = ppc64_elf_tdata (ibfd)->relgot;
11664 relgot->rawsize = relgot->size;
11669 /* Now reallocate the got, local syms first. We don't need to
11670 allocate section contents again since we never increase size. */
11671 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11673 struct got_entry **lgot_ents;
11674 struct got_entry **end_lgot_ents;
11675 struct plt_entry **local_plt;
11676 struct plt_entry **end_local_plt;
11677 unsigned char *lgot_masks;
11678 bfd_size_type locsymcount;
11679 Elf_Internal_Shdr *symtab_hdr;
11682 if (!is_ppc64_elf (ibfd))
11685 lgot_ents = elf_local_got_ents (ibfd);
11689 symtab_hdr = &elf_symtab_hdr (ibfd);
11690 locsymcount = symtab_hdr->sh_info;
11691 end_lgot_ents = lgot_ents + locsymcount;
11692 local_plt = (struct plt_entry **) end_lgot_ents;
11693 end_local_plt = local_plt + locsymcount;
11694 lgot_masks = (unsigned char *) end_local_plt;
11695 s = ppc64_elf_tdata (ibfd)->got;
11696 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11698 struct got_entry *ent;
11700 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11702 unsigned int ent_size = 8;
11703 unsigned int rel_size = sizeof (Elf64_External_Rela);
11705 ent->got.offset = s->size;
11706 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11711 s->size += ent_size;
11712 if ((*lgot_masks & PLT_IFUNC) != 0)
11714 htab->elf.irelplt->size += rel_size;
11715 htab->got_reli_size += rel_size;
11717 else if (bfd_link_pic (info))
11719 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11720 srel->size += rel_size;
11726 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11728 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11730 struct got_entry *ent;
11732 if (!is_ppc64_elf (ibfd))
11735 ent = ppc64_tlsld_got (ibfd);
11736 if (!ent->is_indirect
11737 && ent->got.offset != (bfd_vma) -1)
11739 asection *s = ppc64_elf_tdata (ibfd)->got;
11740 ent->got.offset = s->size;
11742 if (bfd_link_pic (info))
11744 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11745 srel->size += sizeof (Elf64_External_Rela);
11750 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11751 if (!done_something)
11752 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11756 if (!is_ppc64_elf (ibfd))
11759 got = ppc64_elf_tdata (ibfd)->got;
11762 done_something = got->rawsize != got->size;
11763 if (done_something)
11768 if (done_something)
11769 (*htab->params->layout_sections_again) ();
11771 /* Set up for second pass over toc sections to recalculate elf_gp
11772 on input sections. */
11773 htab->toc_bfd = NULL;
11774 htab->toc_first_sec = NULL;
11775 htab->second_toc_pass = TRUE;
11776 return done_something;
11779 /* Called after second pass of multitoc partitioning. */
11782 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11784 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11786 /* After the second pass, toc_curr tracks the TOC offset used
11787 for code sections below in ppc64_elf_next_input_section. */
11788 htab->toc_curr = TOC_BASE_OFF;
11791 /* No toc references were found in ISEC. If the code in ISEC makes no
11792 calls, then there's no need to use toc adjusting stubs when branching
11793 into ISEC. Actually, indirect calls from ISEC are OK as they will
11794 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11795 needed, and 2 if a cyclical call-graph was found but no other reason
11796 for a stub was detected. If called from the top level, a return of
11797 2 means the same as a return of 0. */
11800 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11804 /* Mark this section as checked. */
11805 isec->call_check_done = 1;
11807 /* We know none of our code bearing sections will need toc stubs. */
11808 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11811 if (isec->size == 0)
11814 if (isec->output_section == NULL)
11818 if (isec->reloc_count != 0)
11820 Elf_Internal_Rela *relstart, *rel;
11821 Elf_Internal_Sym *local_syms;
11822 struct ppc_link_hash_table *htab;
11824 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11825 info->keep_memory);
11826 if (relstart == NULL)
11829 /* Look for branches to outside of this section. */
11831 htab = ppc_hash_table (info);
11835 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11837 enum elf_ppc64_reloc_type r_type;
11838 unsigned long r_symndx;
11839 struct elf_link_hash_entry *h;
11840 struct ppc_link_hash_entry *eh;
11841 Elf_Internal_Sym *sym;
11843 struct _opd_sec_data *opd;
11847 r_type = ELF64_R_TYPE (rel->r_info);
11848 if (r_type != R_PPC64_REL24
11849 && r_type != R_PPC64_REL14
11850 && r_type != R_PPC64_REL14_BRTAKEN
11851 && r_type != R_PPC64_REL14_BRNTAKEN)
11854 r_symndx = ELF64_R_SYM (rel->r_info);
11855 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11862 /* Calls to dynamic lib functions go through a plt call stub
11864 eh = (struct ppc_link_hash_entry *) h;
11866 && (eh->elf.plt.plist != NULL
11868 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11874 if (sym_sec == NULL)
11875 /* Ignore other undefined symbols. */
11878 /* Assume branches to other sections not included in the
11879 link need stubs too, to cover -R and absolute syms. */
11880 if (sym_sec->output_section == NULL)
11887 sym_value = sym->st_value;
11890 if (h->root.type != bfd_link_hash_defined
11891 && h->root.type != bfd_link_hash_defweak)
11893 sym_value = h->root.u.def.value;
11895 sym_value += rel->r_addend;
11897 /* If this branch reloc uses an opd sym, find the code section. */
11898 opd = get_opd_info (sym_sec);
11901 if (h == NULL && opd->adjust != NULL)
11905 adjust = opd->adjust[OPD_NDX (sym_value)];
11907 /* Assume deleted functions won't ever be called. */
11909 sym_value += adjust;
11912 dest = opd_entry_value (sym_sec, sym_value,
11913 &sym_sec, NULL, FALSE);
11914 if (dest == (bfd_vma) -1)
11919 + sym_sec->output_offset
11920 + sym_sec->output_section->vma);
11922 /* Ignore branch to self. */
11923 if (sym_sec == isec)
11926 /* If the called function uses the toc, we need a stub. */
11927 if (sym_sec->has_toc_reloc
11928 || sym_sec->makes_toc_func_call)
11934 /* Assume any branch that needs a long branch stub might in fact
11935 need a plt_branch stub. A plt_branch stub uses r2. */
11936 else if (dest - (isec->output_offset
11937 + isec->output_section->vma
11938 + rel->r_offset) + (1 << 25)
11939 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11947 /* If calling back to a section in the process of being
11948 tested, we can't say for sure that no toc adjusting stubs
11949 are needed, so don't return zero. */
11950 else if (sym_sec->call_check_in_progress)
11953 /* Branches to another section that itself doesn't have any TOC
11954 references are OK. Recursively call ourselves to check. */
11955 else if (!sym_sec->call_check_done)
11959 /* Mark current section as indeterminate, so that other
11960 sections that call back to current won't be marked as
11962 isec->call_check_in_progress = 1;
11963 recur = toc_adjusting_stub_needed (info, sym_sec);
11964 isec->call_check_in_progress = 0;
11975 if (local_syms != NULL
11976 && (elf_symtab_hdr (isec->owner).contents
11977 != (unsigned char *) local_syms))
11979 if (elf_section_data (isec)->relocs != relstart)
11984 && isec->map_head.s != NULL
11985 && (strcmp (isec->output_section->name, ".init") == 0
11986 || strcmp (isec->output_section->name, ".fini") == 0))
11988 if (isec->map_head.s->has_toc_reloc
11989 || isec->map_head.s->makes_toc_func_call)
11991 else if (!isec->map_head.s->call_check_done)
11994 isec->call_check_in_progress = 1;
11995 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11996 isec->call_check_in_progress = 0;
12003 isec->makes_toc_func_call = 1;
12008 /* The linker repeatedly calls this function for each input section,
12009 in the order that input sections are linked into output sections.
12010 Build lists of input sections to determine groupings between which
12011 we may insert linker stubs. */
12014 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12016 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12021 if ((isec->output_section->flags & SEC_CODE) != 0
12022 && isec->output_section->id < htab->sec_info_arr_size)
12024 /* This happens to make the list in reverse order,
12025 which is what we want. */
12026 htab->sec_info[isec->id].u.list
12027 = htab->sec_info[isec->output_section->id].u.list;
12028 htab->sec_info[isec->output_section->id].u.list = isec;
12031 if (htab->multi_toc_needed)
12033 /* Analyse sections that aren't already flagged as needing a
12034 valid toc pointer. Exclude .fixup for the linux kernel.
12035 .fixup contains branches, but only back to the function that
12036 hit an exception. */
12037 if (!(isec->has_toc_reloc
12038 || (isec->flags & SEC_CODE) == 0
12039 || strcmp (isec->name, ".fixup") == 0
12040 || isec->call_check_done))
12042 if (toc_adjusting_stub_needed (info, isec) < 0)
12045 /* Make all sections use the TOC assigned for this object file.
12046 This will be wrong for pasted sections; We fix that in
12047 check_pasted_section(). */
12048 if (elf_gp (isec->owner) != 0)
12049 htab->toc_curr = elf_gp (isec->owner);
12052 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12056 /* Check that all .init and .fini sections use the same toc, if they
12057 have toc relocs. */
12060 check_pasted_section (struct bfd_link_info *info, const char *name)
12062 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12066 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12067 bfd_vma toc_off = 0;
12070 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12071 if (i->has_toc_reloc)
12074 toc_off = htab->sec_info[i->id].toc_off;
12075 else if (toc_off != htab->sec_info[i->id].toc_off)
12080 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12081 if (i->makes_toc_func_call)
12083 toc_off = htab->sec_info[i->id].toc_off;
12087 /* Make sure the whole pasted function uses the same toc offset. */
12089 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12090 htab->sec_info[i->id].toc_off = toc_off;
12096 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12098 return (check_pasted_section (info, ".init")
12099 & check_pasted_section (info, ".fini"));
12102 /* See whether we can group stub sections together. Grouping stub
12103 sections may result in fewer stubs. More importantly, we need to
12104 put all .init* and .fini* stubs at the beginning of the .init or
12105 .fini output sections respectively, because glibc splits the
12106 _init and _fini functions into multiple parts. Putting a stub in
12107 the middle of a function is not a good idea. */
12110 group_sections (struct bfd_link_info *info,
12111 bfd_size_type stub_group_size,
12112 bfd_boolean stubs_always_before_branch)
12114 struct ppc_link_hash_table *htab;
12116 bfd_boolean suppress_size_errors;
12118 htab = ppc_hash_table (info);
12122 suppress_size_errors = FALSE;
12123 if (stub_group_size == 1)
12125 /* Default values. */
12126 if (stubs_always_before_branch)
12127 stub_group_size = 0x1e00000;
12129 stub_group_size = 0x1c00000;
12130 suppress_size_errors = TRUE;
12133 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12137 if (osec->id >= htab->sec_info_arr_size)
12140 tail = htab->sec_info[osec->id].u.list;
12141 while (tail != NULL)
12145 bfd_size_type total;
12146 bfd_boolean big_sec;
12148 struct map_stub *group;
12149 bfd_size_type group_size;
12152 total = tail->size;
12153 group_size = (ppc64_elf_section_data (tail) != NULL
12154 && ppc64_elf_section_data (tail)->has_14bit_branch
12155 ? stub_group_size >> 10 : stub_group_size);
12157 big_sec = total > group_size;
12158 if (big_sec && !suppress_size_errors)
12159 /* xgettext:c-format */
12160 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12161 tail->owner, tail);
12162 curr_toc = htab->sec_info[tail->id].toc_off;
12164 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12165 && ((total += curr->output_offset - prev->output_offset)
12166 < (ppc64_elf_section_data (prev) != NULL
12167 && ppc64_elf_section_data (prev)->has_14bit_branch
12168 ? (group_size = stub_group_size >> 10) : group_size))
12169 && htab->sec_info[prev->id].toc_off == curr_toc)
12172 /* OK, the size from the start of CURR to the end is less
12173 than group_size and thus can be handled by one stub
12174 section. (or the tail section is itself larger than
12175 group_size, in which case we may be toast.) We should
12176 really be keeping track of the total size of stubs added
12177 here, as stubs contribute to the final output section
12178 size. That's a little tricky, and this way will only
12179 break if stubs added make the total size more than 2^25,
12180 ie. for the default stub_group_size, if stubs total more
12181 than 2097152 bytes, or nearly 75000 plt call stubs. */
12182 group = bfd_alloc (curr->owner, sizeof (*group));
12185 group->link_sec = curr;
12186 group->stub_sec = NULL;
12187 group->needs_save_res = 0;
12188 group->next = htab->group;
12189 htab->group = group;
12192 prev = htab->sec_info[tail->id].u.list;
12193 /* Set up this stub group. */
12194 htab->sec_info[tail->id].u.group = group;
12196 while (tail != curr && (tail = prev) != NULL);
12198 /* But wait, there's more! Input sections up to group_size
12199 bytes before the stub section can be handled by it too.
12200 Don't do this if we have a really large section after the
12201 stubs, as adding more stubs increases the chance that
12202 branches may not reach into the stub section. */
12203 if (!stubs_always_before_branch && !big_sec)
12206 while (prev != NULL
12207 && ((total += tail->output_offset - prev->output_offset)
12208 < (ppc64_elf_section_data (prev) != NULL
12209 && ppc64_elf_section_data (prev)->has_14bit_branch
12210 ? (group_size = stub_group_size >> 10) : group_size))
12211 && htab->sec_info[prev->id].toc_off == curr_toc)
12214 prev = htab->sec_info[tail->id].u.list;
12215 htab->sec_info[tail->id].u.group = group;
12224 static const unsigned char glink_eh_frame_cie[] =
12226 0, 0, 0, 16, /* length. */
12227 0, 0, 0, 0, /* id. */
12228 1, /* CIE version. */
12229 'z', 'R', 0, /* Augmentation string. */
12230 4, /* Code alignment. */
12231 0x78, /* Data alignment. */
12233 1, /* Augmentation size. */
12234 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12235 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
12238 /* Stripping output sections is normally done before dynamic section
12239 symbols have been allocated. This function is called later, and
12240 handles cases like htab->brlt which is mapped to its own output
12244 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12246 if (isec->size == 0
12247 && isec->output_section->size == 0
12248 && !(isec->output_section->flags & SEC_KEEP)
12249 && !bfd_section_removed_from_list (info->output_bfd,
12250 isec->output_section)
12251 && elf_section_data (isec->output_section)->dynindx == 0)
12253 isec->output_section->flags |= SEC_EXCLUDE;
12254 bfd_section_list_remove (info->output_bfd, isec->output_section);
12255 info->output_bfd->section_count--;
12259 /* Determine and set the size of the stub section for a final link.
12261 The basic idea here is to examine all the relocations looking for
12262 PC-relative calls to a target that is unreachable with a "bl"
12266 ppc64_elf_size_stubs (struct bfd_link_info *info)
12268 bfd_size_type stub_group_size;
12269 bfd_boolean stubs_always_before_branch;
12270 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12275 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12276 htab->params->plt_thread_safe = 1;
12277 if (!htab->opd_abi)
12278 htab->params->plt_thread_safe = 0;
12279 else if (htab->params->plt_thread_safe == -1)
12281 static const char *const thread_starter[] =
12285 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12287 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12288 "mq_notify", "create_timer",
12293 "GOMP_parallel_start",
12294 "GOMP_parallel_loop_static",
12295 "GOMP_parallel_loop_static_start",
12296 "GOMP_parallel_loop_dynamic",
12297 "GOMP_parallel_loop_dynamic_start",
12298 "GOMP_parallel_loop_guided",
12299 "GOMP_parallel_loop_guided_start",
12300 "GOMP_parallel_loop_runtime",
12301 "GOMP_parallel_loop_runtime_start",
12302 "GOMP_parallel_sections",
12303 "GOMP_parallel_sections_start",
12309 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12311 struct elf_link_hash_entry *h;
12312 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12313 FALSE, FALSE, TRUE);
12314 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12315 if (htab->params->plt_thread_safe)
12319 stubs_always_before_branch = htab->params->group_size < 0;
12320 if (htab->params->group_size < 0)
12321 stub_group_size = -htab->params->group_size;
12323 stub_group_size = htab->params->group_size;
12325 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12328 #define STUB_SHRINK_ITER 20
12329 /* Loop until no stubs added. After iteration 20 of this loop we may
12330 exit on a stub section shrinking. This is to break out of a
12331 pathological case where adding stubs on one iteration decreases
12332 section gaps (perhaps due to alignment), which then requires
12333 fewer or smaller stubs on the next iteration. */
12338 unsigned int bfd_indx;
12339 struct map_stub *group;
12340 asection *stub_sec;
12342 htab->stub_iteration += 1;
12344 for (input_bfd = info->input_bfds, bfd_indx = 0;
12346 input_bfd = input_bfd->link.next, bfd_indx++)
12348 Elf_Internal_Shdr *symtab_hdr;
12350 Elf_Internal_Sym *local_syms = NULL;
12352 if (!is_ppc64_elf (input_bfd))
12355 /* We'll need the symbol table in a second. */
12356 symtab_hdr = &elf_symtab_hdr (input_bfd);
12357 if (symtab_hdr->sh_info == 0)
12360 /* Walk over each section attached to the input bfd. */
12361 for (section = input_bfd->sections;
12363 section = section->next)
12365 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12367 /* If there aren't any relocs, then there's nothing more
12369 if ((section->flags & SEC_RELOC) == 0
12370 || (section->flags & SEC_ALLOC) == 0
12371 || (section->flags & SEC_LOAD) == 0
12372 || (section->flags & SEC_CODE) == 0
12373 || section->reloc_count == 0)
12376 /* If this section is a link-once section that will be
12377 discarded, then don't create any stubs. */
12378 if (section->output_section == NULL
12379 || section->output_section->owner != info->output_bfd)
12382 /* Get the relocs. */
12384 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12385 info->keep_memory);
12386 if (internal_relocs == NULL)
12387 goto error_ret_free_local;
12389 /* Now examine each relocation. */
12390 irela = internal_relocs;
12391 irelaend = irela + section->reloc_count;
12392 for (; irela < irelaend; irela++)
12394 enum elf_ppc64_reloc_type r_type;
12395 unsigned int r_indx;
12396 enum ppc_stub_type stub_type;
12397 struct ppc_stub_hash_entry *stub_entry;
12398 asection *sym_sec, *code_sec;
12399 bfd_vma sym_value, code_value;
12400 bfd_vma destination;
12401 unsigned long local_off;
12402 bfd_boolean ok_dest;
12403 struct ppc_link_hash_entry *hash;
12404 struct ppc_link_hash_entry *fdh;
12405 struct elf_link_hash_entry *h;
12406 Elf_Internal_Sym *sym;
12408 const asection *id_sec;
12409 struct _opd_sec_data *opd;
12410 struct plt_entry *plt_ent;
12412 r_type = ELF64_R_TYPE (irela->r_info);
12413 r_indx = ELF64_R_SYM (irela->r_info);
12415 if (r_type >= R_PPC64_max)
12417 bfd_set_error (bfd_error_bad_value);
12418 goto error_ret_free_internal;
12421 /* Only look for stubs on branch instructions. */
12422 if (r_type != R_PPC64_REL24
12423 && r_type != R_PPC64_REL14
12424 && r_type != R_PPC64_REL14_BRTAKEN
12425 && r_type != R_PPC64_REL14_BRNTAKEN)
12428 /* Now determine the call target, its name, value,
12430 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12431 r_indx, input_bfd))
12432 goto error_ret_free_internal;
12433 hash = (struct ppc_link_hash_entry *) h;
12440 sym_value = sym->st_value;
12441 if (sym_sec != NULL
12442 && sym_sec->output_section != NULL)
12445 else if (hash->elf.root.type == bfd_link_hash_defined
12446 || hash->elf.root.type == bfd_link_hash_defweak)
12448 sym_value = hash->elf.root.u.def.value;
12449 if (sym_sec->output_section != NULL)
12452 else if (hash->elf.root.type == bfd_link_hash_undefweak
12453 || hash->elf.root.type == bfd_link_hash_undefined)
12455 /* Recognise an old ABI func code entry sym, and
12456 use the func descriptor sym instead if it is
12458 if (hash->elf.root.root.string[0] == '.'
12459 && hash->oh != NULL)
12461 fdh = ppc_follow_link (hash->oh);
12462 if (fdh->elf.root.type == bfd_link_hash_defined
12463 || fdh->elf.root.type == bfd_link_hash_defweak)
12465 sym_sec = fdh->elf.root.u.def.section;
12466 sym_value = fdh->elf.root.u.def.value;
12467 if (sym_sec->output_section != NULL)
12476 bfd_set_error (bfd_error_bad_value);
12477 goto error_ret_free_internal;
12484 sym_value += irela->r_addend;
12485 destination = (sym_value
12486 + sym_sec->output_offset
12487 + sym_sec->output_section->vma);
12488 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12493 code_sec = sym_sec;
12494 code_value = sym_value;
12495 opd = get_opd_info (sym_sec);
12500 if (hash == NULL && opd->adjust != NULL)
12502 long adjust = opd->adjust[OPD_NDX (sym_value)];
12505 code_value += adjust;
12506 sym_value += adjust;
12508 dest = opd_entry_value (sym_sec, sym_value,
12509 &code_sec, &code_value, FALSE);
12510 if (dest != (bfd_vma) -1)
12512 destination = dest;
12515 /* Fixup old ABI sym to point at code
12517 hash->elf.root.type = bfd_link_hash_defweak;
12518 hash->elf.root.u.def.section = code_sec;
12519 hash->elf.root.u.def.value = code_value;
12524 /* Determine what (if any) linker stub is needed. */
12526 stub_type = ppc_type_of_stub (section, irela, &hash,
12527 &plt_ent, destination,
12530 if (stub_type != ppc_stub_plt_call)
12532 /* Check whether we need a TOC adjusting stub.
12533 Since the linker pastes together pieces from
12534 different object files when creating the
12535 _init and _fini functions, it may be that a
12536 call to what looks like a local sym is in
12537 fact a call needing a TOC adjustment. */
12538 if (code_sec != NULL
12539 && code_sec->output_section != NULL
12540 && (htab->sec_info[code_sec->id].toc_off
12541 != htab->sec_info[section->id].toc_off)
12542 && (code_sec->has_toc_reloc
12543 || code_sec->makes_toc_func_call))
12544 stub_type = ppc_stub_long_branch_r2off;
12547 if (stub_type == ppc_stub_none)
12550 /* __tls_get_addr calls might be eliminated. */
12551 if (stub_type != ppc_stub_plt_call
12553 && (hash == htab->tls_get_addr
12554 || hash == htab->tls_get_addr_fd)
12555 && section->has_tls_reloc
12556 && irela != internal_relocs)
12558 /* Get tls info. */
12559 unsigned char *tls_mask;
12561 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12562 irela - 1, input_bfd))
12563 goto error_ret_free_internal;
12564 if (*tls_mask != 0)
12568 if (stub_type == ppc_stub_plt_call
12569 && irela + 1 < irelaend
12570 && irela[1].r_offset == irela->r_offset + 4
12571 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12573 if (!tocsave_find (htab, INSERT,
12574 &local_syms, irela + 1, input_bfd))
12575 goto error_ret_free_internal;
12577 else if (stub_type == ppc_stub_plt_call)
12578 stub_type = ppc_stub_plt_call_r2save;
12580 /* Support for grouping stub sections. */
12581 id_sec = htab->sec_info[section->id].u.group->link_sec;
12583 /* Get the name of this stub. */
12584 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12586 goto error_ret_free_internal;
12588 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12589 stub_name, FALSE, FALSE);
12590 if (stub_entry != NULL)
12592 /* The proper stub has already been created. */
12594 if (stub_type == ppc_stub_plt_call_r2save)
12595 stub_entry->stub_type = stub_type;
12599 stub_entry = ppc_add_stub (stub_name, section, info);
12600 if (stub_entry == NULL)
12603 error_ret_free_internal:
12604 if (elf_section_data (section)->relocs == NULL)
12605 free (internal_relocs);
12606 error_ret_free_local:
12607 if (local_syms != NULL
12608 && (symtab_hdr->contents
12609 != (unsigned char *) local_syms))
12614 stub_entry->stub_type = stub_type;
12615 if (stub_type != ppc_stub_plt_call
12616 && stub_type != ppc_stub_plt_call_r2save)
12618 stub_entry->target_value = code_value;
12619 stub_entry->target_section = code_sec;
12623 stub_entry->target_value = sym_value;
12624 stub_entry->target_section = sym_sec;
12626 stub_entry->h = hash;
12627 stub_entry->plt_ent = plt_ent;
12628 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12630 if (stub_entry->h != NULL)
12631 htab->stub_globals += 1;
12634 /* We're done with the internal relocs, free them. */
12635 if (elf_section_data (section)->relocs != internal_relocs)
12636 free (internal_relocs);
12639 if (local_syms != NULL
12640 && symtab_hdr->contents != (unsigned char *) local_syms)
12642 if (!info->keep_memory)
12645 symtab_hdr->contents = (unsigned char *) local_syms;
12649 /* We may have added some stubs. Find out the new size of the
12651 for (stub_sec = htab->params->stub_bfd->sections;
12653 stub_sec = stub_sec->next)
12654 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12656 if (htab->stub_iteration <= STUB_SHRINK_ITER
12657 || stub_sec->rawsize < stub_sec->size)
12658 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12659 stub_sec->rawsize = stub_sec->size;
12660 stub_sec->size = 0;
12661 stub_sec->reloc_count = 0;
12662 stub_sec->flags &= ~SEC_RELOC;
12665 htab->brlt->size = 0;
12666 htab->brlt->reloc_count = 0;
12667 htab->brlt->flags &= ~SEC_RELOC;
12668 if (htab->relbrlt != NULL)
12669 htab->relbrlt->size = 0;
12671 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12673 for (group = htab->group; group != NULL; group = group->next)
12674 if (group->needs_save_res)
12675 group->stub_sec->size += htab->sfpr->size;
12677 if (info->emitrelocations
12678 && htab->glink != NULL && htab->glink->size != 0)
12680 htab->glink->reloc_count = 1;
12681 htab->glink->flags |= SEC_RELOC;
12684 if (htab->glink_eh_frame != NULL
12685 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12686 && htab->glink_eh_frame->output_section->size != 0)
12688 size_t size = 0, align = 4;
12690 for (stub_sec = htab->params->stub_bfd->sections;
12692 stub_sec = stub_sec->next)
12693 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12694 size += (17 + align - 1) & -align;
12695 if (htab->glink != NULL && htab->glink->size != 0)
12696 size += (24 + align - 1) & -align;
12698 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12699 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12700 size = (size + align - 1) & -align;
12701 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12702 htab->glink_eh_frame->size = size;
12705 if (htab->params->plt_stub_align != 0)
12706 for (stub_sec = htab->params->stub_bfd->sections;
12708 stub_sec = stub_sec->next)
12709 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12710 stub_sec->size = ((stub_sec->size
12711 + (1 << htab->params->plt_stub_align) - 1)
12712 & -(1 << htab->params->plt_stub_align));
12714 for (stub_sec = htab->params->stub_bfd->sections;
12716 stub_sec = stub_sec->next)
12717 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12718 && stub_sec->rawsize != stub_sec->size
12719 && (htab->stub_iteration <= STUB_SHRINK_ITER
12720 || stub_sec->rawsize < stub_sec->size))
12723 if (stub_sec == NULL
12724 && (htab->glink_eh_frame == NULL
12725 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12728 /* Ask the linker to do its stuff. */
12729 (*htab->params->layout_sections_again) ();
12732 if (htab->glink_eh_frame != NULL
12733 && htab->glink_eh_frame->size != 0)
12736 bfd_byte *p, *last_fde;
12737 size_t last_fde_len, size, align, pad;
12738 asection *stub_sec;
12740 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12743 htab->glink_eh_frame->contents = p;
12747 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12748 /* CIE length (rewrite in case little-endian). */
12749 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12750 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12751 p += last_fde_len + 4;
12753 for (stub_sec = htab->params->stub_bfd->sections;
12755 stub_sec = stub_sec->next)
12756 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12759 last_fde_len = ((17 + align - 1) & -align) - 4;
12761 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12764 val = p - htab->glink_eh_frame->contents;
12765 bfd_put_32 (htab->elf.dynobj, val, p);
12767 /* Offset to stub section, written later. */
12769 /* stub section size. */
12770 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12772 /* Augmentation. */
12775 p += ((17 + align - 1) & -align) - 17;
12777 if (htab->glink != NULL && htab->glink->size != 0)
12780 last_fde_len = ((24 + align - 1) & -align) - 4;
12782 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12785 val = p - htab->glink_eh_frame->contents;
12786 bfd_put_32 (htab->elf.dynobj, val, p);
12788 /* Offset to .glink, written later. */
12791 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12793 /* Augmentation. */
12796 *p++ = DW_CFA_advance_loc + 1;
12797 *p++ = DW_CFA_register;
12799 *p++ = htab->opd_abi ? 12 : 0;
12800 *p++ = DW_CFA_advance_loc + 4;
12801 *p++ = DW_CFA_restore_extended;
12803 p += ((24 + align - 1) & -align) - 24;
12805 /* Subsume any padding into the last FDE if user .eh_frame
12806 sections are aligned more than glink_eh_frame. Otherwise any
12807 zero padding will be seen as a terminator. */
12808 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12809 size = p - htab->glink_eh_frame->contents;
12810 pad = ((size + align - 1) & -align) - size;
12811 htab->glink_eh_frame->size = size + pad;
12812 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12815 maybe_strip_output (info, htab->brlt);
12816 if (htab->glink_eh_frame != NULL)
12817 maybe_strip_output (info, htab->glink_eh_frame);
12822 /* Called after we have determined section placement. If sections
12823 move, we'll be called again. Provide a value for TOCstart. */
12826 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12829 bfd_vma TOCstart, adjust;
12833 struct elf_link_hash_entry *h;
12834 struct elf_link_hash_table *htab = elf_hash_table (info);
12836 if (is_elf_hash_table (htab)
12837 && htab->hgot != NULL)
12841 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12842 if (is_elf_hash_table (htab))
12846 && h->root.type == bfd_link_hash_defined
12847 && !h->root.linker_def
12848 && (!is_elf_hash_table (htab)
12849 || h->def_regular))
12851 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12852 + h->root.u.def.section->output_offset
12853 + h->root.u.def.section->output_section->vma);
12854 _bfd_set_gp_value (obfd, TOCstart);
12859 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12860 order. The TOC starts where the first of these sections starts. */
12861 s = bfd_get_section_by_name (obfd, ".got");
12862 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12863 s = bfd_get_section_by_name (obfd, ".toc");
12864 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12865 s = bfd_get_section_by_name (obfd, ".tocbss");
12866 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12867 s = bfd_get_section_by_name (obfd, ".plt");
12868 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12870 /* This may happen for
12871 o references to TOC base (SYM@toc / TOC[tc0]) without a
12873 o bad linker script
12874 o --gc-sections and empty TOC sections
12876 FIXME: Warn user? */
12878 /* Look for a likely section. We probably won't even be
12880 for (s = obfd->sections; s != NULL; s = s->next)
12881 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12883 == (SEC_ALLOC | SEC_SMALL_DATA))
12886 for (s = obfd->sections; s != NULL; s = s->next)
12887 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12888 == (SEC_ALLOC | SEC_SMALL_DATA))
12891 for (s = obfd->sections; s != NULL; s = s->next)
12892 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12896 for (s = obfd->sections; s != NULL; s = s->next)
12897 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12903 TOCstart = s->output_section->vma + s->output_offset;
12905 /* Force alignment. */
12906 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12907 TOCstart -= adjust;
12908 _bfd_set_gp_value (obfd, TOCstart);
12910 if (info != NULL && s != NULL)
12912 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12916 if (htab->elf.hgot != NULL)
12918 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12919 htab->elf.hgot->root.u.def.section = s;
12924 struct bfd_link_hash_entry *bh = NULL;
12925 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12926 s, TOC_BASE_OFF - adjust,
12927 NULL, FALSE, FALSE, &bh);
12933 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12934 write out any global entry stubs. */
12937 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12939 struct bfd_link_info *info;
12940 struct ppc_link_hash_table *htab;
12941 struct plt_entry *pent;
12944 if (h->root.type == bfd_link_hash_indirect)
12947 if (!h->pointer_equality_needed)
12950 if (h->def_regular)
12954 htab = ppc_hash_table (info);
12959 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12960 if (pent->plt.offset != (bfd_vma) -1
12961 && pent->addend == 0)
12967 p = s->contents + h->root.u.def.value;
12968 plt = htab->elf.splt;
12969 if (!htab->elf.dynamic_sections_created
12970 || h->dynindx == -1)
12971 plt = htab->elf.iplt;
12972 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12973 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12975 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12977 info->callbacks->einfo
12978 (_("%P: linkage table error against `%T'\n"),
12979 h->root.root.string);
12980 bfd_set_error (bfd_error_bad_value);
12981 htab->stub_error = TRUE;
12984 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12985 if (htab->params->emit_stub_syms)
12987 size_t len = strlen (h->root.root.string);
12988 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12993 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12994 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12997 if (h->root.type == bfd_link_hash_new)
12999 h->root.type = bfd_link_hash_defined;
13000 h->root.u.def.section = s;
13001 h->root.u.def.value = p - s->contents;
13002 h->ref_regular = 1;
13003 h->def_regular = 1;
13004 h->ref_regular_nonweak = 1;
13005 h->forced_local = 1;
13007 h->root.linker_def = 1;
13011 if (PPC_HA (off) != 0)
13013 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13016 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13018 bfd_put_32 (s->owner, MTCTR_R12, p);
13020 bfd_put_32 (s->owner, BCTR, p);
13026 /* Build all the stubs associated with the current output file.
13027 The stubs are kept in a hash table attached to the main linker
13028 hash table. This function is called via gldelf64ppc_finish. */
13031 ppc64_elf_build_stubs (struct bfd_link_info *info,
13034 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13035 struct map_stub *group;
13036 asection *stub_sec;
13038 int stub_sec_count = 0;
13043 /* Allocate memory to hold the linker stubs. */
13044 for (stub_sec = htab->params->stub_bfd->sections;
13046 stub_sec = stub_sec->next)
13047 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13048 && stub_sec->size != 0)
13050 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13051 if (stub_sec->contents == NULL)
13053 stub_sec->size = 0;
13056 if (htab->glink != NULL && htab->glink->size != 0)
13061 /* Build the .glink plt call stub. */
13062 if (htab->params->emit_stub_syms)
13064 struct elf_link_hash_entry *h;
13065 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13066 TRUE, FALSE, FALSE);
13069 if (h->root.type == bfd_link_hash_new)
13071 h->root.type = bfd_link_hash_defined;
13072 h->root.u.def.section = htab->glink;
13073 h->root.u.def.value = 8;
13074 h->ref_regular = 1;
13075 h->def_regular = 1;
13076 h->ref_regular_nonweak = 1;
13077 h->forced_local = 1;
13079 h->root.linker_def = 1;
13082 plt0 = (htab->elf.splt->output_section->vma
13083 + htab->elf.splt->output_offset
13085 if (info->emitrelocations)
13087 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13090 r->r_offset = (htab->glink->output_offset
13091 + htab->glink->output_section->vma);
13092 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13093 r->r_addend = plt0;
13095 p = htab->glink->contents;
13096 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13097 bfd_put_64 (htab->glink->owner, plt0, p);
13101 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13103 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13105 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13107 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13109 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13111 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13113 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13115 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13117 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13119 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13124 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13126 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13128 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13130 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13132 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13134 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13136 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13138 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13140 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13142 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13144 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13146 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13149 bfd_put_32 (htab->glink->owner, BCTR, p);
13151 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13153 bfd_put_32 (htab->glink->owner, NOP, p);
13157 /* Build the .glink lazy link call stubs. */
13159 while (p < htab->glink->contents + htab->glink->rawsize)
13165 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13170 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13172 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13177 bfd_put_32 (htab->glink->owner,
13178 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13183 /* Build .glink global entry stubs. */
13184 if (htab->glink->size > htab->glink->rawsize)
13185 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13188 if (htab->brlt != NULL && htab->brlt->size != 0)
13190 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13192 if (htab->brlt->contents == NULL)
13195 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13197 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13198 htab->relbrlt->size);
13199 if (htab->relbrlt->contents == NULL)
13203 /* Build the stubs as directed by the stub hash table. */
13204 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13206 for (group = htab->group; group != NULL; group = group->next)
13207 if (group->needs_save_res)
13209 stub_sec = group->stub_sec;
13210 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13212 if (htab->params->emit_stub_syms)
13216 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13217 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13220 stub_sec->size += htab->sfpr->size;
13223 if (htab->relbrlt != NULL)
13224 htab->relbrlt->reloc_count = 0;
13226 if (htab->params->plt_stub_align != 0)
13227 for (stub_sec = htab->params->stub_bfd->sections;
13229 stub_sec = stub_sec->next)
13230 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13231 stub_sec->size = ((stub_sec->size
13232 + (1 << htab->params->plt_stub_align) - 1)
13233 & -(1 << htab->params->plt_stub_align));
13235 for (stub_sec = htab->params->stub_bfd->sections;
13237 stub_sec = stub_sec->next)
13238 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13240 stub_sec_count += 1;
13241 if (stub_sec->rawsize != stub_sec->size
13242 && (htab->stub_iteration <= STUB_SHRINK_ITER
13243 || stub_sec->rawsize < stub_sec->size))
13247 /* Note that the glink_eh_frame check here is not only testing that
13248 the generated size matched the calculated size but also that
13249 bfd_elf_discard_info didn't make any changes to the section. */
13250 if (stub_sec != NULL
13251 || (htab->glink_eh_frame != NULL
13252 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13254 htab->stub_error = TRUE;
13255 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13258 if (htab->stub_error)
13263 *stats = bfd_malloc (500);
13264 if (*stats == NULL)
13267 sprintf (*stats, _("linker stubs in %u group%s\n"
13269 " toc adjust %lu\n"
13270 " long branch %lu\n"
13271 " long toc adj %lu\n"
13273 " plt call toc %lu\n"
13274 " global entry %lu"),
13276 stub_sec_count == 1 ? "" : "s",
13277 htab->stub_count[ppc_stub_long_branch - 1],
13278 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13279 htab->stub_count[ppc_stub_plt_branch - 1],
13280 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13281 htab->stub_count[ppc_stub_plt_call - 1],
13282 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13283 htab->stub_count[ppc_stub_global_entry - 1]);
13288 /* What to do when ld finds relocations against symbols defined in
13289 discarded sections. */
13291 static unsigned int
13292 ppc64_elf_action_discarded (asection *sec)
13294 if (strcmp (".opd", sec->name) == 0)
13297 if (strcmp (".toc", sec->name) == 0)
13300 if (strcmp (".toc1", sec->name) == 0)
13303 return _bfd_elf_default_action_discarded (sec);
13306 /* The RELOCATE_SECTION function is called by the ELF backend linker
13307 to handle the relocations for a section.
13309 The relocs are always passed as Rela structures; if the section
13310 actually uses Rel structures, the r_addend field will always be
13313 This function is responsible for adjust the section contents as
13314 necessary, and (if using Rela relocs and generating a
13315 relocatable output file) adjusting the reloc addend as
13318 This function does not have to worry about setting the reloc
13319 address or the reloc symbol index.
13321 LOCAL_SYMS is a pointer to the swapped in local symbols.
13323 LOCAL_SECTIONS is an array giving the section in the input file
13324 corresponding to the st_shndx field of each local symbol.
13326 The global hash table entry for the global symbols can be found
13327 via elf_sym_hashes (input_bfd).
13329 When generating relocatable output, this function must handle
13330 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13331 going to be the section symbol corresponding to the output
13332 section, which means that the addend must be adjusted
13336 ppc64_elf_relocate_section (bfd *output_bfd,
13337 struct bfd_link_info *info,
13339 asection *input_section,
13340 bfd_byte *contents,
13341 Elf_Internal_Rela *relocs,
13342 Elf_Internal_Sym *local_syms,
13343 asection **local_sections)
13345 struct ppc_link_hash_table *htab;
13346 Elf_Internal_Shdr *symtab_hdr;
13347 struct elf_link_hash_entry **sym_hashes;
13348 Elf_Internal_Rela *rel;
13349 Elf_Internal_Rela *wrel;
13350 Elf_Internal_Rela *relend;
13351 Elf_Internal_Rela outrel;
13353 struct got_entry **local_got_ents;
13355 bfd_boolean ret = TRUE;
13356 bfd_boolean is_opd;
13357 /* Assume 'at' branch hints. */
13358 bfd_boolean is_isa_v2 = TRUE;
13359 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13361 /* Initialize howto table if needed. */
13362 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13365 htab = ppc_hash_table (info);
13369 /* Don't relocate stub sections. */
13370 if (input_section->owner == htab->params->stub_bfd)
13373 BFD_ASSERT (is_ppc64_elf (input_bfd));
13375 local_got_ents = elf_local_got_ents (input_bfd);
13376 TOCstart = elf_gp (output_bfd);
13377 symtab_hdr = &elf_symtab_hdr (input_bfd);
13378 sym_hashes = elf_sym_hashes (input_bfd);
13379 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13381 rel = wrel = relocs;
13382 relend = relocs + input_section->reloc_count;
13383 for (; rel < relend; wrel++, rel++)
13385 enum elf_ppc64_reloc_type r_type;
13387 bfd_reloc_status_type r;
13388 Elf_Internal_Sym *sym;
13390 struct elf_link_hash_entry *h_elf;
13391 struct ppc_link_hash_entry *h;
13392 struct ppc_link_hash_entry *fdh;
13393 const char *sym_name;
13394 unsigned long r_symndx, toc_symndx;
13395 bfd_vma toc_addend;
13396 unsigned char tls_mask, tls_gd, tls_type;
13397 unsigned char sym_type;
13398 bfd_vma relocation;
13399 bfd_boolean unresolved_reloc;
13400 bfd_boolean warned;
13401 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13404 struct ppc_stub_hash_entry *stub_entry;
13405 bfd_vma max_br_offset;
13407 Elf_Internal_Rela orig_rel;
13408 reloc_howto_type *howto;
13409 struct reloc_howto_struct alt_howto;
13414 r_type = ELF64_R_TYPE (rel->r_info);
13415 r_symndx = ELF64_R_SYM (rel->r_info);
13417 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13418 symbol of the previous ADDR64 reloc. The symbol gives us the
13419 proper TOC base to use. */
13420 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13422 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13424 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13430 unresolved_reloc = FALSE;
13433 if (r_symndx < symtab_hdr->sh_info)
13435 /* It's a local symbol. */
13436 struct _opd_sec_data *opd;
13438 sym = local_syms + r_symndx;
13439 sec = local_sections[r_symndx];
13440 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13441 sym_type = ELF64_ST_TYPE (sym->st_info);
13442 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13443 opd = get_opd_info (sec);
13444 if (opd != NULL && opd->adjust != NULL)
13446 long adjust = opd->adjust[OPD_NDX (sym->st_value
13452 /* If this is a relocation against the opd section sym
13453 and we have edited .opd, adjust the reloc addend so
13454 that ld -r and ld --emit-relocs output is correct.
13455 If it is a reloc against some other .opd symbol,
13456 then the symbol value will be adjusted later. */
13457 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13458 rel->r_addend += adjust;
13460 relocation += adjust;
13466 bfd_boolean ignored;
13468 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13469 r_symndx, symtab_hdr, sym_hashes,
13470 h_elf, sec, relocation,
13471 unresolved_reloc, warned, ignored);
13472 sym_name = h_elf->root.root.string;
13473 sym_type = h_elf->type;
13475 && sec->owner == output_bfd
13476 && strcmp (sec->name, ".opd") == 0)
13478 /* This is a symbol defined in a linker script. All
13479 such are defined in output sections, even those
13480 defined by simple assignment from a symbol defined in
13481 an input section. Transfer the symbol to an
13482 appropriate input .opd section, so that a branch to
13483 this symbol will be mapped to the location specified
13484 by the opd entry. */
13485 struct bfd_link_order *lo;
13486 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13487 if (lo->type == bfd_indirect_link_order)
13489 asection *isec = lo->u.indirect.section;
13490 if (h_elf->root.u.def.value >= isec->output_offset
13491 && h_elf->root.u.def.value < (isec->output_offset
13494 h_elf->root.u.def.value -= isec->output_offset;
13495 h_elf->root.u.def.section = isec;
13502 h = (struct ppc_link_hash_entry *) h_elf;
13504 if (sec != NULL && discarded_section (sec))
13506 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13507 input_bfd, input_section,
13508 contents + rel->r_offset);
13509 wrel->r_offset = rel->r_offset;
13511 wrel->r_addend = 0;
13513 /* For ld -r, remove relocations in debug sections against
13514 sections defined in discarded sections. Not done for
13515 non-debug to preserve relocs in .eh_frame which the
13516 eh_frame editing code expects to be present. */
13517 if (bfd_link_relocatable (info)
13518 && (input_section->flags & SEC_DEBUGGING))
13524 if (bfd_link_relocatable (info))
13527 if (h != NULL && &h->elf == htab->elf.hgot)
13529 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13530 sec = bfd_abs_section_ptr;
13531 unresolved_reloc = FALSE;
13534 /* TLS optimizations. Replace instruction sequences and relocs
13535 based on information we collected in tls_optimize. We edit
13536 RELOCS so that --emit-relocs will output something sensible
13537 for the final instruction stream. */
13542 tls_mask = h->tls_mask;
13543 else if (local_got_ents != NULL)
13545 struct plt_entry **local_plt = (struct plt_entry **)
13546 (local_got_ents + symtab_hdr->sh_info);
13547 unsigned char *lgot_masks = (unsigned char *)
13548 (local_plt + symtab_hdr->sh_info);
13549 tls_mask = lgot_masks[r_symndx];
13552 && (r_type == R_PPC64_TLS
13553 || r_type == R_PPC64_TLSGD
13554 || r_type == R_PPC64_TLSLD))
13556 /* Check for toc tls entries. */
13557 unsigned char *toc_tls;
13559 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13560 &local_syms, rel, input_bfd))
13564 tls_mask = *toc_tls;
13567 /* Check that tls relocs are used with tls syms, and non-tls
13568 relocs are used with non-tls syms. */
13569 if (r_symndx != STN_UNDEF
13570 && r_type != R_PPC64_NONE
13572 || h->elf.root.type == bfd_link_hash_defined
13573 || h->elf.root.type == bfd_link_hash_defweak)
13574 && (IS_PPC64_TLS_RELOC (r_type)
13575 != (sym_type == STT_TLS
13576 || (sym_type == STT_SECTION
13577 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13580 && (r_type == R_PPC64_TLS
13581 || r_type == R_PPC64_TLSGD
13582 || r_type == R_PPC64_TLSLD))
13583 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13586 info->callbacks->einfo
13587 (!IS_PPC64_TLS_RELOC (r_type)
13588 /* xgettext:c-format */
13589 ? _("%H: %s used with TLS symbol `%T'\n")
13590 /* xgettext:c-format */
13591 : _("%H: %s used with non-TLS symbol `%T'\n"),
13592 input_bfd, input_section, rel->r_offset,
13593 ppc64_elf_howto_table[r_type]->name,
13597 /* Ensure reloc mapping code below stays sane. */
13598 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13599 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13600 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13601 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13602 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13603 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13604 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13605 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13606 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13607 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13615 case R_PPC64_LO_DS_OPT:
13616 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13617 if ((insn & (0x3f << 26)) != 58u << 26)
13619 insn += (14u << 26) - (58u << 26);
13620 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13621 r_type = R_PPC64_TOC16_LO;
13622 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13625 case R_PPC64_TOC16:
13626 case R_PPC64_TOC16_LO:
13627 case R_PPC64_TOC16_DS:
13628 case R_PPC64_TOC16_LO_DS:
13630 /* Check for toc tls entries. */
13631 unsigned char *toc_tls;
13634 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13635 &local_syms, rel, input_bfd);
13641 tls_mask = *toc_tls;
13642 if (r_type == R_PPC64_TOC16_DS
13643 || r_type == R_PPC64_TOC16_LO_DS)
13646 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13651 /* If we found a GD reloc pair, then we might be
13652 doing a GD->IE transition. */
13655 tls_gd = TLS_TPRELGD;
13656 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13659 else if (retval == 3)
13661 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13669 case R_PPC64_GOT_TPREL16_HI:
13670 case R_PPC64_GOT_TPREL16_HA:
13672 && (tls_mask & TLS_TPREL) == 0)
13674 rel->r_offset -= d_offset;
13675 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13676 r_type = R_PPC64_NONE;
13677 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13681 case R_PPC64_GOT_TPREL16_DS:
13682 case R_PPC64_GOT_TPREL16_LO_DS:
13684 && (tls_mask & TLS_TPREL) == 0)
13687 insn = bfd_get_32 (input_bfd,
13688 contents + rel->r_offset - d_offset);
13690 insn |= 0x3c0d0000; /* addis 0,13,0 */
13691 bfd_put_32 (input_bfd, insn,
13692 contents + rel->r_offset - d_offset);
13693 r_type = R_PPC64_TPREL16_HA;
13694 if (toc_symndx != 0)
13696 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13697 rel->r_addend = toc_addend;
13698 /* We changed the symbol. Start over in order to
13699 get h, sym, sec etc. right. */
13703 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13709 && (tls_mask & TLS_TPREL) == 0)
13711 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13712 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13715 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13716 /* Was PPC64_TLS which sits on insn boundary, now
13717 PPC64_TPREL16_LO which is at low-order half-word. */
13718 rel->r_offset += d_offset;
13719 r_type = R_PPC64_TPREL16_LO;
13720 if (toc_symndx != 0)
13722 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13723 rel->r_addend = toc_addend;
13724 /* We changed the symbol. Start over in order to
13725 get h, sym, sec etc. right. */
13729 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13733 case R_PPC64_GOT_TLSGD16_HI:
13734 case R_PPC64_GOT_TLSGD16_HA:
13735 tls_gd = TLS_TPRELGD;
13736 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13740 case R_PPC64_GOT_TLSLD16_HI:
13741 case R_PPC64_GOT_TLSLD16_HA:
13742 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13745 if ((tls_mask & tls_gd) != 0)
13746 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13747 + R_PPC64_GOT_TPREL16_DS);
13750 rel->r_offset -= d_offset;
13751 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13752 r_type = R_PPC64_NONE;
13754 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13758 case R_PPC64_GOT_TLSGD16:
13759 case R_PPC64_GOT_TLSGD16_LO:
13760 tls_gd = TLS_TPRELGD;
13761 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13765 case R_PPC64_GOT_TLSLD16:
13766 case R_PPC64_GOT_TLSLD16_LO:
13767 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13769 unsigned int insn1, insn2, insn3;
13773 offset = (bfd_vma) -1;
13774 /* If not using the newer R_PPC64_TLSGD/LD to mark
13775 __tls_get_addr calls, we must trust that the call
13776 stays with its arg setup insns, ie. that the next
13777 reloc is the __tls_get_addr call associated with
13778 the current reloc. Edit both insns. */
13779 if (input_section->has_tls_get_addr_call
13780 && rel + 1 < relend
13781 && branch_reloc_hash_match (input_bfd, rel + 1,
13782 htab->tls_get_addr,
13783 htab->tls_get_addr_fd))
13784 offset = rel[1].r_offset;
13785 /* We read the low GOT_TLS (or TOC16) insn because we
13786 need to keep the destination reg. It may be
13787 something other than the usual r3, and moved to r3
13788 before the call by intervening code. */
13789 insn1 = bfd_get_32 (input_bfd,
13790 contents + rel->r_offset - d_offset);
13791 if ((tls_mask & tls_gd) != 0)
13794 insn1 &= (0x1f << 21) | (0x1f << 16);
13795 insn1 |= 58 << 26; /* ld */
13796 insn2 = 0x7c636a14; /* add 3,3,13 */
13797 if (offset != (bfd_vma) -1)
13798 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13799 if ((tls_mask & TLS_EXPLICIT) == 0)
13800 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13801 + R_PPC64_GOT_TPREL16_DS);
13803 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13804 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13809 insn1 &= 0x1f << 21;
13810 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13811 insn2 = 0x38630000; /* addi 3,3,0 */
13814 /* Was an LD reloc. */
13816 sec = local_sections[toc_symndx];
13818 r_symndx < symtab_hdr->sh_info;
13820 if (local_sections[r_symndx] == sec)
13822 if (r_symndx >= symtab_hdr->sh_info)
13823 r_symndx = STN_UNDEF;
13824 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13825 if (r_symndx != STN_UNDEF)
13826 rel->r_addend -= (local_syms[r_symndx].st_value
13827 + sec->output_offset
13828 + sec->output_section->vma);
13830 else if (toc_symndx != 0)
13832 r_symndx = toc_symndx;
13833 rel->r_addend = toc_addend;
13835 r_type = R_PPC64_TPREL16_HA;
13836 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13837 if (offset != (bfd_vma) -1)
13839 rel[1].r_info = ELF64_R_INFO (r_symndx,
13840 R_PPC64_TPREL16_LO);
13841 rel[1].r_offset = offset + d_offset;
13842 rel[1].r_addend = rel->r_addend;
13845 bfd_put_32 (input_bfd, insn1,
13846 contents + rel->r_offset - d_offset);
13847 if (offset != (bfd_vma) -1)
13849 insn3 = bfd_get_32 (input_bfd,
13850 contents + offset + 4);
13852 || insn3 == CROR_151515 || insn3 == CROR_313131)
13854 rel[1].r_offset += 4;
13855 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13858 bfd_put_32 (input_bfd, insn2, contents + offset);
13860 if ((tls_mask & tls_gd) == 0
13861 && (tls_gd == 0 || toc_symndx != 0))
13863 /* We changed the symbol. Start over in order
13864 to get h, sym, sec etc. right. */
13870 case R_PPC64_TLSGD:
13871 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13873 unsigned int insn2, insn3;
13874 bfd_vma offset = rel->r_offset;
13876 if ((tls_mask & TLS_TPRELGD) != 0)
13879 r_type = R_PPC64_NONE;
13880 insn2 = 0x7c636a14; /* add 3,3,13 */
13885 if (toc_symndx != 0)
13887 r_symndx = toc_symndx;
13888 rel->r_addend = toc_addend;
13890 r_type = R_PPC64_TPREL16_LO;
13891 rel->r_offset = offset + d_offset;
13892 insn2 = 0x38630000; /* addi 3,3,0 */
13894 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13895 /* Zap the reloc on the _tls_get_addr call too. */
13896 BFD_ASSERT (offset == rel[1].r_offset);
13897 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13898 insn3 = bfd_get_32 (input_bfd,
13899 contents + offset + 4);
13901 || insn3 == CROR_151515 || insn3 == CROR_313131)
13903 rel->r_offset += 4;
13904 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13907 bfd_put_32 (input_bfd, insn2, contents + offset);
13908 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13913 case R_PPC64_TLSLD:
13914 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13916 unsigned int insn2, insn3;
13917 bfd_vma offset = rel->r_offset;
13920 sec = local_sections[toc_symndx];
13922 r_symndx < symtab_hdr->sh_info;
13924 if (local_sections[r_symndx] == sec)
13926 if (r_symndx >= symtab_hdr->sh_info)
13927 r_symndx = STN_UNDEF;
13928 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13929 if (r_symndx != STN_UNDEF)
13930 rel->r_addend -= (local_syms[r_symndx].st_value
13931 + sec->output_offset
13932 + sec->output_section->vma);
13934 r_type = R_PPC64_TPREL16_LO;
13935 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13936 rel->r_offset = offset + d_offset;
13937 /* Zap the reloc on the _tls_get_addr call too. */
13938 BFD_ASSERT (offset == rel[1].r_offset);
13939 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13940 insn2 = 0x38630000; /* addi 3,3,0 */
13941 insn3 = bfd_get_32 (input_bfd,
13942 contents + offset + 4);
13944 || insn3 == CROR_151515 || insn3 == CROR_313131)
13946 rel->r_offset += 4;
13947 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13950 bfd_put_32 (input_bfd, insn2, contents + offset);
13955 case R_PPC64_DTPMOD64:
13956 if (rel + 1 < relend
13957 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13958 && rel[1].r_offset == rel->r_offset + 8)
13960 if ((tls_mask & TLS_GD) == 0)
13962 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13963 if ((tls_mask & TLS_TPRELGD) != 0)
13964 r_type = R_PPC64_TPREL64;
13967 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13968 r_type = R_PPC64_NONE;
13970 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13975 if ((tls_mask & TLS_LD) == 0)
13977 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13978 r_type = R_PPC64_NONE;
13979 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13984 case R_PPC64_TPREL64:
13985 if ((tls_mask & TLS_TPREL) == 0)
13987 r_type = R_PPC64_NONE;
13988 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13992 case R_PPC64_ENTRY:
13993 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13994 if (!bfd_link_pic (info)
13995 && !info->traditional_format
13996 && relocation + 0x80008000 <= 0xffffffff)
13998 unsigned int insn1, insn2;
14000 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14001 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14002 if ((insn1 & ~0xfffc) == LD_R2_0R12
14003 && insn2 == ADD_R2_R2_R12)
14005 bfd_put_32 (input_bfd,
14006 LIS_R2 + PPC_HA (relocation),
14007 contents + rel->r_offset);
14008 bfd_put_32 (input_bfd,
14009 ADDI_R2_R2 + PPC_LO (relocation),
14010 contents + rel->r_offset + 4);
14015 relocation -= (rel->r_offset
14016 + input_section->output_offset
14017 + input_section->output_section->vma);
14018 if (relocation + 0x80008000 <= 0xffffffff)
14020 unsigned int insn1, insn2;
14022 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14023 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14024 if ((insn1 & ~0xfffc) == LD_R2_0R12
14025 && insn2 == ADD_R2_R2_R12)
14027 bfd_put_32 (input_bfd,
14028 ADDIS_R2_R12 + PPC_HA (relocation),
14029 contents + rel->r_offset);
14030 bfd_put_32 (input_bfd,
14031 ADDI_R2_R2 + PPC_LO (relocation),
14032 contents + rel->r_offset + 4);
14038 case R_PPC64_REL16_HA:
14039 /* If we are generating a non-PIC executable, edit
14040 . 0: addis 2,12,.TOC.-0b@ha
14041 . addi 2,2,.TOC.-0b@l
14042 used by ELFv2 global entry points to set up r2, to
14045 if .TOC. is in range. */
14046 if (!bfd_link_pic (info)
14047 && !info->traditional_format
14049 && rel->r_addend == d_offset
14050 && h != NULL && &h->elf == htab->elf.hgot
14051 && rel + 1 < relend
14052 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14053 && rel[1].r_offset == rel->r_offset + 4
14054 && rel[1].r_addend == rel->r_addend + 4
14055 && relocation + 0x80008000 <= 0xffffffff)
14057 unsigned int insn1, insn2;
14058 bfd_vma offset = rel->r_offset - d_offset;
14059 insn1 = bfd_get_32 (input_bfd, contents + offset);
14060 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14061 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14062 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14064 r_type = R_PPC64_ADDR16_HA;
14065 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14066 rel->r_addend -= d_offset;
14067 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14068 rel[1].r_addend -= d_offset + 4;
14069 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14075 /* Handle other relocations that tweak non-addend part of insn. */
14077 max_br_offset = 1 << 25;
14078 addend = rel->r_addend;
14079 reloc_dest = DEST_NORMAL;
14085 case R_PPC64_TOCSAVE:
14086 if (relocation + addend == (rel->r_offset
14087 + input_section->output_offset
14088 + input_section->output_section->vma)
14089 && tocsave_find (htab, NO_INSERT,
14090 &local_syms, rel, input_bfd))
14092 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14094 || insn == CROR_151515 || insn == CROR_313131)
14095 bfd_put_32 (input_bfd,
14096 STD_R2_0R1 + STK_TOC (htab),
14097 contents + rel->r_offset);
14101 /* Branch taken prediction relocations. */
14102 case R_PPC64_ADDR14_BRTAKEN:
14103 case R_PPC64_REL14_BRTAKEN:
14104 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14105 /* Fall through. */
14107 /* Branch not taken prediction relocations. */
14108 case R_PPC64_ADDR14_BRNTAKEN:
14109 case R_PPC64_REL14_BRNTAKEN:
14110 insn |= bfd_get_32 (input_bfd,
14111 contents + rel->r_offset) & ~(0x01 << 21);
14112 /* Fall through. */
14114 case R_PPC64_REL14:
14115 max_br_offset = 1 << 15;
14116 /* Fall through. */
14118 case R_PPC64_REL24:
14119 /* Calls to functions with a different TOC, such as calls to
14120 shared objects, need to alter the TOC pointer. This is
14121 done using a linkage stub. A REL24 branching to these
14122 linkage stubs needs to be followed by a nop, as the nop
14123 will be replaced with an instruction to restore the TOC
14128 && h->oh->is_func_descriptor)
14129 fdh = ppc_follow_link (h->oh);
14130 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14132 if (stub_entry != NULL
14133 && (stub_entry->stub_type == ppc_stub_plt_call
14134 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14135 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14136 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14138 bfd_boolean can_plt_call = FALSE;
14140 /* All of these stubs will modify r2, so there must be a
14141 branch and link followed by a nop. The nop is
14142 replaced by an insn to restore r2. */
14143 if (rel->r_offset + 8 <= input_section->size)
14147 br = bfd_get_32 (input_bfd,
14148 contents + rel->r_offset);
14153 nop = bfd_get_32 (input_bfd,
14154 contents + rel->r_offset + 4);
14156 || nop == CROR_151515 || nop == CROR_313131)
14159 && (h == htab->tls_get_addr_fd
14160 || h == htab->tls_get_addr)
14161 && htab->params->tls_get_addr_opt)
14163 /* Special stub used, leave nop alone. */
14166 bfd_put_32 (input_bfd,
14167 LD_R2_0R1 + STK_TOC (htab),
14168 contents + rel->r_offset + 4);
14169 can_plt_call = TRUE;
14174 if (!can_plt_call && h != NULL)
14176 const char *name = h->elf.root.root.string;
14181 if (strncmp (name, "__libc_start_main", 17) == 0
14182 && (name[17] == 0 || name[17] == '@'))
14184 /* Allow crt1 branch to go via a toc adjusting
14185 stub. Other calls that never return could do
14186 the same, if we could detect such. */
14187 can_plt_call = TRUE;
14193 /* g++ as of 20130507 emits self-calls without a
14194 following nop. This is arguably wrong since we
14195 have conflicting information. On the one hand a
14196 global symbol and on the other a local call
14197 sequence, but don't error for this special case.
14198 It isn't possible to cheaply verify we have
14199 exactly such a call. Allow all calls to the same
14201 asection *code_sec = sec;
14203 if (get_opd_info (sec) != NULL)
14205 bfd_vma off = (relocation + addend
14206 - sec->output_section->vma
14207 - sec->output_offset);
14209 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14211 if (code_sec == input_section)
14212 can_plt_call = TRUE;
14217 if (stub_entry->stub_type == ppc_stub_plt_call
14218 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14219 info->callbacks->einfo
14220 /* xgettext:c-format */
14221 (_("%H: call to `%T' lacks nop, can't restore toc; "
14222 "recompile with -fPIC\n"),
14223 input_bfd, input_section, rel->r_offset, sym_name);
14225 info->callbacks->einfo
14226 /* xgettext:c-format */
14227 (_("%H: call to `%T' lacks nop, can't restore toc; "
14228 "(-mcmodel=small toc adjust stub)\n"),
14229 input_bfd, input_section, rel->r_offset, sym_name);
14231 bfd_set_error (bfd_error_bad_value);
14236 && (stub_entry->stub_type == ppc_stub_plt_call
14237 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14238 unresolved_reloc = FALSE;
14241 if ((stub_entry == NULL
14242 || stub_entry->stub_type == ppc_stub_long_branch
14243 || stub_entry->stub_type == ppc_stub_plt_branch)
14244 && get_opd_info (sec) != NULL)
14246 /* The branch destination is the value of the opd entry. */
14247 bfd_vma off = (relocation + addend
14248 - sec->output_section->vma
14249 - sec->output_offset);
14250 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14251 if (dest != (bfd_vma) -1)
14255 reloc_dest = DEST_OPD;
14259 /* If the branch is out of reach we ought to have a long
14261 from = (rel->r_offset
14262 + input_section->output_offset
14263 + input_section->output_section->vma);
14265 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14269 if (stub_entry != NULL
14270 && (stub_entry->stub_type == ppc_stub_long_branch
14271 || stub_entry->stub_type == ppc_stub_plt_branch)
14272 && (r_type == R_PPC64_ADDR14_BRTAKEN
14273 || r_type == R_PPC64_ADDR14_BRNTAKEN
14274 || (relocation + addend - from + max_br_offset
14275 < 2 * max_br_offset)))
14276 /* Don't use the stub if this branch is in range. */
14279 if (stub_entry != NULL)
14281 /* Munge up the value and addend so that we call the stub
14282 rather than the procedure directly. */
14283 asection *stub_sec = stub_entry->group->stub_sec;
14285 if (stub_entry->stub_type == ppc_stub_save_res)
14286 relocation += (stub_sec->output_offset
14287 + stub_sec->output_section->vma
14288 + stub_sec->size - htab->sfpr->size
14289 - htab->sfpr->output_offset
14290 - htab->sfpr->output_section->vma);
14292 relocation = (stub_entry->stub_offset
14293 + stub_sec->output_offset
14294 + stub_sec->output_section->vma);
14296 reloc_dest = DEST_STUB;
14298 if ((stub_entry->stub_type == ppc_stub_plt_call
14299 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14300 && (ALWAYS_EMIT_R2SAVE
14301 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14302 && rel + 1 < relend
14303 && rel[1].r_offset == rel->r_offset + 4
14304 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14312 /* Set 'a' bit. This is 0b00010 in BO field for branch
14313 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14314 for branch on CTR insns (BO == 1a00t or 1a01t). */
14315 if ((insn & (0x14 << 21)) == (0x04 << 21))
14316 insn |= 0x02 << 21;
14317 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14318 insn |= 0x08 << 21;
14324 /* Invert 'y' bit if not the default. */
14325 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14326 insn ^= 0x01 << 21;
14329 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14332 /* NOP out calls to undefined weak functions.
14333 We can thus call a weak function without first
14334 checking whether the function is defined. */
14336 && h->elf.root.type == bfd_link_hash_undefweak
14337 && h->elf.dynindx == -1
14338 && r_type == R_PPC64_REL24
14342 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14348 /* Set `addend'. */
14353 info->callbacks->einfo
14354 /* xgettext:c-format */
14355 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14356 input_bfd, (int) r_type, sym_name);
14358 bfd_set_error (bfd_error_bad_value);
14364 case R_PPC64_TLSGD:
14365 case R_PPC64_TLSLD:
14366 case R_PPC64_TOCSAVE:
14367 case R_PPC64_GNU_VTINHERIT:
14368 case R_PPC64_GNU_VTENTRY:
14369 case R_PPC64_ENTRY:
14372 /* GOT16 relocations. Like an ADDR16 using the symbol's
14373 address in the GOT as relocation value instead of the
14374 symbol's value itself. Also, create a GOT entry for the
14375 symbol and put the symbol value there. */
14376 case R_PPC64_GOT_TLSGD16:
14377 case R_PPC64_GOT_TLSGD16_LO:
14378 case R_PPC64_GOT_TLSGD16_HI:
14379 case R_PPC64_GOT_TLSGD16_HA:
14380 tls_type = TLS_TLS | TLS_GD;
14383 case R_PPC64_GOT_TLSLD16:
14384 case R_PPC64_GOT_TLSLD16_LO:
14385 case R_PPC64_GOT_TLSLD16_HI:
14386 case R_PPC64_GOT_TLSLD16_HA:
14387 tls_type = TLS_TLS | TLS_LD;
14390 case R_PPC64_GOT_TPREL16_DS:
14391 case R_PPC64_GOT_TPREL16_LO_DS:
14392 case R_PPC64_GOT_TPREL16_HI:
14393 case R_PPC64_GOT_TPREL16_HA:
14394 tls_type = TLS_TLS | TLS_TPREL;
14397 case R_PPC64_GOT_DTPREL16_DS:
14398 case R_PPC64_GOT_DTPREL16_LO_DS:
14399 case R_PPC64_GOT_DTPREL16_HI:
14400 case R_PPC64_GOT_DTPREL16_HA:
14401 tls_type = TLS_TLS | TLS_DTPREL;
14404 case R_PPC64_GOT16:
14405 case R_PPC64_GOT16_LO:
14406 case R_PPC64_GOT16_HI:
14407 case R_PPC64_GOT16_HA:
14408 case R_PPC64_GOT16_DS:
14409 case R_PPC64_GOT16_LO_DS:
14412 /* Relocation is to the entry for this symbol in the global
14417 unsigned long indx = 0;
14418 struct got_entry *ent;
14420 if (tls_type == (TLS_TLS | TLS_LD)
14422 || !h->elf.def_dynamic))
14423 ent = ppc64_tlsld_got (input_bfd);
14428 if (!htab->elf.dynamic_sections_created
14429 || h->elf.dynindx == -1
14430 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14431 || (ELF_ST_VISIBILITY (h->elf.other) != STV_DEFAULT
14432 && h->elf.root.type == bfd_link_hash_undefweak))
14433 /* This is actually a static link, or it is a
14434 -Bsymbolic link and the symbol is defined
14435 locally, or the symbol was forced to be local
14436 because of a version file. */
14440 indx = h->elf.dynindx;
14441 unresolved_reloc = FALSE;
14443 ent = h->elf.got.glist;
14447 if (local_got_ents == NULL)
14449 ent = local_got_ents[r_symndx];
14452 for (; ent != NULL; ent = ent->next)
14453 if (ent->addend == orig_rel.r_addend
14454 && ent->owner == input_bfd
14455 && ent->tls_type == tls_type)
14461 if (ent->is_indirect)
14462 ent = ent->got.ent;
14463 offp = &ent->got.offset;
14464 got = ppc64_elf_tdata (ent->owner)->got;
14468 /* The offset must always be a multiple of 8. We use the
14469 least significant bit to record whether we have already
14470 processed this entry. */
14472 if ((off & 1) != 0)
14476 /* Generate relocs for the dynamic linker, except in
14477 the case of TLSLD where we'll use one entry per
14485 ? h->elf.type == STT_GNU_IFUNC
14486 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14488 relgot = htab->elf.irelplt;
14490 || (bfd_link_pic (info)
14492 || (ELF_ST_VISIBILITY (h->elf.other)
14494 || h->elf.root.type != bfd_link_hash_undefweak
14495 || (tls_type == (TLS_TLS | TLS_LD)
14496 && !h->elf.def_dynamic))))
14497 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14498 if (relgot != NULL)
14500 outrel.r_offset = (got->output_section->vma
14501 + got->output_offset
14503 outrel.r_addend = addend;
14504 if (tls_type & (TLS_LD | TLS_GD))
14506 outrel.r_addend = 0;
14507 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14508 if (tls_type == (TLS_TLS | TLS_GD))
14510 loc = relgot->contents;
14511 loc += (relgot->reloc_count++
14512 * sizeof (Elf64_External_Rela));
14513 bfd_elf64_swap_reloca_out (output_bfd,
14515 outrel.r_offset += 8;
14516 outrel.r_addend = addend;
14518 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14521 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14522 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14523 else if (tls_type == (TLS_TLS | TLS_TPREL))
14524 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14525 else if (indx != 0)
14526 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14530 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14532 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14534 /* Write the .got section contents for the sake
14536 loc = got->contents + off;
14537 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14541 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14543 outrel.r_addend += relocation;
14544 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14546 if (htab->elf.tls_sec == NULL)
14547 outrel.r_addend = 0;
14549 outrel.r_addend -= htab->elf.tls_sec->vma;
14552 loc = relgot->contents;
14553 loc += (relgot->reloc_count++
14554 * sizeof (Elf64_External_Rela));
14555 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14558 /* Init the .got section contents here if we're not
14559 emitting a reloc. */
14563 = (htab->params->tls_get_addr_opt
14564 && htab->tls_get_addr_fd != NULL
14565 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
14567 relocation += addend;
14570 if (htab->elf.tls_sec == NULL)
14574 if (tls_type & TLS_LD)
14577 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14578 if ((tls_type & TLS_TPREL)
14579 || (tlsopt && !(tls_type & TLS_DTPREL)))
14580 relocation += DTP_OFFSET - TP_OFFSET;
14583 if (tls_type & (TLS_GD | TLS_LD))
14585 bfd_put_64 (output_bfd, relocation,
14586 got->contents + off + 8);
14587 relocation = !tlsopt;
14590 bfd_put_64 (output_bfd, relocation,
14591 got->contents + off);
14595 if (off >= (bfd_vma) -2)
14598 relocation = got->output_section->vma + got->output_offset + off;
14599 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14603 case R_PPC64_PLT16_HA:
14604 case R_PPC64_PLT16_HI:
14605 case R_PPC64_PLT16_LO:
14606 case R_PPC64_PLT32:
14607 case R_PPC64_PLT64:
14608 /* Relocation is to the entry for this symbol in the
14609 procedure linkage table. */
14611 struct plt_entry **plt_list = NULL;
14613 plt_list = &h->elf.plt.plist;
14614 else if (local_got_ents != NULL)
14616 struct plt_entry **local_plt = (struct plt_entry **)
14617 (local_got_ents + symtab_hdr->sh_info);
14618 unsigned char *local_got_tls_masks = (unsigned char *)
14619 (local_plt + symtab_hdr->sh_info);
14620 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14621 plt_list = local_plt + r_symndx;
14625 struct plt_entry *ent;
14627 for (ent = *plt_list; ent != NULL; ent = ent->next)
14628 if (ent->plt.offset != (bfd_vma) -1
14629 && ent->addend == orig_rel.r_addend)
14633 plt = htab->elf.splt;
14634 if (!htab->elf.dynamic_sections_created
14636 || h->elf.dynindx == -1)
14637 plt = htab->elf.iplt;
14638 relocation = (plt->output_section->vma
14639 + plt->output_offset
14640 + ent->plt.offset);
14642 unresolved_reloc = FALSE;
14650 /* Relocation value is TOC base. */
14651 relocation = TOCstart;
14652 if (r_symndx == STN_UNDEF)
14653 relocation += htab->sec_info[input_section->id].toc_off;
14654 else if (unresolved_reloc)
14656 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14657 relocation += htab->sec_info[sec->id].toc_off;
14659 unresolved_reloc = TRUE;
14662 /* TOC16 relocs. We want the offset relative to the TOC base,
14663 which is the address of the start of the TOC plus 0x8000.
14664 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14666 case R_PPC64_TOC16:
14667 case R_PPC64_TOC16_LO:
14668 case R_PPC64_TOC16_HI:
14669 case R_PPC64_TOC16_DS:
14670 case R_PPC64_TOC16_LO_DS:
14671 case R_PPC64_TOC16_HA:
14672 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14675 /* Relocate against the beginning of the section. */
14676 case R_PPC64_SECTOFF:
14677 case R_PPC64_SECTOFF_LO:
14678 case R_PPC64_SECTOFF_HI:
14679 case R_PPC64_SECTOFF_DS:
14680 case R_PPC64_SECTOFF_LO_DS:
14681 case R_PPC64_SECTOFF_HA:
14683 addend -= sec->output_section->vma;
14686 case R_PPC64_REL16:
14687 case R_PPC64_REL16_LO:
14688 case R_PPC64_REL16_HI:
14689 case R_PPC64_REL16_HA:
14690 case R_PPC64_REL16DX_HA:
14693 case R_PPC64_REL14:
14694 case R_PPC64_REL14_BRNTAKEN:
14695 case R_PPC64_REL14_BRTAKEN:
14696 case R_PPC64_REL24:
14699 case R_PPC64_TPREL16:
14700 case R_PPC64_TPREL16_LO:
14701 case R_PPC64_TPREL16_HI:
14702 case R_PPC64_TPREL16_HA:
14703 case R_PPC64_TPREL16_DS:
14704 case R_PPC64_TPREL16_LO_DS:
14705 case R_PPC64_TPREL16_HIGH:
14706 case R_PPC64_TPREL16_HIGHA:
14707 case R_PPC64_TPREL16_HIGHER:
14708 case R_PPC64_TPREL16_HIGHERA:
14709 case R_PPC64_TPREL16_HIGHEST:
14710 case R_PPC64_TPREL16_HIGHESTA:
14712 && h->elf.root.type == bfd_link_hash_undefweak
14713 && h->elf.dynindx == -1)
14715 /* Make this relocation against an undefined weak symbol
14716 resolve to zero. This is really just a tweak, since
14717 code using weak externs ought to check that they are
14718 defined before using them. */
14719 bfd_byte *p = contents + rel->r_offset - d_offset;
14721 insn = bfd_get_32 (input_bfd, p);
14722 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14724 bfd_put_32 (input_bfd, insn, p);
14727 if (htab->elf.tls_sec != NULL)
14728 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14729 if (bfd_link_pic (info))
14730 /* The TPREL16 relocs shouldn't really be used in shared
14731 libs as they will result in DT_TEXTREL being set, but
14732 support them anyway. */
14736 case R_PPC64_DTPREL16:
14737 case R_PPC64_DTPREL16_LO:
14738 case R_PPC64_DTPREL16_HI:
14739 case R_PPC64_DTPREL16_HA:
14740 case R_PPC64_DTPREL16_DS:
14741 case R_PPC64_DTPREL16_LO_DS:
14742 case R_PPC64_DTPREL16_HIGH:
14743 case R_PPC64_DTPREL16_HIGHA:
14744 case R_PPC64_DTPREL16_HIGHER:
14745 case R_PPC64_DTPREL16_HIGHERA:
14746 case R_PPC64_DTPREL16_HIGHEST:
14747 case R_PPC64_DTPREL16_HIGHESTA:
14748 if (htab->elf.tls_sec != NULL)
14749 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14752 case R_PPC64_ADDR64_LOCAL:
14753 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14758 case R_PPC64_DTPMOD64:
14763 case R_PPC64_TPREL64:
14764 if (htab->elf.tls_sec != NULL)
14765 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14768 case R_PPC64_DTPREL64:
14769 if (htab->elf.tls_sec != NULL)
14770 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14771 /* Fall through. */
14773 /* Relocations that may need to be propagated if this is a
14775 case R_PPC64_REL30:
14776 case R_PPC64_REL32:
14777 case R_PPC64_REL64:
14778 case R_PPC64_ADDR14:
14779 case R_PPC64_ADDR14_BRNTAKEN:
14780 case R_PPC64_ADDR14_BRTAKEN:
14781 case R_PPC64_ADDR16:
14782 case R_PPC64_ADDR16_DS:
14783 case R_PPC64_ADDR16_HA:
14784 case R_PPC64_ADDR16_HI:
14785 case R_PPC64_ADDR16_HIGH:
14786 case R_PPC64_ADDR16_HIGHA:
14787 case R_PPC64_ADDR16_HIGHER:
14788 case R_PPC64_ADDR16_HIGHERA:
14789 case R_PPC64_ADDR16_HIGHEST:
14790 case R_PPC64_ADDR16_HIGHESTA:
14791 case R_PPC64_ADDR16_LO:
14792 case R_PPC64_ADDR16_LO_DS:
14793 case R_PPC64_ADDR24:
14794 case R_PPC64_ADDR32:
14795 case R_PPC64_ADDR64:
14796 case R_PPC64_UADDR16:
14797 case R_PPC64_UADDR32:
14798 case R_PPC64_UADDR64:
14800 if ((input_section->flags & SEC_ALLOC) == 0)
14803 if (NO_OPD_RELOCS && is_opd)
14806 if (bfd_link_pic (info)
14808 || h->dyn_relocs != NULL)
14809 && ((h != NULL && pc_dynrelocs (h))
14810 || must_be_dyn_reloc (info, r_type)))
14812 ? h->dyn_relocs != NULL
14813 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14815 bfd_boolean skip, relocate;
14819 /* When generating a dynamic object, these relocations
14820 are copied into the output file to be resolved at run
14826 out_off = _bfd_elf_section_offset (output_bfd, info,
14827 input_section, rel->r_offset);
14828 if (out_off == (bfd_vma) -1)
14830 else if (out_off == (bfd_vma) -2)
14831 skip = TRUE, relocate = TRUE;
14832 out_off += (input_section->output_section->vma
14833 + input_section->output_offset);
14834 outrel.r_offset = out_off;
14835 outrel.r_addend = rel->r_addend;
14837 /* Optimize unaligned reloc use. */
14838 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14839 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14840 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14841 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14842 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14843 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14844 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14845 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14846 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14849 memset (&outrel, 0, sizeof outrel);
14850 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14852 && r_type != R_PPC64_TOC)
14854 BFD_ASSERT (h->elf.dynindx != -1);
14855 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14859 /* This symbol is local, or marked to become local,
14860 or this is an opd section reloc which must point
14861 at a local function. */
14862 outrel.r_addend += relocation;
14863 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14865 if (is_opd && h != NULL)
14867 /* Lie about opd entries. This case occurs
14868 when building shared libraries and we
14869 reference a function in another shared
14870 lib. The same thing happens for a weak
14871 definition in an application that's
14872 overridden by a strong definition in a
14873 shared lib. (I believe this is a generic
14874 bug in binutils handling of weak syms.)
14875 In these cases we won't use the opd
14876 entry in this lib. */
14877 unresolved_reloc = FALSE;
14880 && r_type == R_PPC64_ADDR64
14882 ? h->elf.type == STT_GNU_IFUNC
14883 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14884 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14887 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14889 /* We need to relocate .opd contents for ld.so.
14890 Prelink also wants simple and consistent rules
14891 for relocs. This make all RELATIVE relocs have
14892 *r_offset equal to r_addend. */
14901 ? h->elf.type == STT_GNU_IFUNC
14902 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14904 info->callbacks->einfo
14905 /* xgettext:c-format */
14906 (_("%H: %s for indirect "
14907 "function `%T' unsupported\n"),
14908 input_bfd, input_section, rel->r_offset,
14909 ppc64_elf_howto_table[r_type]->name,
14913 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14915 else if (sec == NULL || sec->owner == NULL)
14917 bfd_set_error (bfd_error_bad_value);
14924 osec = sec->output_section;
14925 indx = elf_section_data (osec)->dynindx;
14929 if ((osec->flags & SEC_READONLY) == 0
14930 && htab->elf.data_index_section != NULL)
14931 osec = htab->elf.data_index_section;
14933 osec = htab->elf.text_index_section;
14934 indx = elf_section_data (osec)->dynindx;
14936 BFD_ASSERT (indx != 0);
14938 /* We are turning this relocation into one
14939 against a section symbol, so subtract out
14940 the output section's address but not the
14941 offset of the input section in the output
14943 outrel.r_addend -= osec->vma;
14946 outrel.r_info = ELF64_R_INFO (indx, r_type);
14950 sreloc = elf_section_data (input_section)->sreloc;
14952 ? h->elf.type == STT_GNU_IFUNC
14953 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14954 sreloc = htab->elf.irelplt;
14955 if (sreloc == NULL)
14958 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14961 loc = sreloc->contents;
14962 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14963 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14965 /* If this reloc is against an external symbol, it will
14966 be computed at runtime, so there's no need to do
14967 anything now. However, for the sake of prelink ensure
14968 that the section contents are a known value. */
14971 unresolved_reloc = FALSE;
14972 /* The value chosen here is quite arbitrary as ld.so
14973 ignores section contents except for the special
14974 case of .opd where the contents might be accessed
14975 before relocation. Choose zero, as that won't
14976 cause reloc overflow. */
14979 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14980 to improve backward compatibility with older
14982 if (r_type == R_PPC64_ADDR64)
14983 addend = outrel.r_addend;
14984 /* Adjust pc_relative relocs to have zero in *r_offset. */
14985 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14986 addend = outrel.r_offset;
14989 else if (r_type == R_PPC64_DTPMOD64
14990 && htab->params->tls_get_addr_opt
14991 && htab->tls_get_addr_fd != NULL
14992 && htab->tls_get_addr_fd->elf.plt.plist != NULL)
14994 /* Set up for __tls_get_addr_opt stub, when this entry
14995 does not have dynamic relocs. */
14997 /* Set up the next word for local dynamic. If it turns
14998 out to be global dynamic, the reloc will overwrite
15000 if (rel->r_offset + 16 <= input_section->size)
15001 bfd_put_64 (input_bfd, DTP_OFFSET - TP_OFFSET,
15002 contents + rel->r_offset + 8);
15004 else if (r_type == R_PPC64_DTPREL64
15005 && htab->params->tls_get_addr_opt
15006 && htab->tls_get_addr_fd != NULL
15007 && htab->tls_get_addr_fd->elf.plt.plist != NULL
15009 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
15010 && rel[-1].r_offset + 8 == rel->r_offset)
15012 /* __tls_get_addr_opt stub value. */
15013 addend += DTP_OFFSET - TP_OFFSET;
15018 case R_PPC64_GLOB_DAT:
15019 case R_PPC64_JMP_SLOT:
15020 case R_PPC64_JMP_IREL:
15021 case R_PPC64_RELATIVE:
15022 /* We shouldn't ever see these dynamic relocs in relocatable
15024 /* Fall through. */
15026 case R_PPC64_PLTGOT16:
15027 case R_PPC64_PLTGOT16_DS:
15028 case R_PPC64_PLTGOT16_HA:
15029 case R_PPC64_PLTGOT16_HI:
15030 case R_PPC64_PLTGOT16_LO:
15031 case R_PPC64_PLTGOT16_LO_DS:
15032 case R_PPC64_PLTREL32:
15033 case R_PPC64_PLTREL64:
15034 /* These ones haven't been implemented yet. */
15036 info->callbacks->einfo
15037 /* xgettext:c-format */
15038 (_("%P: %B: %s is not supported for `%T'\n"),
15040 ppc64_elf_howto_table[r_type]->name, sym_name);
15042 bfd_set_error (bfd_error_invalid_operation);
15047 /* Multi-instruction sequences that access the TOC can be
15048 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15049 to nop; addi rb,r2,x; */
15055 case R_PPC64_GOT_TLSLD16_HI:
15056 case R_PPC64_GOT_TLSGD16_HI:
15057 case R_PPC64_GOT_TPREL16_HI:
15058 case R_PPC64_GOT_DTPREL16_HI:
15059 case R_PPC64_GOT16_HI:
15060 case R_PPC64_TOC16_HI:
15061 /* These relocs would only be useful if building up an
15062 offset to later add to r2, perhaps in an indexed
15063 addressing mode instruction. Don't try to optimize.
15064 Unfortunately, the possibility of someone building up an
15065 offset like this or even with the HA relocs, means that
15066 we need to check the high insn when optimizing the low
15070 case R_PPC64_GOT_TLSLD16_HA:
15071 case R_PPC64_GOT_TLSGD16_HA:
15072 case R_PPC64_GOT_TPREL16_HA:
15073 case R_PPC64_GOT_DTPREL16_HA:
15074 case R_PPC64_GOT16_HA:
15075 case R_PPC64_TOC16_HA:
15076 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15077 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15079 bfd_byte *p = contents + (rel->r_offset & ~3);
15080 bfd_put_32 (input_bfd, NOP, p);
15084 case R_PPC64_GOT_TLSLD16_LO:
15085 case R_PPC64_GOT_TLSGD16_LO:
15086 case R_PPC64_GOT_TPREL16_LO_DS:
15087 case R_PPC64_GOT_DTPREL16_LO_DS:
15088 case R_PPC64_GOT16_LO:
15089 case R_PPC64_GOT16_LO_DS:
15090 case R_PPC64_TOC16_LO:
15091 case R_PPC64_TOC16_LO_DS:
15092 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15093 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15095 bfd_byte *p = contents + (rel->r_offset & ~3);
15096 insn = bfd_get_32 (input_bfd, p);
15097 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15099 /* Transform addic to addi when we change reg. */
15100 insn &= ~((0x3f << 26) | (0x1f << 16));
15101 insn |= (14u << 26) | (2 << 16);
15105 insn &= ~(0x1f << 16);
15108 bfd_put_32 (input_bfd, insn, p);
15113 /* Do any further special processing. */
15114 howto = ppc64_elf_howto_table[(int) r_type];
15120 case R_PPC64_REL16_HA:
15121 case R_PPC64_REL16DX_HA:
15122 case R_PPC64_ADDR16_HA:
15123 case R_PPC64_ADDR16_HIGHA:
15124 case R_PPC64_ADDR16_HIGHERA:
15125 case R_PPC64_ADDR16_HIGHESTA:
15126 case R_PPC64_TOC16_HA:
15127 case R_PPC64_SECTOFF_HA:
15128 case R_PPC64_TPREL16_HA:
15129 case R_PPC64_TPREL16_HIGHA:
15130 case R_PPC64_TPREL16_HIGHERA:
15131 case R_PPC64_TPREL16_HIGHESTA:
15132 case R_PPC64_DTPREL16_HA:
15133 case R_PPC64_DTPREL16_HIGHA:
15134 case R_PPC64_DTPREL16_HIGHERA:
15135 case R_PPC64_DTPREL16_HIGHESTA:
15136 /* It's just possible that this symbol is a weak symbol
15137 that's not actually defined anywhere. In that case,
15138 'sec' would be NULL, and we should leave the symbol
15139 alone (it will be set to zero elsewhere in the link). */
15142 /* Fall through. */
15144 case R_PPC64_GOT16_HA:
15145 case R_PPC64_PLTGOT16_HA:
15146 case R_PPC64_PLT16_HA:
15147 case R_PPC64_GOT_TLSGD16_HA:
15148 case R_PPC64_GOT_TLSLD16_HA:
15149 case R_PPC64_GOT_TPREL16_HA:
15150 case R_PPC64_GOT_DTPREL16_HA:
15151 /* Add 0x10000 if sign bit in 0:15 is set.
15152 Bits 0:15 are not used. */
15156 case R_PPC64_ADDR16_DS:
15157 case R_PPC64_ADDR16_LO_DS:
15158 case R_PPC64_GOT16_DS:
15159 case R_PPC64_GOT16_LO_DS:
15160 case R_PPC64_PLT16_LO_DS:
15161 case R_PPC64_SECTOFF_DS:
15162 case R_PPC64_SECTOFF_LO_DS:
15163 case R_PPC64_TOC16_DS:
15164 case R_PPC64_TOC16_LO_DS:
15165 case R_PPC64_PLTGOT16_DS:
15166 case R_PPC64_PLTGOT16_LO_DS:
15167 case R_PPC64_GOT_TPREL16_DS:
15168 case R_PPC64_GOT_TPREL16_LO_DS:
15169 case R_PPC64_GOT_DTPREL16_DS:
15170 case R_PPC64_GOT_DTPREL16_LO_DS:
15171 case R_PPC64_TPREL16_DS:
15172 case R_PPC64_TPREL16_LO_DS:
15173 case R_PPC64_DTPREL16_DS:
15174 case R_PPC64_DTPREL16_LO_DS:
15175 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15177 /* If this reloc is against an lq, lxv, or stxv insn, then
15178 the value must be a multiple of 16. This is somewhat of
15179 a hack, but the "correct" way to do this by defining _DQ
15180 forms of all the _DS relocs bloats all reloc switches in
15181 this file. It doesn't make much sense to use these
15182 relocs in data, so testing the insn should be safe. */
15183 if ((insn & (0x3f << 26)) == (56u << 26)
15184 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15186 relocation += addend;
15187 addend = insn & (mask ^ 3);
15188 if ((relocation & mask) != 0)
15190 relocation ^= relocation & mask;
15191 info->callbacks->einfo
15192 /* xgettext:c-format */
15193 (_("%H: error: %s not a multiple of %u\n"),
15194 input_bfd, input_section, rel->r_offset,
15197 bfd_set_error (bfd_error_bad_value);
15204 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15205 because such sections are not SEC_ALLOC and thus ld.so will
15206 not process them. */
15207 if (unresolved_reloc
15208 && !((input_section->flags & SEC_DEBUGGING) != 0
15209 && h->elf.def_dynamic)
15210 && _bfd_elf_section_offset (output_bfd, info, input_section,
15211 rel->r_offset) != (bfd_vma) -1)
15213 info->callbacks->einfo
15214 /* xgettext:c-format */
15215 (_("%H: unresolvable %s against `%T'\n"),
15216 input_bfd, input_section, rel->r_offset,
15218 h->elf.root.root.string);
15222 /* 16-bit fields in insns mostly have signed values, but a
15223 few insns have 16-bit unsigned values. Really, we should
15224 have different reloc types. */
15225 if (howto->complain_on_overflow != complain_overflow_dont
15226 && howto->dst_mask == 0xffff
15227 && (input_section->flags & SEC_CODE) != 0)
15229 enum complain_overflow complain = complain_overflow_signed;
15231 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15232 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15233 complain = complain_overflow_bitfield;
15234 else if (howto->rightshift == 0
15235 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15236 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15237 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15238 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15239 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15240 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15241 complain = complain_overflow_unsigned;
15242 if (howto->complain_on_overflow != complain)
15244 alt_howto = *howto;
15245 alt_howto.complain_on_overflow = complain;
15246 howto = &alt_howto;
15250 if (r_type == R_PPC64_REL16DX_HA)
15252 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15253 if (rel->r_offset + 4 > input_section->size)
15254 r = bfd_reloc_outofrange;
15257 relocation += addend;
15258 relocation -= (rel->r_offset
15259 + input_section->output_offset
15260 + input_section->output_section->vma);
15261 relocation = (bfd_signed_vma) relocation >> 16;
15262 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15264 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15265 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15267 if (relocation + 0x8000 > 0xffff)
15268 r = bfd_reloc_overflow;
15272 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15273 rel->r_offset, relocation, addend);
15275 if (r != bfd_reloc_ok)
15277 char *more_info = NULL;
15278 const char *reloc_name = howto->name;
15280 if (reloc_dest != DEST_NORMAL)
15282 more_info = bfd_malloc (strlen (reloc_name) + 8);
15283 if (more_info != NULL)
15285 strcpy (more_info, reloc_name);
15286 strcat (more_info, (reloc_dest == DEST_OPD
15287 ? " (OPD)" : " (stub)"));
15288 reloc_name = more_info;
15292 if (r == bfd_reloc_overflow)
15294 /* On code like "if (foo) foo();" don't report overflow
15295 on a branch to zero when foo is undefined. */
15297 && (reloc_dest == DEST_STUB
15299 && (h->elf.root.type == bfd_link_hash_undefweak
15300 || h->elf.root.type == bfd_link_hash_undefined)
15301 && is_branch_reloc (r_type))))
15302 info->callbacks->reloc_overflow (info, &h->elf.root,
15303 sym_name, reloc_name,
15305 input_bfd, input_section,
15310 info->callbacks->einfo
15311 /* xgettext:c-format */
15312 (_("%H: %s against `%T': error %d\n"),
15313 input_bfd, input_section, rel->r_offset,
15314 reloc_name, sym_name, (int) r);
15317 if (more_info != NULL)
15327 Elf_Internal_Shdr *rel_hdr;
15328 size_t deleted = rel - wrel;
15330 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15331 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15332 if (rel_hdr->sh_size == 0)
15334 /* It is too late to remove an empty reloc section. Leave
15336 ??? What is wrong with an empty section??? */
15337 rel_hdr->sh_size = rel_hdr->sh_entsize;
15340 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15341 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15342 input_section->reloc_count -= deleted;
15345 /* If we're emitting relocations, then shortly after this function
15346 returns, reloc offsets and addends for this section will be
15347 adjusted. Worse, reloc symbol indices will be for the output
15348 file rather than the input. Save a copy of the relocs for
15349 opd_entry_value. */
15350 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15353 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15354 rel = bfd_alloc (input_bfd, amt);
15355 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15356 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15359 memcpy (rel, relocs, amt);
15364 /* Adjust the value of any local symbols in opd sections. */
15367 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15368 const char *name ATTRIBUTE_UNUSED,
15369 Elf_Internal_Sym *elfsym,
15370 asection *input_sec,
15371 struct elf_link_hash_entry *h)
15373 struct _opd_sec_data *opd;
15380 opd = get_opd_info (input_sec);
15381 if (opd == NULL || opd->adjust == NULL)
15384 value = elfsym->st_value - input_sec->output_offset;
15385 if (!bfd_link_relocatable (info))
15386 value -= input_sec->output_section->vma;
15388 adjust = opd->adjust[OPD_NDX (value)];
15392 elfsym->st_value += adjust;
15396 /* Finish up dynamic symbol handling. We set the contents of various
15397 dynamic sections here. */
15400 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15401 struct bfd_link_info *info,
15402 struct elf_link_hash_entry *h,
15403 Elf_Internal_Sym *sym)
15405 struct ppc_link_hash_table *htab;
15406 struct plt_entry *ent;
15407 Elf_Internal_Rela rela;
15410 htab = ppc_hash_table (info);
15414 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15415 if (ent->plt.offset != (bfd_vma) -1)
15417 /* This symbol has an entry in the procedure linkage
15418 table. Set it up. */
15419 if (!htab->elf.dynamic_sections_created
15420 || h->dynindx == -1)
15422 BFD_ASSERT (h->type == STT_GNU_IFUNC
15424 && (h->root.type == bfd_link_hash_defined
15425 || h->root.type == bfd_link_hash_defweak));
15426 rela.r_offset = (htab->elf.iplt->output_section->vma
15427 + htab->elf.iplt->output_offset
15428 + ent->plt.offset);
15430 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15432 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15433 rela.r_addend = (h->root.u.def.value
15434 + h->root.u.def.section->output_offset
15435 + h->root.u.def.section->output_section->vma
15437 loc = (htab->elf.irelplt->contents
15438 + (htab->elf.irelplt->reloc_count++
15439 * sizeof (Elf64_External_Rela)));
15443 rela.r_offset = (htab->elf.splt->output_section->vma
15444 + htab->elf.splt->output_offset
15445 + ent->plt.offset);
15446 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15447 rela.r_addend = ent->addend;
15448 loc = (htab->elf.srelplt->contents
15449 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15450 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15452 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15454 if (!htab->opd_abi)
15456 if (!h->def_regular)
15458 /* Mark the symbol as undefined, rather than as
15459 defined in glink. Leave the value if there were
15460 any relocations where pointer equality matters
15461 (this is a clue for the dynamic linker, to make
15462 function pointer comparisons work between an
15463 application and shared library), otherwise set it
15465 sym->st_shndx = SHN_UNDEF;
15466 if (!h->pointer_equality_needed)
15468 else if (!h->ref_regular_nonweak)
15470 /* This breaks function pointer comparisons, but
15471 that is better than breaking tests for a NULL
15472 function pointer. */
15481 /* This symbol needs a copy reloc. Set it up. */
15484 if (h->dynindx == -1
15485 || (h->root.type != bfd_link_hash_defined
15486 && h->root.type != bfd_link_hash_defweak)
15487 || htab->elf.srelbss == NULL
15488 || htab->elf.sreldynrelro == NULL)
15491 rela.r_offset = (h->root.u.def.value
15492 + h->root.u.def.section->output_section->vma
15493 + h->root.u.def.section->output_offset);
15494 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15496 if (h->root.u.def.section == htab->elf.sdynrelro)
15497 srel = htab->elf.sreldynrelro;
15499 srel = htab->elf.srelbss;
15500 loc = srel->contents;
15501 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15502 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15508 /* Used to decide how to sort relocs in an optimal manner for the
15509 dynamic linker, before writing them out. */
15511 static enum elf_reloc_type_class
15512 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15513 const asection *rel_sec,
15514 const Elf_Internal_Rela *rela)
15516 enum elf_ppc64_reloc_type r_type;
15517 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15519 if (rel_sec == htab->elf.irelplt)
15520 return reloc_class_ifunc;
15522 r_type = ELF64_R_TYPE (rela->r_info);
15525 case R_PPC64_RELATIVE:
15526 return reloc_class_relative;
15527 case R_PPC64_JMP_SLOT:
15528 return reloc_class_plt;
15530 return reloc_class_copy;
15532 return reloc_class_normal;
15536 /* Finish up the dynamic sections. */
15539 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15540 struct bfd_link_info *info)
15542 struct ppc_link_hash_table *htab;
15546 htab = ppc_hash_table (info);
15550 dynobj = htab->elf.dynobj;
15551 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15553 if (htab->elf.dynamic_sections_created)
15555 Elf64_External_Dyn *dyncon, *dynconend;
15557 if (sdyn == NULL || htab->elf.sgot == NULL)
15560 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15561 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15562 for (; dyncon < dynconend; dyncon++)
15564 Elf_Internal_Dyn dyn;
15567 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15574 case DT_PPC64_GLINK:
15576 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15577 /* We stupidly defined DT_PPC64_GLINK to be the start
15578 of glink rather than the first entry point, which is
15579 what ld.so needs, and now have a bigger stub to
15580 support automatic multiple TOCs. */
15581 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15585 s = bfd_get_section_by_name (output_bfd, ".opd");
15588 dyn.d_un.d_ptr = s->vma;
15592 if (htab->do_multi_toc && htab->multi_toc_needed)
15593 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15596 case DT_PPC64_OPDSZ:
15597 s = bfd_get_section_by_name (output_bfd, ".opd");
15600 dyn.d_un.d_val = s->size;
15604 s = htab->elf.splt;
15605 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15609 s = htab->elf.srelplt;
15610 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15614 dyn.d_un.d_val = htab->elf.srelplt->size;
15618 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15622 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15623 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15625 /* Fill in the first entry in the global offset table.
15626 We use it to hold the link-time TOCbase. */
15627 bfd_put_64 (output_bfd,
15628 elf_gp (output_bfd) + TOC_BASE_OFF,
15629 htab->elf.sgot->contents);
15631 /* Set .got entry size. */
15632 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15635 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15636 && htab->elf.splt->output_section != bfd_abs_section_ptr)
15638 /* Set .plt entry size. */
15639 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15640 = PLT_ENTRY_SIZE (htab);
15643 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15644 brlt ourselves if emitrelocations. */
15645 if (htab->brlt != NULL
15646 && htab->brlt->reloc_count != 0
15647 && !_bfd_elf_link_output_relocs (output_bfd,
15649 elf_section_data (htab->brlt)->rela.hdr,
15650 elf_section_data (htab->brlt)->relocs,
15654 if (htab->glink != NULL
15655 && htab->glink->reloc_count != 0
15656 && !_bfd_elf_link_output_relocs (output_bfd,
15658 elf_section_data (htab->glink)->rela.hdr,
15659 elf_section_data (htab->glink)->relocs,
15663 if (htab->glink_eh_frame != NULL
15664 && htab->glink_eh_frame->size != 0)
15668 asection *stub_sec;
15671 p = htab->glink_eh_frame->contents;
15672 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15673 for (stub_sec = htab->params->stub_bfd->sections;
15675 stub_sec = stub_sec->next)
15676 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15682 /* Offset to stub section. */
15683 val = (stub_sec->output_section->vma
15684 + stub_sec->output_offset);
15685 val -= (htab->glink_eh_frame->output_section->vma
15686 + htab->glink_eh_frame->output_offset
15687 + (p - htab->glink_eh_frame->contents));
15688 if (val + 0x80000000 > 0xffffffff)
15690 info->callbacks->einfo
15691 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15695 bfd_put_32 (dynobj, val, p);
15697 /* stub section size. */
15699 /* Augmentation. */
15702 p += ((17 + align - 1) & -align) - 17;
15704 if (htab->glink != NULL && htab->glink->size != 0)
15710 /* Offset to .glink. */
15711 val = (htab->glink->output_section->vma
15712 + htab->glink->output_offset
15714 val -= (htab->glink_eh_frame->output_section->vma
15715 + htab->glink_eh_frame->output_offset
15716 + (p - htab->glink_eh_frame->contents));
15717 if (val + 0x80000000 > 0xffffffff)
15719 info->callbacks->einfo
15720 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15721 htab->glink->name);
15724 bfd_put_32 (dynobj, val, p);
15728 /* Augmentation. */
15732 p += ((24 + align - 1) & -align) - 24;
15735 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15736 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15737 htab->glink_eh_frame,
15738 htab->glink_eh_frame->contents))
15742 /* We need to handle writing out multiple GOT sections ourselves,
15743 since we didn't add them to DYNOBJ. We know dynobj is the first
15745 while ((dynobj = dynobj->link.next) != NULL)
15749 if (!is_ppc64_elf (dynobj))
15752 s = ppc64_elf_tdata (dynobj)->got;
15755 && s->output_section != bfd_abs_section_ptr
15756 && !bfd_set_section_contents (output_bfd, s->output_section,
15757 s->contents, s->output_offset,
15760 s = ppc64_elf_tdata (dynobj)->relgot;
15763 && s->output_section != bfd_abs_section_ptr
15764 && !bfd_set_section_contents (output_bfd, s->output_section,
15765 s->contents, s->output_offset,
15773 #include "elf64-target.h"
15775 /* FreeBSD support */
15777 #undef TARGET_LITTLE_SYM
15778 #undef TARGET_LITTLE_NAME
15780 #undef TARGET_BIG_SYM
15781 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15782 #undef TARGET_BIG_NAME
15783 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15786 #define ELF_OSABI ELFOSABI_FREEBSD
15789 #define elf64_bed elf64_powerpc_fbsd_bed
15791 #include "elf64-target.h"