1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_before_check_relocs
98 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
108 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
110 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
121 /* The name of the dynamic interpreter. This is put in the .interp
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
131 /* Offsets to some stack save slots. */
133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
134 /* This one is dodgy. ELFv2 does not have a linker word, so use the
135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
139 /* TOC base pointers offset from start of TOC. */
140 #define TOC_BASE_OFF 0x8000
142 /* Offset of tp and dtp pointers from start of TLS block. */
143 #define TP_OFFSET 0x7000
144 #define DTP_OFFSET 0x8000
146 /* .plt call stub instructions. The normal stub is like this, but
147 sometimes the .plt entry crosses a 64k boundary and we need to
148 insert an addi to adjust r11. */
149 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
150 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
151 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
152 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
153 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
154 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
155 #define BCTR 0x4e800420 /* bctr */
157 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
158 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
159 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
161 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
162 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
163 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
164 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
165 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
166 #define BNECTR 0x4ca20420 /* bnectr+ */
167 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
169 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
170 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
171 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
173 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
175 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
176 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
177 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
179 /* glink call stub instructions. We enter with the index in R0. */
180 #define GLINK_CALL_STUB_SIZE (16*4)
184 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
185 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
187 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
188 /* ld %2,(0b-1b)(%11) */
189 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
190 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
196 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
197 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
198 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
199 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
200 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
203 #define NOP 0x60000000
205 /* Some other nops. */
206 #define CROR_151515 0x4def7b82
207 #define CROR_313131 0x4ffffb82
209 /* .glink entries for the first 32k functions are two instructions. */
210 #define LI_R0_0 0x38000000 /* li %r0,0 */
211 #define B_DOT 0x48000000 /* b . */
213 /* After that, we need two instructions to load the index, followed by
215 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
216 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
218 /* Instructions used by the save and restore reg functions. */
219 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
220 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
221 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
222 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
223 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
224 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
225 #define LI_R12_0 0x39800000 /* li %r12,0 */
226 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
227 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
228 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
229 #define BLR 0x4e800020 /* blr */
231 /* Since .opd is an array of descriptors and each entry will end up
232 with identical R_PPC64_RELATIVE relocs, there is really no need to
233 propagate .opd relocs; The dynamic linker should be taught to
234 relocate .opd without reloc entries. */
235 #ifndef NO_OPD_RELOCS
236 #define NO_OPD_RELOCS 0
239 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
241 /* Relocation HOWTO's. */
242 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
244 static reloc_howto_type ppc64_elf_howto_raw[] = {
245 /* This reloc does nothing. */
246 HOWTO (R_PPC64_NONE, /* type */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
250 FALSE, /* pc_relative */
252 complain_overflow_dont, /* complain_on_overflow */
253 bfd_elf_generic_reloc, /* special_function */
254 "R_PPC64_NONE", /* name */
255 FALSE, /* partial_inplace */
258 FALSE), /* pcrel_offset */
260 /* A standard 32 bit relocation. */
261 HOWTO (R_PPC64_ADDR32, /* type */
263 2, /* size (0 = byte, 1 = short, 2 = long) */
265 FALSE, /* pc_relative */
267 complain_overflow_bitfield, /* complain_on_overflow */
268 bfd_elf_generic_reloc, /* special_function */
269 "R_PPC64_ADDR32", /* name */
270 FALSE, /* partial_inplace */
272 0xffffffff, /* dst_mask */
273 FALSE), /* pcrel_offset */
275 /* An absolute 26 bit branch; the lower two bits must be zero.
276 FIXME: we don't check that, we just clear them. */
277 HOWTO (R_PPC64_ADDR24, /* type */
279 2, /* size (0 = byte, 1 = short, 2 = long) */
281 FALSE, /* pc_relative */
283 complain_overflow_bitfield, /* complain_on_overflow */
284 bfd_elf_generic_reloc, /* special_function */
285 "R_PPC64_ADDR24", /* name */
286 FALSE, /* partial_inplace */
288 0x03fffffc, /* dst_mask */
289 FALSE), /* pcrel_offset */
291 /* A standard 16 bit relocation. */
292 HOWTO (R_PPC64_ADDR16, /* type */
294 1, /* size (0 = byte, 1 = short, 2 = long) */
296 FALSE, /* pc_relative */
298 complain_overflow_bitfield, /* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_PPC64_ADDR16", /* name */
301 FALSE, /* partial_inplace */
303 0xffff, /* dst_mask */
304 FALSE), /* pcrel_offset */
306 /* A 16 bit relocation without overflow. */
307 HOWTO (R_PPC64_ADDR16_LO, /* type */
309 1, /* size (0 = byte, 1 = short, 2 = long) */
311 FALSE, /* pc_relative */
313 complain_overflow_dont,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_PPC64_ADDR16_LO", /* name */
316 FALSE, /* partial_inplace */
318 0xffff, /* dst_mask */
319 FALSE), /* pcrel_offset */
321 /* Bits 16-31 of an address. */
322 HOWTO (R_PPC64_ADDR16_HI, /* type */
324 1, /* size (0 = byte, 1 = short, 2 = long) */
326 FALSE, /* pc_relative */
328 complain_overflow_signed, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_PPC64_ADDR16_HI", /* name */
331 FALSE, /* partial_inplace */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
336 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
337 bits, treated as a signed number, is negative. */
338 HOWTO (R_PPC64_ADDR16_HA, /* type */
340 1, /* size (0 = byte, 1 = short, 2 = long) */
342 FALSE, /* pc_relative */
344 complain_overflow_signed, /* complain_on_overflow */
345 ppc64_elf_ha_reloc, /* special_function */
346 "R_PPC64_ADDR16_HA", /* name */
347 FALSE, /* partial_inplace */
349 0xffff, /* dst_mask */
350 FALSE), /* pcrel_offset */
352 /* An absolute 16 bit branch; the lower two bits must be zero.
353 FIXME: we don't check that, we just clear them. */
354 HOWTO (R_PPC64_ADDR14, /* type */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
358 FALSE, /* pc_relative */
360 complain_overflow_signed, /* complain_on_overflow */
361 ppc64_elf_branch_reloc, /* special_function */
362 "R_PPC64_ADDR14", /* name */
363 FALSE, /* partial_inplace */
365 0x0000fffc, /* dst_mask */
366 FALSE), /* pcrel_offset */
368 /* An absolute 16 bit branch, for which bit 10 should be set to
369 indicate that the branch is expected to be taken. The lower two
370 bits must be zero. */
371 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
375 FALSE, /* pc_relative */
377 complain_overflow_signed, /* complain_on_overflow */
378 ppc64_elf_brtaken_reloc, /* special_function */
379 "R_PPC64_ADDR14_BRTAKEN",/* name */
380 FALSE, /* partial_inplace */
382 0x0000fffc, /* dst_mask */
383 FALSE), /* pcrel_offset */
385 /* An absolute 16 bit branch, for which bit 10 should be set to
386 indicate that the branch is not expected to be taken. The lower
387 two bits must be zero. */
388 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
392 FALSE, /* pc_relative */
394 complain_overflow_signed, /* complain_on_overflow */
395 ppc64_elf_brtaken_reloc, /* special_function */
396 "R_PPC64_ADDR14_BRNTAKEN",/* name */
397 FALSE, /* partial_inplace */
399 0x0000fffc, /* dst_mask */
400 FALSE), /* pcrel_offset */
402 /* A relative 26 bit branch; the lower two bits must be zero. */
403 HOWTO (R_PPC64_REL24, /* type */
405 2, /* size (0 = byte, 1 = short, 2 = long) */
407 TRUE, /* pc_relative */
409 complain_overflow_signed, /* complain_on_overflow */
410 ppc64_elf_branch_reloc, /* special_function */
411 "R_PPC64_REL24", /* name */
412 FALSE, /* partial_inplace */
414 0x03fffffc, /* dst_mask */
415 TRUE), /* pcrel_offset */
417 /* A relative 16 bit branch; the lower two bits must be zero. */
418 HOWTO (R_PPC64_REL14, /* type */
420 2, /* size (0 = byte, 1 = short, 2 = long) */
422 TRUE, /* pc_relative */
424 complain_overflow_signed, /* complain_on_overflow */
425 ppc64_elf_branch_reloc, /* special_function */
426 "R_PPC64_REL14", /* name */
427 FALSE, /* partial_inplace */
429 0x0000fffc, /* dst_mask */
430 TRUE), /* pcrel_offset */
432 /* A relative 16 bit branch. Bit 10 should be set to indicate that
433 the branch is expected to be taken. The lower two bits must be
435 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
439 TRUE, /* pc_relative */
441 complain_overflow_signed, /* complain_on_overflow */
442 ppc64_elf_brtaken_reloc, /* special_function */
443 "R_PPC64_REL14_BRTAKEN", /* name */
444 FALSE, /* partial_inplace */
446 0x0000fffc, /* dst_mask */
447 TRUE), /* pcrel_offset */
449 /* A relative 16 bit branch. Bit 10 should be set to indicate that
450 the branch is not expected to be taken. The lower two bits must
452 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
456 TRUE, /* pc_relative */
458 complain_overflow_signed, /* complain_on_overflow */
459 ppc64_elf_brtaken_reloc, /* special_function */
460 "R_PPC64_REL14_BRNTAKEN",/* name */
461 FALSE, /* partial_inplace */
463 0x0000fffc, /* dst_mask */
464 TRUE), /* pcrel_offset */
466 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
468 HOWTO (R_PPC64_GOT16, /* type */
470 1, /* size (0 = byte, 1 = short, 2 = long) */
472 FALSE, /* pc_relative */
474 complain_overflow_signed, /* complain_on_overflow */
475 ppc64_elf_unhandled_reloc, /* special_function */
476 "R_PPC64_GOT16", /* name */
477 FALSE, /* partial_inplace */
479 0xffff, /* dst_mask */
480 FALSE), /* pcrel_offset */
482 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
484 HOWTO (R_PPC64_GOT16_LO, /* type */
486 1, /* size (0 = byte, 1 = short, 2 = long) */
488 FALSE, /* pc_relative */
490 complain_overflow_dont, /* complain_on_overflow */
491 ppc64_elf_unhandled_reloc, /* special_function */
492 "R_PPC64_GOT16_LO", /* name */
493 FALSE, /* partial_inplace */
495 0xffff, /* dst_mask */
496 FALSE), /* pcrel_offset */
498 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
500 HOWTO (R_PPC64_GOT16_HI, /* type */
502 1, /* size (0 = byte, 1 = short, 2 = long) */
504 FALSE, /* pc_relative */
506 complain_overflow_signed,/* complain_on_overflow */
507 ppc64_elf_unhandled_reloc, /* special_function */
508 "R_PPC64_GOT16_HI", /* name */
509 FALSE, /* partial_inplace */
511 0xffff, /* dst_mask */
512 FALSE), /* pcrel_offset */
514 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
516 HOWTO (R_PPC64_GOT16_HA, /* type */
518 1, /* size (0 = byte, 1 = short, 2 = long) */
520 FALSE, /* pc_relative */
522 complain_overflow_signed,/* complain_on_overflow */
523 ppc64_elf_unhandled_reloc, /* special_function */
524 "R_PPC64_GOT16_HA", /* name */
525 FALSE, /* partial_inplace */
527 0xffff, /* dst_mask */
528 FALSE), /* pcrel_offset */
530 /* This is used only by the dynamic linker. The symbol should exist
531 both in the object being run and in some shared library. The
532 dynamic linker copies the data addressed by the symbol from the
533 shared library into the object, because the object being
534 run has to have the data at some particular address. */
535 HOWTO (R_PPC64_COPY, /* type */
537 0, /* this one is variable size */
539 FALSE, /* pc_relative */
541 complain_overflow_dont, /* complain_on_overflow */
542 ppc64_elf_unhandled_reloc, /* special_function */
543 "R_PPC64_COPY", /* name */
544 FALSE, /* partial_inplace */
547 FALSE), /* pcrel_offset */
549 /* Like R_PPC64_ADDR64, but used when setting global offset table
551 HOWTO (R_PPC64_GLOB_DAT, /* type */
553 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
555 FALSE, /* pc_relative */
557 complain_overflow_dont, /* complain_on_overflow */
558 ppc64_elf_unhandled_reloc, /* special_function */
559 "R_PPC64_GLOB_DAT", /* name */
560 FALSE, /* partial_inplace */
562 ONES (64), /* dst_mask */
563 FALSE), /* pcrel_offset */
565 /* Created by the link editor. Marks a procedure linkage table
566 entry for a symbol. */
567 HOWTO (R_PPC64_JMP_SLOT, /* type */
569 0, /* size (0 = byte, 1 = short, 2 = long) */
571 FALSE, /* pc_relative */
573 complain_overflow_dont, /* complain_on_overflow */
574 ppc64_elf_unhandled_reloc, /* special_function */
575 "R_PPC64_JMP_SLOT", /* name */
576 FALSE, /* partial_inplace */
579 FALSE), /* pcrel_offset */
581 /* Used only by the dynamic linker. When the object is run, this
582 doubleword64 is set to the load address of the object, plus the
584 HOWTO (R_PPC64_RELATIVE, /* type */
586 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
588 FALSE, /* pc_relative */
590 complain_overflow_dont, /* complain_on_overflow */
591 bfd_elf_generic_reloc, /* special_function */
592 "R_PPC64_RELATIVE", /* name */
593 FALSE, /* partial_inplace */
595 ONES (64), /* dst_mask */
596 FALSE), /* pcrel_offset */
598 /* Like R_PPC64_ADDR32, but may be unaligned. */
599 HOWTO (R_PPC64_UADDR32, /* type */
601 2, /* size (0 = byte, 1 = short, 2 = long) */
603 FALSE, /* pc_relative */
605 complain_overflow_bitfield, /* complain_on_overflow */
606 bfd_elf_generic_reloc, /* special_function */
607 "R_PPC64_UADDR32", /* name */
608 FALSE, /* partial_inplace */
610 0xffffffff, /* dst_mask */
611 FALSE), /* pcrel_offset */
613 /* Like R_PPC64_ADDR16, but may be unaligned. */
614 HOWTO (R_PPC64_UADDR16, /* type */
616 1, /* size (0 = byte, 1 = short, 2 = long) */
618 FALSE, /* pc_relative */
620 complain_overflow_bitfield, /* complain_on_overflow */
621 bfd_elf_generic_reloc, /* special_function */
622 "R_PPC64_UADDR16", /* name */
623 FALSE, /* partial_inplace */
625 0xffff, /* dst_mask */
626 FALSE), /* pcrel_offset */
628 /* 32-bit PC relative. */
629 HOWTO (R_PPC64_REL32, /* type */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
633 TRUE, /* pc_relative */
635 complain_overflow_signed, /* complain_on_overflow */
636 bfd_elf_generic_reloc, /* special_function */
637 "R_PPC64_REL32", /* name */
638 FALSE, /* partial_inplace */
640 0xffffffff, /* dst_mask */
641 TRUE), /* pcrel_offset */
643 /* 32-bit relocation to the symbol's procedure linkage table. */
644 HOWTO (R_PPC64_PLT32, /* type */
646 2, /* size (0 = byte, 1 = short, 2 = long) */
648 FALSE, /* pc_relative */
650 complain_overflow_bitfield, /* complain_on_overflow */
651 ppc64_elf_unhandled_reloc, /* special_function */
652 "R_PPC64_PLT32", /* name */
653 FALSE, /* partial_inplace */
655 0xffffffff, /* dst_mask */
656 FALSE), /* pcrel_offset */
658 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
659 FIXME: R_PPC64_PLTREL32 not supported. */
660 HOWTO (R_PPC64_PLTREL32, /* type */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
664 TRUE, /* pc_relative */
666 complain_overflow_signed, /* complain_on_overflow */
667 bfd_elf_generic_reloc, /* special_function */
668 "R_PPC64_PLTREL32", /* name */
669 FALSE, /* partial_inplace */
671 0xffffffff, /* dst_mask */
672 TRUE), /* pcrel_offset */
674 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
676 HOWTO (R_PPC64_PLT16_LO, /* type */
678 1, /* size (0 = byte, 1 = short, 2 = long) */
680 FALSE, /* pc_relative */
682 complain_overflow_dont, /* complain_on_overflow */
683 ppc64_elf_unhandled_reloc, /* special_function */
684 "R_PPC64_PLT16_LO", /* name */
685 FALSE, /* partial_inplace */
687 0xffff, /* dst_mask */
688 FALSE), /* pcrel_offset */
690 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
692 HOWTO (R_PPC64_PLT16_HI, /* type */
694 1, /* size (0 = byte, 1 = short, 2 = long) */
696 FALSE, /* pc_relative */
698 complain_overflow_signed, /* complain_on_overflow */
699 ppc64_elf_unhandled_reloc, /* special_function */
700 "R_PPC64_PLT16_HI", /* name */
701 FALSE, /* partial_inplace */
703 0xffff, /* dst_mask */
704 FALSE), /* pcrel_offset */
706 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
708 HOWTO (R_PPC64_PLT16_HA, /* type */
710 1, /* size (0 = byte, 1 = short, 2 = long) */
712 FALSE, /* pc_relative */
714 complain_overflow_signed, /* complain_on_overflow */
715 ppc64_elf_unhandled_reloc, /* special_function */
716 "R_PPC64_PLT16_HA", /* name */
717 FALSE, /* partial_inplace */
719 0xffff, /* dst_mask */
720 FALSE), /* pcrel_offset */
722 /* 16-bit section relative relocation. */
723 HOWTO (R_PPC64_SECTOFF, /* type */
725 1, /* size (0 = byte, 1 = short, 2 = long) */
727 FALSE, /* pc_relative */
729 complain_overflow_signed, /* complain_on_overflow */
730 ppc64_elf_sectoff_reloc, /* special_function */
731 "R_PPC64_SECTOFF", /* name */
732 FALSE, /* partial_inplace */
734 0xffff, /* dst_mask */
735 FALSE), /* pcrel_offset */
737 /* Like R_PPC64_SECTOFF, but no overflow warning. */
738 HOWTO (R_PPC64_SECTOFF_LO, /* type */
740 1, /* size (0 = byte, 1 = short, 2 = long) */
742 FALSE, /* pc_relative */
744 complain_overflow_dont, /* complain_on_overflow */
745 ppc64_elf_sectoff_reloc, /* special_function */
746 "R_PPC64_SECTOFF_LO", /* name */
747 FALSE, /* partial_inplace */
749 0xffff, /* dst_mask */
750 FALSE), /* pcrel_offset */
752 /* 16-bit upper half section relative relocation. */
753 HOWTO (R_PPC64_SECTOFF_HI, /* type */
755 1, /* size (0 = byte, 1 = short, 2 = long) */
757 FALSE, /* pc_relative */
759 complain_overflow_signed, /* complain_on_overflow */
760 ppc64_elf_sectoff_reloc, /* special_function */
761 "R_PPC64_SECTOFF_HI", /* name */
762 FALSE, /* partial_inplace */
764 0xffff, /* dst_mask */
765 FALSE), /* pcrel_offset */
767 /* 16-bit upper half adjusted section relative relocation. */
768 HOWTO (R_PPC64_SECTOFF_HA, /* type */
770 1, /* size (0 = byte, 1 = short, 2 = long) */
772 FALSE, /* pc_relative */
774 complain_overflow_signed, /* complain_on_overflow */
775 ppc64_elf_sectoff_ha_reloc, /* special_function */
776 "R_PPC64_SECTOFF_HA", /* name */
777 FALSE, /* partial_inplace */
779 0xffff, /* dst_mask */
780 FALSE), /* pcrel_offset */
782 /* Like R_PPC64_REL24 without touching the two least significant bits. */
783 HOWTO (R_PPC64_REL30, /* type */
785 2, /* size (0 = byte, 1 = short, 2 = long) */
787 TRUE, /* pc_relative */
789 complain_overflow_dont, /* complain_on_overflow */
790 bfd_elf_generic_reloc, /* special_function */
791 "R_PPC64_REL30", /* name */
792 FALSE, /* partial_inplace */
794 0xfffffffc, /* dst_mask */
795 TRUE), /* pcrel_offset */
797 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
799 /* A standard 64-bit relocation. */
800 HOWTO (R_PPC64_ADDR64, /* type */
802 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
804 FALSE, /* pc_relative */
806 complain_overflow_dont, /* complain_on_overflow */
807 bfd_elf_generic_reloc, /* special_function */
808 "R_PPC64_ADDR64", /* name */
809 FALSE, /* partial_inplace */
811 ONES (64), /* dst_mask */
812 FALSE), /* pcrel_offset */
814 /* The bits 32-47 of an address. */
815 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
817 1, /* size (0 = byte, 1 = short, 2 = long) */
819 FALSE, /* pc_relative */
821 complain_overflow_dont, /* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "R_PPC64_ADDR16_HIGHER", /* name */
824 FALSE, /* partial_inplace */
826 0xffff, /* dst_mask */
827 FALSE), /* pcrel_offset */
829 /* The bits 32-47 of an address, plus 1 if the contents of the low
830 16 bits, treated as a signed number, is negative. */
831 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
833 1, /* size (0 = byte, 1 = short, 2 = long) */
835 FALSE, /* pc_relative */
837 complain_overflow_dont, /* complain_on_overflow */
838 ppc64_elf_ha_reloc, /* special_function */
839 "R_PPC64_ADDR16_HIGHERA", /* name */
840 FALSE, /* partial_inplace */
842 0xffff, /* dst_mask */
843 FALSE), /* pcrel_offset */
845 /* The bits 48-63 of an address. */
846 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
848 1, /* size (0 = byte, 1 = short, 2 = long) */
850 FALSE, /* pc_relative */
852 complain_overflow_dont, /* complain_on_overflow */
853 bfd_elf_generic_reloc, /* special_function */
854 "R_PPC64_ADDR16_HIGHEST", /* name */
855 FALSE, /* partial_inplace */
857 0xffff, /* dst_mask */
858 FALSE), /* pcrel_offset */
860 /* The bits 48-63 of an address, plus 1 if the contents of the low
861 16 bits, treated as a signed number, is negative. */
862 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
864 1, /* size (0 = byte, 1 = short, 2 = long) */
866 FALSE, /* pc_relative */
868 complain_overflow_dont, /* complain_on_overflow */
869 ppc64_elf_ha_reloc, /* special_function */
870 "R_PPC64_ADDR16_HIGHESTA", /* name */
871 FALSE, /* partial_inplace */
873 0xffff, /* dst_mask */
874 FALSE), /* pcrel_offset */
876 /* Like ADDR64, but may be unaligned. */
877 HOWTO (R_PPC64_UADDR64, /* type */
879 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
881 FALSE, /* pc_relative */
883 complain_overflow_dont, /* complain_on_overflow */
884 bfd_elf_generic_reloc, /* special_function */
885 "R_PPC64_UADDR64", /* name */
886 FALSE, /* partial_inplace */
888 ONES (64), /* dst_mask */
889 FALSE), /* pcrel_offset */
891 /* 64-bit relative relocation. */
892 HOWTO (R_PPC64_REL64, /* type */
894 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
896 TRUE, /* pc_relative */
898 complain_overflow_dont, /* complain_on_overflow */
899 bfd_elf_generic_reloc, /* special_function */
900 "R_PPC64_REL64", /* name */
901 FALSE, /* partial_inplace */
903 ONES (64), /* dst_mask */
904 TRUE), /* pcrel_offset */
906 /* 64-bit relocation to the symbol's procedure linkage table. */
907 HOWTO (R_PPC64_PLT64, /* type */
909 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
911 FALSE, /* pc_relative */
913 complain_overflow_dont, /* complain_on_overflow */
914 ppc64_elf_unhandled_reloc, /* special_function */
915 "R_PPC64_PLT64", /* name */
916 FALSE, /* partial_inplace */
918 ONES (64), /* dst_mask */
919 FALSE), /* pcrel_offset */
921 /* 64-bit PC relative relocation to the symbol's procedure linkage
923 /* FIXME: R_PPC64_PLTREL64 not supported. */
924 HOWTO (R_PPC64_PLTREL64, /* type */
926 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
928 TRUE, /* pc_relative */
930 complain_overflow_dont, /* complain_on_overflow */
931 ppc64_elf_unhandled_reloc, /* special_function */
932 "R_PPC64_PLTREL64", /* name */
933 FALSE, /* partial_inplace */
935 ONES (64), /* dst_mask */
936 TRUE), /* pcrel_offset */
938 /* 16 bit TOC-relative relocation. */
940 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
941 HOWTO (R_PPC64_TOC16, /* type */
943 1, /* size (0 = byte, 1 = short, 2 = long) */
945 FALSE, /* pc_relative */
947 complain_overflow_signed, /* complain_on_overflow */
948 ppc64_elf_toc_reloc, /* special_function */
949 "R_PPC64_TOC16", /* name */
950 FALSE, /* partial_inplace */
952 0xffff, /* dst_mask */
953 FALSE), /* pcrel_offset */
955 /* 16 bit TOC-relative relocation without overflow. */
957 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
958 HOWTO (R_PPC64_TOC16_LO, /* type */
960 1, /* size (0 = byte, 1 = short, 2 = long) */
962 FALSE, /* pc_relative */
964 complain_overflow_dont, /* complain_on_overflow */
965 ppc64_elf_toc_reloc, /* special_function */
966 "R_PPC64_TOC16_LO", /* name */
967 FALSE, /* partial_inplace */
969 0xffff, /* dst_mask */
970 FALSE), /* pcrel_offset */
972 /* 16 bit TOC-relative relocation, high 16 bits. */
974 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
975 HOWTO (R_PPC64_TOC16_HI, /* type */
977 1, /* size (0 = byte, 1 = short, 2 = long) */
979 FALSE, /* pc_relative */
981 complain_overflow_signed, /* complain_on_overflow */
982 ppc64_elf_toc_reloc, /* special_function */
983 "R_PPC64_TOC16_HI", /* name */
984 FALSE, /* partial_inplace */
986 0xffff, /* dst_mask */
987 FALSE), /* pcrel_offset */
989 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
990 contents of the low 16 bits, treated as a signed number, is
993 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
994 HOWTO (R_PPC64_TOC16_HA, /* type */
996 1, /* size (0 = byte, 1 = short, 2 = long) */
998 FALSE, /* pc_relative */
1000 complain_overflow_signed, /* complain_on_overflow */
1001 ppc64_elf_toc_ha_reloc, /* special_function */
1002 "R_PPC64_TOC16_HA", /* name */
1003 FALSE, /* partial_inplace */
1005 0xffff, /* dst_mask */
1006 FALSE), /* pcrel_offset */
1008 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1010 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1011 HOWTO (R_PPC64_TOC, /* type */
1013 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1015 FALSE, /* pc_relative */
1017 complain_overflow_dont, /* complain_on_overflow */
1018 ppc64_elf_toc64_reloc, /* special_function */
1019 "R_PPC64_TOC", /* name */
1020 FALSE, /* partial_inplace */
1022 ONES (64), /* dst_mask */
1023 FALSE), /* pcrel_offset */
1025 /* Like R_PPC64_GOT16, but also informs the link editor that the
1026 value to relocate may (!) refer to a PLT entry which the link
1027 editor (a) may replace with the symbol value. If the link editor
1028 is unable to fully resolve the symbol, it may (b) create a PLT
1029 entry and store the address to the new PLT entry in the GOT.
1030 This permits lazy resolution of function symbols at run time.
1031 The link editor may also skip all of this and just (c) emit a
1032 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1033 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1034 HOWTO (R_PPC64_PLTGOT16, /* type */
1036 1, /* size (0 = byte, 1 = short, 2 = long) */
1038 FALSE, /* pc_relative */
1040 complain_overflow_signed, /* complain_on_overflow */
1041 ppc64_elf_unhandled_reloc, /* special_function */
1042 "R_PPC64_PLTGOT16", /* name */
1043 FALSE, /* partial_inplace */
1045 0xffff, /* dst_mask */
1046 FALSE), /* pcrel_offset */
1048 /* Like R_PPC64_PLTGOT16, but without overflow. */
1049 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1050 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1052 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 FALSE, /* pc_relative */
1056 complain_overflow_dont, /* complain_on_overflow */
1057 ppc64_elf_unhandled_reloc, /* special_function */
1058 "R_PPC64_PLTGOT16_LO", /* name */
1059 FALSE, /* partial_inplace */
1061 0xffff, /* dst_mask */
1062 FALSE), /* pcrel_offset */
1064 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1065 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1066 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1067 16, /* rightshift */
1068 1, /* size (0 = byte, 1 = short, 2 = long) */
1070 FALSE, /* pc_relative */
1072 complain_overflow_signed, /* complain_on_overflow */
1073 ppc64_elf_unhandled_reloc, /* special_function */
1074 "R_PPC64_PLTGOT16_HI", /* name */
1075 FALSE, /* partial_inplace */
1077 0xffff, /* dst_mask */
1078 FALSE), /* pcrel_offset */
1080 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1081 1 if the contents of the low 16 bits, treated as a signed number,
1083 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1084 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1085 16, /* rightshift */
1086 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 FALSE, /* pc_relative */
1090 complain_overflow_signed, /* complain_on_overflow */
1091 ppc64_elf_unhandled_reloc, /* special_function */
1092 "R_PPC64_PLTGOT16_HA", /* name */
1093 FALSE, /* partial_inplace */
1095 0xffff, /* dst_mask */
1096 FALSE), /* pcrel_offset */
1098 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1099 HOWTO (R_PPC64_ADDR16_DS, /* type */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 FALSE, /* pc_relative */
1105 complain_overflow_signed, /* complain_on_overflow */
1106 bfd_elf_generic_reloc, /* special_function */
1107 "R_PPC64_ADDR16_DS", /* name */
1108 FALSE, /* partial_inplace */
1110 0xfffc, /* dst_mask */
1111 FALSE), /* pcrel_offset */
1113 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1114 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1116 1, /* size (0 = byte, 1 = short, 2 = long) */
1118 FALSE, /* pc_relative */
1120 complain_overflow_dont,/* complain_on_overflow */
1121 bfd_elf_generic_reloc, /* special_function */
1122 "R_PPC64_ADDR16_LO_DS",/* name */
1123 FALSE, /* partial_inplace */
1125 0xfffc, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1128 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1129 HOWTO (R_PPC64_GOT16_DS, /* type */
1131 1, /* size (0 = byte, 1 = short, 2 = long) */
1133 FALSE, /* pc_relative */
1135 complain_overflow_signed, /* complain_on_overflow */
1136 ppc64_elf_unhandled_reloc, /* special_function */
1137 "R_PPC64_GOT16_DS", /* name */
1138 FALSE, /* partial_inplace */
1140 0xfffc, /* dst_mask */
1141 FALSE), /* pcrel_offset */
1143 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1144 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1146 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 FALSE, /* pc_relative */
1150 complain_overflow_dont, /* complain_on_overflow */
1151 ppc64_elf_unhandled_reloc, /* special_function */
1152 "R_PPC64_GOT16_LO_DS", /* name */
1153 FALSE, /* partial_inplace */
1155 0xfffc, /* dst_mask */
1156 FALSE), /* pcrel_offset */
1158 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1159 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1161 1, /* size (0 = byte, 1 = short, 2 = long) */
1163 FALSE, /* pc_relative */
1165 complain_overflow_dont, /* complain_on_overflow */
1166 ppc64_elf_unhandled_reloc, /* special_function */
1167 "R_PPC64_PLT16_LO_DS", /* name */
1168 FALSE, /* partial_inplace */
1170 0xfffc, /* dst_mask */
1171 FALSE), /* pcrel_offset */
1173 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1174 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1176 1, /* size (0 = byte, 1 = short, 2 = long) */
1178 FALSE, /* pc_relative */
1180 complain_overflow_signed, /* complain_on_overflow */
1181 ppc64_elf_sectoff_reloc, /* special_function */
1182 "R_PPC64_SECTOFF_DS", /* name */
1183 FALSE, /* partial_inplace */
1185 0xfffc, /* dst_mask */
1186 FALSE), /* pcrel_offset */
1188 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1189 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1191 1, /* size (0 = byte, 1 = short, 2 = long) */
1193 FALSE, /* pc_relative */
1195 complain_overflow_dont, /* complain_on_overflow */
1196 ppc64_elf_sectoff_reloc, /* special_function */
1197 "R_PPC64_SECTOFF_LO_DS",/* name */
1198 FALSE, /* partial_inplace */
1200 0xfffc, /* dst_mask */
1201 FALSE), /* pcrel_offset */
1203 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1204 HOWTO (R_PPC64_TOC16_DS, /* type */
1206 1, /* size (0 = byte, 1 = short, 2 = long) */
1208 FALSE, /* pc_relative */
1210 complain_overflow_signed, /* complain_on_overflow */
1211 ppc64_elf_toc_reloc, /* special_function */
1212 "R_PPC64_TOC16_DS", /* name */
1213 FALSE, /* partial_inplace */
1215 0xfffc, /* dst_mask */
1216 FALSE), /* pcrel_offset */
1218 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1219 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1221 1, /* size (0 = byte, 1 = short, 2 = long) */
1223 FALSE, /* pc_relative */
1225 complain_overflow_dont, /* complain_on_overflow */
1226 ppc64_elf_toc_reloc, /* special_function */
1227 "R_PPC64_TOC16_LO_DS", /* name */
1228 FALSE, /* partial_inplace */
1230 0xfffc, /* dst_mask */
1231 FALSE), /* pcrel_offset */
1233 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1234 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1235 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1237 1, /* size (0 = byte, 1 = short, 2 = long) */
1239 FALSE, /* pc_relative */
1241 complain_overflow_signed, /* complain_on_overflow */
1242 ppc64_elf_unhandled_reloc, /* special_function */
1243 "R_PPC64_PLTGOT16_DS", /* name */
1244 FALSE, /* partial_inplace */
1246 0xfffc, /* dst_mask */
1247 FALSE), /* pcrel_offset */
1249 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1250 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1251 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1253 1, /* size (0 = byte, 1 = short, 2 = long) */
1255 FALSE, /* pc_relative */
1257 complain_overflow_dont, /* complain_on_overflow */
1258 ppc64_elf_unhandled_reloc, /* special_function */
1259 "R_PPC64_PLTGOT16_LO_DS",/* name */
1260 FALSE, /* partial_inplace */
1262 0xfffc, /* dst_mask */
1263 FALSE), /* pcrel_offset */
1265 /* Marker relocs for TLS. */
1268 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 FALSE, /* pc_relative */
1272 complain_overflow_dont, /* complain_on_overflow */
1273 bfd_elf_generic_reloc, /* special_function */
1274 "R_PPC64_TLS", /* name */
1275 FALSE, /* partial_inplace */
1278 FALSE), /* pcrel_offset */
1280 HOWTO (R_PPC64_TLSGD,
1282 2, /* size (0 = byte, 1 = short, 2 = long) */
1284 FALSE, /* pc_relative */
1286 complain_overflow_dont, /* complain_on_overflow */
1287 bfd_elf_generic_reloc, /* special_function */
1288 "R_PPC64_TLSGD", /* name */
1289 FALSE, /* partial_inplace */
1292 FALSE), /* pcrel_offset */
1294 HOWTO (R_PPC64_TLSLD,
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1298 FALSE, /* pc_relative */
1300 complain_overflow_dont, /* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_PPC64_TLSLD", /* name */
1303 FALSE, /* partial_inplace */
1306 FALSE), /* pcrel_offset */
1308 HOWTO (R_PPC64_TOCSAVE,
1310 2, /* size (0 = byte, 1 = short, 2 = long) */
1312 FALSE, /* pc_relative */
1314 complain_overflow_dont, /* complain_on_overflow */
1315 bfd_elf_generic_reloc, /* special_function */
1316 "R_PPC64_TOCSAVE", /* name */
1317 FALSE, /* partial_inplace */
1320 FALSE), /* pcrel_offset */
1322 /* Computes the load module index of the load module that contains the
1323 definition of its TLS sym. */
1324 HOWTO (R_PPC64_DTPMOD64,
1326 4, /* size (0 = byte, 1 = short, 2 = long) */
1328 FALSE, /* pc_relative */
1330 complain_overflow_dont, /* complain_on_overflow */
1331 ppc64_elf_unhandled_reloc, /* special_function */
1332 "R_PPC64_DTPMOD64", /* name */
1333 FALSE, /* partial_inplace */
1335 ONES (64), /* dst_mask */
1336 FALSE), /* pcrel_offset */
1338 /* Computes a dtv-relative displacement, the difference between the value
1339 of sym+add and the base address of the thread-local storage block that
1340 contains the definition of sym, minus 0x8000. */
1341 HOWTO (R_PPC64_DTPREL64,
1343 4, /* size (0 = byte, 1 = short, 2 = long) */
1345 FALSE, /* pc_relative */
1347 complain_overflow_dont, /* complain_on_overflow */
1348 ppc64_elf_unhandled_reloc, /* special_function */
1349 "R_PPC64_DTPREL64", /* name */
1350 FALSE, /* partial_inplace */
1352 ONES (64), /* dst_mask */
1353 FALSE), /* pcrel_offset */
1355 /* A 16 bit dtprel reloc. */
1356 HOWTO (R_PPC64_DTPREL16,
1358 1, /* size (0 = byte, 1 = short, 2 = long) */
1360 FALSE, /* pc_relative */
1362 complain_overflow_signed, /* complain_on_overflow */
1363 ppc64_elf_unhandled_reloc, /* special_function */
1364 "R_PPC64_DTPREL16", /* name */
1365 FALSE, /* partial_inplace */
1367 0xffff, /* dst_mask */
1368 FALSE), /* pcrel_offset */
1370 /* Like DTPREL16, but no overflow. */
1371 HOWTO (R_PPC64_DTPREL16_LO,
1373 1, /* size (0 = byte, 1 = short, 2 = long) */
1375 FALSE, /* pc_relative */
1377 complain_overflow_dont, /* complain_on_overflow */
1378 ppc64_elf_unhandled_reloc, /* special_function */
1379 "R_PPC64_DTPREL16_LO", /* name */
1380 FALSE, /* partial_inplace */
1382 0xffff, /* dst_mask */
1383 FALSE), /* pcrel_offset */
1385 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1386 HOWTO (R_PPC64_DTPREL16_HI,
1387 16, /* rightshift */
1388 1, /* size (0 = byte, 1 = short, 2 = long) */
1390 FALSE, /* pc_relative */
1392 complain_overflow_signed, /* complain_on_overflow */
1393 ppc64_elf_unhandled_reloc, /* special_function */
1394 "R_PPC64_DTPREL16_HI", /* name */
1395 FALSE, /* partial_inplace */
1397 0xffff, /* dst_mask */
1398 FALSE), /* pcrel_offset */
1400 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1401 HOWTO (R_PPC64_DTPREL16_HA,
1402 16, /* rightshift */
1403 1, /* size (0 = byte, 1 = short, 2 = long) */
1405 FALSE, /* pc_relative */
1407 complain_overflow_signed, /* complain_on_overflow */
1408 ppc64_elf_unhandled_reloc, /* special_function */
1409 "R_PPC64_DTPREL16_HA", /* name */
1410 FALSE, /* partial_inplace */
1412 0xffff, /* dst_mask */
1413 FALSE), /* pcrel_offset */
1415 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1416 HOWTO (R_PPC64_DTPREL16_HIGHER,
1417 32, /* rightshift */
1418 1, /* size (0 = byte, 1 = short, 2 = long) */
1420 FALSE, /* pc_relative */
1422 complain_overflow_dont, /* complain_on_overflow */
1423 ppc64_elf_unhandled_reloc, /* special_function */
1424 "R_PPC64_DTPREL16_HIGHER", /* name */
1425 FALSE, /* partial_inplace */
1427 0xffff, /* dst_mask */
1428 FALSE), /* pcrel_offset */
1430 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1431 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1432 32, /* rightshift */
1433 1, /* size (0 = byte, 1 = short, 2 = long) */
1435 FALSE, /* pc_relative */
1437 complain_overflow_dont, /* complain_on_overflow */
1438 ppc64_elf_unhandled_reloc, /* special_function */
1439 "R_PPC64_DTPREL16_HIGHERA", /* name */
1440 FALSE, /* partial_inplace */
1442 0xffff, /* dst_mask */
1443 FALSE), /* pcrel_offset */
1445 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1446 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1447 48, /* rightshift */
1448 1, /* size (0 = byte, 1 = short, 2 = long) */
1450 FALSE, /* pc_relative */
1452 complain_overflow_dont, /* complain_on_overflow */
1453 ppc64_elf_unhandled_reloc, /* special_function */
1454 "R_PPC64_DTPREL16_HIGHEST", /* name */
1455 FALSE, /* partial_inplace */
1457 0xffff, /* dst_mask */
1458 FALSE), /* pcrel_offset */
1460 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1461 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1462 48, /* rightshift */
1463 1, /* size (0 = byte, 1 = short, 2 = long) */
1465 FALSE, /* pc_relative */
1467 complain_overflow_dont, /* complain_on_overflow */
1468 ppc64_elf_unhandled_reloc, /* special_function */
1469 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1470 FALSE, /* partial_inplace */
1472 0xffff, /* dst_mask */
1473 FALSE), /* pcrel_offset */
1475 /* Like DTPREL16, but for insns with a DS field. */
1476 HOWTO (R_PPC64_DTPREL16_DS,
1478 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 FALSE, /* pc_relative */
1482 complain_overflow_signed, /* complain_on_overflow */
1483 ppc64_elf_unhandled_reloc, /* special_function */
1484 "R_PPC64_DTPREL16_DS", /* name */
1485 FALSE, /* partial_inplace */
1487 0xfffc, /* dst_mask */
1488 FALSE), /* pcrel_offset */
1490 /* Like DTPREL16_DS, but no overflow. */
1491 HOWTO (R_PPC64_DTPREL16_LO_DS,
1493 1, /* size (0 = byte, 1 = short, 2 = long) */
1495 FALSE, /* pc_relative */
1497 complain_overflow_dont, /* complain_on_overflow */
1498 ppc64_elf_unhandled_reloc, /* special_function */
1499 "R_PPC64_DTPREL16_LO_DS", /* name */
1500 FALSE, /* partial_inplace */
1502 0xfffc, /* dst_mask */
1503 FALSE), /* pcrel_offset */
1505 /* Computes a tp-relative displacement, the difference between the value of
1506 sym+add and the value of the thread pointer (r13). */
1507 HOWTO (R_PPC64_TPREL64,
1509 4, /* size (0 = byte, 1 = short, 2 = long) */
1511 FALSE, /* pc_relative */
1513 complain_overflow_dont, /* complain_on_overflow */
1514 ppc64_elf_unhandled_reloc, /* special_function */
1515 "R_PPC64_TPREL64", /* name */
1516 FALSE, /* partial_inplace */
1518 ONES (64), /* dst_mask */
1519 FALSE), /* pcrel_offset */
1521 /* A 16 bit tprel reloc. */
1522 HOWTO (R_PPC64_TPREL16,
1524 1, /* size (0 = byte, 1 = short, 2 = long) */
1526 FALSE, /* pc_relative */
1528 complain_overflow_signed, /* complain_on_overflow */
1529 ppc64_elf_unhandled_reloc, /* special_function */
1530 "R_PPC64_TPREL16", /* name */
1531 FALSE, /* partial_inplace */
1533 0xffff, /* dst_mask */
1534 FALSE), /* pcrel_offset */
1536 /* Like TPREL16, but no overflow. */
1537 HOWTO (R_PPC64_TPREL16_LO,
1539 1, /* size (0 = byte, 1 = short, 2 = long) */
1541 FALSE, /* pc_relative */
1543 complain_overflow_dont, /* complain_on_overflow */
1544 ppc64_elf_unhandled_reloc, /* special_function */
1545 "R_PPC64_TPREL16_LO", /* name */
1546 FALSE, /* partial_inplace */
1548 0xffff, /* dst_mask */
1549 FALSE), /* pcrel_offset */
1551 /* Like TPREL16_LO, but next higher group of 16 bits. */
1552 HOWTO (R_PPC64_TPREL16_HI,
1553 16, /* rightshift */
1554 1, /* size (0 = byte, 1 = short, 2 = long) */
1556 FALSE, /* pc_relative */
1558 complain_overflow_signed, /* complain_on_overflow */
1559 ppc64_elf_unhandled_reloc, /* special_function */
1560 "R_PPC64_TPREL16_HI", /* name */
1561 FALSE, /* partial_inplace */
1563 0xffff, /* dst_mask */
1564 FALSE), /* pcrel_offset */
1566 /* Like TPREL16_HI, but adjust for low 16 bits. */
1567 HOWTO (R_PPC64_TPREL16_HA,
1568 16, /* rightshift */
1569 1, /* size (0 = byte, 1 = short, 2 = long) */
1571 FALSE, /* pc_relative */
1573 complain_overflow_signed, /* complain_on_overflow */
1574 ppc64_elf_unhandled_reloc, /* special_function */
1575 "R_PPC64_TPREL16_HA", /* name */
1576 FALSE, /* partial_inplace */
1578 0xffff, /* dst_mask */
1579 FALSE), /* pcrel_offset */
1581 /* Like TPREL16_HI, but next higher group of 16 bits. */
1582 HOWTO (R_PPC64_TPREL16_HIGHER,
1583 32, /* rightshift */
1584 1, /* size (0 = byte, 1 = short, 2 = long) */
1586 FALSE, /* pc_relative */
1588 complain_overflow_dont, /* complain_on_overflow */
1589 ppc64_elf_unhandled_reloc, /* special_function */
1590 "R_PPC64_TPREL16_HIGHER", /* name */
1591 FALSE, /* partial_inplace */
1593 0xffff, /* dst_mask */
1594 FALSE), /* pcrel_offset */
1596 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1597 HOWTO (R_PPC64_TPREL16_HIGHERA,
1598 32, /* rightshift */
1599 1, /* size (0 = byte, 1 = short, 2 = long) */
1601 FALSE, /* pc_relative */
1603 complain_overflow_dont, /* complain_on_overflow */
1604 ppc64_elf_unhandled_reloc, /* special_function */
1605 "R_PPC64_TPREL16_HIGHERA", /* name */
1606 FALSE, /* partial_inplace */
1608 0xffff, /* dst_mask */
1609 FALSE), /* pcrel_offset */
1611 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1612 HOWTO (R_PPC64_TPREL16_HIGHEST,
1613 48, /* rightshift */
1614 1, /* size (0 = byte, 1 = short, 2 = long) */
1616 FALSE, /* pc_relative */
1618 complain_overflow_dont, /* complain_on_overflow */
1619 ppc64_elf_unhandled_reloc, /* special_function */
1620 "R_PPC64_TPREL16_HIGHEST", /* name */
1621 FALSE, /* partial_inplace */
1623 0xffff, /* dst_mask */
1624 FALSE), /* pcrel_offset */
1626 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1627 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1628 48, /* rightshift */
1629 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 FALSE, /* pc_relative */
1633 complain_overflow_dont, /* complain_on_overflow */
1634 ppc64_elf_unhandled_reloc, /* special_function */
1635 "R_PPC64_TPREL16_HIGHESTA", /* name */
1636 FALSE, /* partial_inplace */
1638 0xffff, /* dst_mask */
1639 FALSE), /* pcrel_offset */
1641 /* Like TPREL16, but for insns with a DS field. */
1642 HOWTO (R_PPC64_TPREL16_DS,
1644 1, /* size (0 = byte, 1 = short, 2 = long) */
1646 FALSE, /* pc_relative */
1648 complain_overflow_signed, /* complain_on_overflow */
1649 ppc64_elf_unhandled_reloc, /* special_function */
1650 "R_PPC64_TPREL16_DS", /* name */
1651 FALSE, /* partial_inplace */
1653 0xfffc, /* dst_mask */
1654 FALSE), /* pcrel_offset */
1656 /* Like TPREL16_DS, but no overflow. */
1657 HOWTO (R_PPC64_TPREL16_LO_DS,
1659 1, /* size (0 = byte, 1 = short, 2 = long) */
1661 FALSE, /* pc_relative */
1663 complain_overflow_dont, /* complain_on_overflow */
1664 ppc64_elf_unhandled_reloc, /* special_function */
1665 "R_PPC64_TPREL16_LO_DS", /* name */
1666 FALSE, /* partial_inplace */
1668 0xfffc, /* dst_mask */
1669 FALSE), /* pcrel_offset */
1671 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1672 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1673 to the first entry relative to the TOC base (r2). */
1674 HOWTO (R_PPC64_GOT_TLSGD16,
1676 1, /* size (0 = byte, 1 = short, 2 = long) */
1678 FALSE, /* pc_relative */
1680 complain_overflow_signed, /* complain_on_overflow */
1681 ppc64_elf_unhandled_reloc, /* special_function */
1682 "R_PPC64_GOT_TLSGD16", /* name */
1683 FALSE, /* partial_inplace */
1685 0xffff, /* dst_mask */
1686 FALSE), /* pcrel_offset */
1688 /* Like GOT_TLSGD16, but no overflow. */
1689 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1691 1, /* size (0 = byte, 1 = short, 2 = long) */
1693 FALSE, /* pc_relative */
1695 complain_overflow_dont, /* complain_on_overflow */
1696 ppc64_elf_unhandled_reloc, /* special_function */
1697 "R_PPC64_GOT_TLSGD16_LO", /* name */
1698 FALSE, /* partial_inplace */
1700 0xffff, /* dst_mask */
1701 FALSE), /* pcrel_offset */
1703 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1704 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1705 16, /* rightshift */
1706 1, /* size (0 = byte, 1 = short, 2 = long) */
1708 FALSE, /* pc_relative */
1710 complain_overflow_signed, /* complain_on_overflow */
1711 ppc64_elf_unhandled_reloc, /* special_function */
1712 "R_PPC64_GOT_TLSGD16_HI", /* name */
1713 FALSE, /* partial_inplace */
1715 0xffff, /* dst_mask */
1716 FALSE), /* pcrel_offset */
1718 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1719 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1720 16, /* rightshift */
1721 1, /* size (0 = byte, 1 = short, 2 = long) */
1723 FALSE, /* pc_relative */
1725 complain_overflow_signed, /* complain_on_overflow */
1726 ppc64_elf_unhandled_reloc, /* special_function */
1727 "R_PPC64_GOT_TLSGD16_HA", /* name */
1728 FALSE, /* partial_inplace */
1730 0xffff, /* dst_mask */
1731 FALSE), /* pcrel_offset */
1733 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1734 with values (sym+add)@dtpmod and zero, and computes the offset to the
1735 first entry relative to the TOC base (r2). */
1736 HOWTO (R_PPC64_GOT_TLSLD16,
1738 1, /* size (0 = byte, 1 = short, 2 = long) */
1740 FALSE, /* pc_relative */
1742 complain_overflow_signed, /* complain_on_overflow */
1743 ppc64_elf_unhandled_reloc, /* special_function */
1744 "R_PPC64_GOT_TLSLD16", /* name */
1745 FALSE, /* partial_inplace */
1747 0xffff, /* dst_mask */
1748 FALSE), /* pcrel_offset */
1750 /* Like GOT_TLSLD16, but no overflow. */
1751 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1753 1, /* size (0 = byte, 1 = short, 2 = long) */
1755 FALSE, /* pc_relative */
1757 complain_overflow_dont, /* complain_on_overflow */
1758 ppc64_elf_unhandled_reloc, /* special_function */
1759 "R_PPC64_GOT_TLSLD16_LO", /* name */
1760 FALSE, /* partial_inplace */
1762 0xffff, /* dst_mask */
1763 FALSE), /* pcrel_offset */
1765 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1766 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1767 16, /* rightshift */
1768 1, /* size (0 = byte, 1 = short, 2 = long) */
1770 FALSE, /* pc_relative */
1772 complain_overflow_signed, /* complain_on_overflow */
1773 ppc64_elf_unhandled_reloc, /* special_function */
1774 "R_PPC64_GOT_TLSLD16_HI", /* name */
1775 FALSE, /* partial_inplace */
1777 0xffff, /* dst_mask */
1778 FALSE), /* pcrel_offset */
1780 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1781 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1782 16, /* rightshift */
1783 1, /* size (0 = byte, 1 = short, 2 = long) */
1785 FALSE, /* pc_relative */
1787 complain_overflow_signed, /* complain_on_overflow */
1788 ppc64_elf_unhandled_reloc, /* special_function */
1789 "R_PPC64_GOT_TLSLD16_HA", /* name */
1790 FALSE, /* partial_inplace */
1792 0xffff, /* dst_mask */
1793 FALSE), /* pcrel_offset */
1795 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1796 the offset to the entry relative to the TOC base (r2). */
1797 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1799 1, /* size (0 = byte, 1 = short, 2 = long) */
1801 FALSE, /* pc_relative */
1803 complain_overflow_signed, /* complain_on_overflow */
1804 ppc64_elf_unhandled_reloc, /* special_function */
1805 "R_PPC64_GOT_DTPREL16_DS", /* name */
1806 FALSE, /* partial_inplace */
1808 0xfffc, /* dst_mask */
1809 FALSE), /* pcrel_offset */
1811 /* Like GOT_DTPREL16_DS, but no overflow. */
1812 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1814 1, /* size (0 = byte, 1 = short, 2 = long) */
1816 FALSE, /* pc_relative */
1818 complain_overflow_dont, /* complain_on_overflow */
1819 ppc64_elf_unhandled_reloc, /* special_function */
1820 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1821 FALSE, /* partial_inplace */
1823 0xfffc, /* dst_mask */
1824 FALSE), /* pcrel_offset */
1826 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1827 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1828 16, /* rightshift */
1829 1, /* size (0 = byte, 1 = short, 2 = long) */
1831 FALSE, /* pc_relative */
1833 complain_overflow_signed, /* complain_on_overflow */
1834 ppc64_elf_unhandled_reloc, /* special_function */
1835 "R_PPC64_GOT_DTPREL16_HI", /* name */
1836 FALSE, /* partial_inplace */
1838 0xffff, /* dst_mask */
1839 FALSE), /* pcrel_offset */
1841 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1842 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1843 16, /* rightshift */
1844 1, /* size (0 = byte, 1 = short, 2 = long) */
1846 FALSE, /* pc_relative */
1848 complain_overflow_signed, /* complain_on_overflow */
1849 ppc64_elf_unhandled_reloc, /* special_function */
1850 "R_PPC64_GOT_DTPREL16_HA", /* name */
1851 FALSE, /* partial_inplace */
1853 0xffff, /* dst_mask */
1854 FALSE), /* pcrel_offset */
1856 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1857 offset to the entry relative to the TOC base (r2). */
1858 HOWTO (R_PPC64_GOT_TPREL16_DS,
1860 1, /* size (0 = byte, 1 = short, 2 = long) */
1862 FALSE, /* pc_relative */
1864 complain_overflow_signed, /* complain_on_overflow */
1865 ppc64_elf_unhandled_reloc, /* special_function */
1866 "R_PPC64_GOT_TPREL16_DS", /* name */
1867 FALSE, /* partial_inplace */
1869 0xfffc, /* dst_mask */
1870 FALSE), /* pcrel_offset */
1872 /* Like GOT_TPREL16_DS, but no overflow. */
1873 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1875 1, /* size (0 = byte, 1 = short, 2 = long) */
1877 FALSE, /* pc_relative */
1879 complain_overflow_dont, /* complain_on_overflow */
1880 ppc64_elf_unhandled_reloc, /* special_function */
1881 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1882 FALSE, /* partial_inplace */
1884 0xfffc, /* dst_mask */
1885 FALSE), /* pcrel_offset */
1887 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1888 HOWTO (R_PPC64_GOT_TPREL16_HI,
1889 16, /* rightshift */
1890 1, /* size (0 = byte, 1 = short, 2 = long) */
1892 FALSE, /* pc_relative */
1894 complain_overflow_signed, /* complain_on_overflow */
1895 ppc64_elf_unhandled_reloc, /* special_function */
1896 "R_PPC64_GOT_TPREL16_HI", /* name */
1897 FALSE, /* partial_inplace */
1899 0xffff, /* dst_mask */
1900 FALSE), /* pcrel_offset */
1902 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1903 HOWTO (R_PPC64_GOT_TPREL16_HA,
1904 16, /* rightshift */
1905 1, /* size (0 = byte, 1 = short, 2 = long) */
1907 FALSE, /* pc_relative */
1909 complain_overflow_signed, /* complain_on_overflow */
1910 ppc64_elf_unhandled_reloc, /* special_function */
1911 "R_PPC64_GOT_TPREL16_HA", /* name */
1912 FALSE, /* partial_inplace */
1914 0xffff, /* dst_mask */
1915 FALSE), /* pcrel_offset */
1917 HOWTO (R_PPC64_JMP_IREL, /* type */
1919 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1921 FALSE, /* pc_relative */
1923 complain_overflow_dont, /* complain_on_overflow */
1924 ppc64_elf_unhandled_reloc, /* special_function */
1925 "R_PPC64_JMP_IREL", /* name */
1926 FALSE, /* partial_inplace */
1929 FALSE), /* pcrel_offset */
1931 HOWTO (R_PPC64_IRELATIVE, /* type */
1933 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935 FALSE, /* pc_relative */
1937 complain_overflow_dont, /* complain_on_overflow */
1938 bfd_elf_generic_reloc, /* special_function */
1939 "R_PPC64_IRELATIVE", /* name */
1940 FALSE, /* partial_inplace */
1942 ONES (64), /* dst_mask */
1943 FALSE), /* pcrel_offset */
1945 /* A 16 bit relative relocation. */
1946 HOWTO (R_PPC64_REL16, /* type */
1948 1, /* size (0 = byte, 1 = short, 2 = long) */
1950 TRUE, /* pc_relative */
1952 complain_overflow_signed, /* complain_on_overflow */
1953 bfd_elf_generic_reloc, /* special_function */
1954 "R_PPC64_REL16", /* name */
1955 FALSE, /* partial_inplace */
1957 0xffff, /* dst_mask */
1958 TRUE), /* pcrel_offset */
1960 /* A 16 bit relative relocation without overflow. */
1961 HOWTO (R_PPC64_REL16_LO, /* type */
1963 1, /* size (0 = byte, 1 = short, 2 = long) */
1965 TRUE, /* pc_relative */
1967 complain_overflow_dont,/* complain_on_overflow */
1968 bfd_elf_generic_reloc, /* special_function */
1969 "R_PPC64_REL16_LO", /* name */
1970 FALSE, /* partial_inplace */
1972 0xffff, /* dst_mask */
1973 TRUE), /* pcrel_offset */
1975 /* The high order 16 bits of a relative address. */
1976 HOWTO (R_PPC64_REL16_HI, /* type */
1977 16, /* rightshift */
1978 1, /* size (0 = byte, 1 = short, 2 = long) */
1980 TRUE, /* pc_relative */
1982 complain_overflow_signed, /* complain_on_overflow */
1983 bfd_elf_generic_reloc, /* special_function */
1984 "R_PPC64_REL16_HI", /* name */
1985 FALSE, /* partial_inplace */
1987 0xffff, /* dst_mask */
1988 TRUE), /* pcrel_offset */
1990 /* The high order 16 bits of a relative address, plus 1 if the contents of
1991 the low 16 bits, treated as a signed number, is negative. */
1992 HOWTO (R_PPC64_REL16_HA, /* type */
1993 16, /* rightshift */
1994 1, /* size (0 = byte, 1 = short, 2 = long) */
1996 TRUE, /* pc_relative */
1998 complain_overflow_signed, /* complain_on_overflow */
1999 ppc64_elf_ha_reloc, /* special_function */
2000 "R_PPC64_REL16_HA", /* name */
2001 FALSE, /* partial_inplace */
2003 0xffff, /* dst_mask */
2004 TRUE), /* pcrel_offset */
2006 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2007 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2008 16, /* rightshift */
2009 1, /* size (0 = byte, 1 = short, 2 = long) */
2011 FALSE, /* pc_relative */
2013 complain_overflow_dont, /* complain_on_overflow */
2014 bfd_elf_generic_reloc, /* special_function */
2015 "R_PPC64_ADDR16_HIGH", /* name */
2016 FALSE, /* partial_inplace */
2018 0xffff, /* dst_mask */
2019 FALSE), /* pcrel_offset */
2021 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2022 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2023 16, /* rightshift */
2024 1, /* size (0 = byte, 1 = short, 2 = long) */
2026 FALSE, /* pc_relative */
2028 complain_overflow_dont, /* complain_on_overflow */
2029 ppc64_elf_ha_reloc, /* special_function */
2030 "R_PPC64_ADDR16_HIGHA", /* name */
2031 FALSE, /* partial_inplace */
2033 0xffff, /* dst_mask */
2034 FALSE), /* pcrel_offset */
2036 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2037 HOWTO (R_PPC64_DTPREL16_HIGH,
2038 16, /* rightshift */
2039 1, /* size (0 = byte, 1 = short, 2 = long) */
2041 FALSE, /* pc_relative */
2043 complain_overflow_dont, /* complain_on_overflow */
2044 ppc64_elf_unhandled_reloc, /* special_function */
2045 "R_PPC64_DTPREL16_HIGH", /* name */
2046 FALSE, /* partial_inplace */
2048 0xffff, /* dst_mask */
2049 FALSE), /* pcrel_offset */
2051 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2052 HOWTO (R_PPC64_DTPREL16_HIGHA,
2053 16, /* rightshift */
2054 1, /* size (0 = byte, 1 = short, 2 = long) */
2056 FALSE, /* pc_relative */
2058 complain_overflow_dont, /* complain_on_overflow */
2059 ppc64_elf_unhandled_reloc, /* special_function */
2060 "R_PPC64_DTPREL16_HIGHA", /* name */
2061 FALSE, /* partial_inplace */
2063 0xffff, /* dst_mask */
2064 FALSE), /* pcrel_offset */
2066 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2067 HOWTO (R_PPC64_TPREL16_HIGH,
2068 16, /* rightshift */
2069 1, /* size (0 = byte, 1 = short, 2 = long) */
2071 FALSE, /* pc_relative */
2073 complain_overflow_dont, /* complain_on_overflow */
2074 ppc64_elf_unhandled_reloc, /* special_function */
2075 "R_PPC64_TPREL16_HIGH", /* name */
2076 FALSE, /* partial_inplace */
2078 0xffff, /* dst_mask */
2079 FALSE), /* pcrel_offset */
2081 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2082 HOWTO (R_PPC64_TPREL16_HIGHA,
2083 16, /* rightshift */
2084 1, /* size (0 = byte, 1 = short, 2 = long) */
2086 FALSE, /* pc_relative */
2088 complain_overflow_dont, /* complain_on_overflow */
2089 ppc64_elf_unhandled_reloc, /* special_function */
2090 "R_PPC64_TPREL16_HIGHA", /* name */
2091 FALSE, /* partial_inplace */
2093 0xffff, /* dst_mask */
2094 FALSE), /* pcrel_offset */
2096 /* Like ADDR64, but use local entry point of function. */
2097 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2099 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2101 FALSE, /* pc_relative */
2103 complain_overflow_dont, /* complain_on_overflow */
2104 bfd_elf_generic_reloc, /* special_function */
2105 "R_PPC64_ADDR64_LOCAL", /* name */
2106 FALSE, /* partial_inplace */
2108 ONES (64), /* dst_mask */
2109 FALSE), /* pcrel_offset */
2111 /* GNU extension to record C++ vtable hierarchy. */
2112 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2114 0, /* size (0 = byte, 1 = short, 2 = long) */
2116 FALSE, /* pc_relative */
2118 complain_overflow_dont, /* complain_on_overflow */
2119 NULL, /* special_function */
2120 "R_PPC64_GNU_VTINHERIT", /* name */
2121 FALSE, /* partial_inplace */
2124 FALSE), /* pcrel_offset */
2126 /* GNU extension to record C++ vtable member usage. */
2127 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2129 0, /* size (0 = byte, 1 = short, 2 = long) */
2131 FALSE, /* pc_relative */
2133 complain_overflow_dont, /* complain_on_overflow */
2134 NULL, /* special_function */
2135 "R_PPC64_GNU_VTENTRY", /* name */
2136 FALSE, /* partial_inplace */
2139 FALSE), /* pcrel_offset */
2143 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2147 ppc_howto_init (void)
2149 unsigned int i, type;
2152 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2155 type = ppc64_elf_howto_raw[i].type;
2156 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2157 / sizeof (ppc64_elf_howto_table[0])));
2158 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2162 static reloc_howto_type *
2163 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2164 bfd_reloc_code_real_type code)
2166 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2168 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2169 /* Initialize howto table if needed. */
2177 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2179 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2181 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2183 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2185 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2187 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2189 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2191 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2193 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2195 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2197 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2199 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2201 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2203 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2205 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2207 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2209 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2211 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2213 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2215 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2217 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2219 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2221 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2223 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2225 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2227 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2229 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2231 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2233 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2235 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2237 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2239 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2241 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2243 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2245 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2247 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2249 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2251 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2253 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2255 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2257 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2259 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2261 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2263 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2265 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2267 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2269 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2271 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2273 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2275 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2277 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2279 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2281 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2283 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2285 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2287 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2289 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2291 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2293 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2295 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2297 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2299 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2301 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2303 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2305 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2307 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2309 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2311 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2313 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2315 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2317 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2319 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2321 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2323 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2325 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2327 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2329 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2331 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2333 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2335 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2337 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2339 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2341 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2343 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2345 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2347 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2349 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2351 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2353 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2355 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2357 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2359 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2361 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2363 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2365 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2367 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2369 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2371 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2373 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2375 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2377 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2379 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2381 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2383 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2385 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2387 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2389 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2391 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2393 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2395 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2397 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2399 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2401 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2403 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2407 return ppc64_elf_howto_table[r];
2410 static reloc_howto_type *
2411 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2417 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2419 if (ppc64_elf_howto_raw[i].name != NULL
2420 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2421 return &ppc64_elf_howto_raw[i];
2426 /* Set the howto pointer for a PowerPC ELF reloc. */
2429 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2430 Elf_Internal_Rela *dst)
2434 /* Initialize howto table if needed. */
2435 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2438 type = ELF64_R_TYPE (dst->r_info);
2439 if (type >= (sizeof (ppc64_elf_howto_table)
2440 / sizeof (ppc64_elf_howto_table[0])))
2442 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2444 type = R_PPC64_NONE;
2446 cache_ptr->howto = ppc64_elf_howto_table[type];
2449 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2451 static bfd_reloc_status_type
2452 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2453 void *data, asection *input_section,
2454 bfd *output_bfd, char **error_message)
2456 /* If this is a relocatable link (output_bfd test tells us), just
2457 call the generic function. Any adjustment will be done at final
2459 if (output_bfd != NULL)
2460 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2461 input_section, output_bfd, error_message);
2463 /* Adjust the addend for sign extension of the low 16 bits.
2464 We won't actually be using the low 16 bits, so trashing them
2466 reloc_entry->addend += 0x8000;
2467 return bfd_reloc_continue;
2470 static bfd_reloc_status_type
2471 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2472 void *data, asection *input_section,
2473 bfd *output_bfd, char **error_message)
2475 if (output_bfd != NULL)
2476 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2477 input_section, output_bfd, error_message);
2479 if (strcmp (symbol->section->name, ".opd") == 0
2480 && (symbol->section->owner->flags & DYNAMIC) == 0)
2482 bfd_vma dest = opd_entry_value (symbol->section,
2483 symbol->value + reloc_entry->addend,
2485 if (dest != (bfd_vma) -1)
2486 reloc_entry->addend = dest - (symbol->value
2487 + symbol->section->output_section->vma
2488 + symbol->section->output_offset);
2490 return bfd_reloc_continue;
2493 static bfd_reloc_status_type
2494 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2495 void *data, asection *input_section,
2496 bfd *output_bfd, char **error_message)
2499 enum elf_ppc64_reloc_type r_type;
2500 bfd_size_type octets;
2501 /* Assume 'at' branch hints. */
2502 bfd_boolean is_isa_v2 = TRUE;
2504 /* If this is a relocatable link (output_bfd test tells us), just
2505 call the generic function. Any adjustment will be done at final
2507 if (output_bfd != NULL)
2508 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2509 input_section, output_bfd, error_message);
2511 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2512 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2513 insn &= ~(0x01 << 21);
2514 r_type = reloc_entry->howto->type;
2515 if (r_type == R_PPC64_ADDR14_BRTAKEN
2516 || r_type == R_PPC64_REL14_BRTAKEN)
2517 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2521 /* Set 'a' bit. This is 0b00010 in BO field for branch
2522 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2523 for branch on CTR insns (BO == 1a00t or 1a01t). */
2524 if ((insn & (0x14 << 21)) == (0x04 << 21))
2526 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2536 if (!bfd_is_com_section (symbol->section))
2537 target = symbol->value;
2538 target += symbol->section->output_section->vma;
2539 target += symbol->section->output_offset;
2540 target += reloc_entry->addend;
2542 from = (reloc_entry->address
2543 + input_section->output_offset
2544 + input_section->output_section->vma);
2546 /* Invert 'y' bit if not the default. */
2547 if ((bfd_signed_vma) (target - from) < 0)
2550 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2552 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2553 input_section, output_bfd, error_message);
2556 static bfd_reloc_status_type
2557 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2558 void *data, asection *input_section,
2559 bfd *output_bfd, char **error_message)
2561 /* If this is a relocatable link (output_bfd test tells us), just
2562 call the generic function. Any adjustment will be done at final
2564 if (output_bfd != NULL)
2565 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2566 input_section, output_bfd, error_message);
2568 /* Subtract the symbol section base address. */
2569 reloc_entry->addend -= symbol->section->output_section->vma;
2570 return bfd_reloc_continue;
2573 static bfd_reloc_status_type
2574 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575 void *data, asection *input_section,
2576 bfd *output_bfd, char **error_message)
2578 /* If this is a relocatable link (output_bfd test tells us), just
2579 call the generic function. Any adjustment will be done at final
2581 if (output_bfd != NULL)
2582 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2583 input_section, output_bfd, error_message);
2585 /* Subtract the symbol section base address. */
2586 reloc_entry->addend -= symbol->section->output_section->vma;
2588 /* Adjust the addend for sign extension of the low 16 bits. */
2589 reloc_entry->addend += 0x8000;
2590 return bfd_reloc_continue;
2593 static bfd_reloc_status_type
2594 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2595 void *data, asection *input_section,
2596 bfd *output_bfd, char **error_message)
2600 /* If this is a relocatable link (output_bfd test tells us), just
2601 call the generic function. Any adjustment will be done at final
2603 if (output_bfd != NULL)
2604 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2605 input_section, output_bfd, error_message);
2607 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2609 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2611 /* Subtract the TOC base address. */
2612 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2613 return bfd_reloc_continue;
2616 static bfd_reloc_status_type
2617 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2618 void *data, asection *input_section,
2619 bfd *output_bfd, char **error_message)
2623 /* If this is a relocatable link (output_bfd test tells us), just
2624 call the generic function. Any adjustment will be done at final
2626 if (output_bfd != NULL)
2627 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2628 input_section, output_bfd, error_message);
2630 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2632 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2634 /* Subtract the TOC base address. */
2635 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2637 /* Adjust the addend for sign extension of the low 16 bits. */
2638 reloc_entry->addend += 0x8000;
2639 return bfd_reloc_continue;
2642 static bfd_reloc_status_type
2643 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2644 void *data, asection *input_section,
2645 bfd *output_bfd, char **error_message)
2648 bfd_size_type octets;
2650 /* If this is a relocatable link (output_bfd test tells us), just
2651 call the generic function. Any adjustment will be done at final
2653 if (output_bfd != NULL)
2654 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2655 input_section, output_bfd, error_message);
2657 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2659 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2661 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2662 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2663 return bfd_reloc_ok;
2666 static bfd_reloc_status_type
2667 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2668 void *data, asection *input_section,
2669 bfd *output_bfd, char **error_message)
2671 /* If this is a relocatable link (output_bfd test tells us), just
2672 call the generic function. Any adjustment will be done at final
2674 if (output_bfd != NULL)
2675 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2676 input_section, output_bfd, error_message);
2678 if (error_message != NULL)
2680 static char buf[60];
2681 sprintf (buf, "generic linker can't handle %s",
2682 reloc_entry->howto->name);
2683 *error_message = buf;
2685 return bfd_reloc_dangerous;
2688 /* Track GOT entries needed for a given symbol. We might need more
2689 than one got entry per symbol. */
2692 struct got_entry *next;
2694 /* The symbol addend that we'll be placing in the GOT. */
2697 /* Unlike other ELF targets, we use separate GOT entries for the same
2698 symbol referenced from different input files. This is to support
2699 automatic multiple TOC/GOT sections, where the TOC base can vary
2700 from one input file to another. After partitioning into TOC groups
2701 we merge entries within the group.
2703 Point to the BFD owning this GOT entry. */
2706 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2707 TLS_TPREL or TLS_DTPREL for tls entries. */
2708 unsigned char tls_type;
2710 /* Non-zero if got.ent points to real entry. */
2711 unsigned char is_indirect;
2713 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2716 bfd_signed_vma refcount;
2718 struct got_entry *ent;
2722 /* The same for PLT. */
2725 struct plt_entry *next;
2731 bfd_signed_vma refcount;
2736 struct ppc64_elf_obj_tdata
2738 struct elf_obj_tdata elf;
2740 /* Shortcuts to dynamic linker sections. */
2744 /* Used during garbage collection. We attach global symbols defined
2745 on removed .opd entries to this section so that the sym is removed. */
2746 asection *deleted_section;
2748 /* TLS local dynamic got entry handling. Support for multiple GOT
2749 sections means we potentially need one of these for each input bfd. */
2750 struct got_entry tlsld_got;
2753 /* A copy of relocs before they are modified for --emit-relocs. */
2754 Elf_Internal_Rela *relocs;
2756 /* Section contents. */
2760 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2761 the reloc to be in the range -32768 to 32767. */
2762 unsigned int has_small_toc_reloc : 1;
2764 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2765 instruction not one we handle. */
2766 unsigned int unexpected_toc_insn : 1;
2769 #define ppc64_elf_tdata(bfd) \
2770 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2772 #define ppc64_tlsld_got(bfd) \
2773 (&ppc64_elf_tdata (bfd)->tlsld_got)
2775 #define is_ppc64_elf(bfd) \
2776 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2777 && elf_object_id (bfd) == PPC64_ELF_DATA)
2779 /* Override the generic function because we store some extras. */
2782 ppc64_elf_mkobject (bfd *abfd)
2784 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2788 /* Fix bad default arch selected for a 64 bit input bfd when the
2789 default is 32 bit. */
2792 ppc64_elf_object_p (bfd *abfd)
2794 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2796 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2798 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2800 /* Relies on arch after 32 bit default being 64 bit default. */
2801 abfd->arch_info = abfd->arch_info->next;
2802 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2808 /* Support for core dump NOTE sections. */
2811 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2813 size_t offset, size;
2815 if (note->descsz != 504)
2819 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2822 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2828 /* Make a ".reg/999" section. */
2829 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2830 size, note->descpos + offset);
2834 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2836 if (note->descsz != 136)
2839 elf_tdata (abfd)->core->pid
2840 = bfd_get_32 (abfd, note->descdata + 24);
2841 elf_tdata (abfd)->core->program
2842 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2843 elf_tdata (abfd)->core->command
2844 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2850 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2863 va_start (ap, note_type);
2864 memset (data, 0, sizeof (data));
2865 strncpy (data + 40, va_arg (ap, const char *), 16);
2866 strncpy (data + 56, va_arg (ap, const char *), 80);
2868 return elfcore_write_note (abfd, buf, bufsiz,
2869 "CORE", note_type, data, sizeof (data));
2880 va_start (ap, note_type);
2881 memset (data, 0, 112);
2882 pid = va_arg (ap, long);
2883 bfd_put_32 (abfd, pid, data + 32);
2884 cursig = va_arg (ap, int);
2885 bfd_put_16 (abfd, cursig, data + 12);
2886 greg = va_arg (ap, const void *);
2887 memcpy (data + 112, greg, 384);
2888 memset (data + 496, 0, 8);
2890 return elfcore_write_note (abfd, buf, bufsiz,
2891 "CORE", note_type, data, sizeof (data));
2896 /* Add extra PPC sections. */
2898 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2900 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2901 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2902 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2903 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2906 { NULL, 0, 0, 0, 0 }
2909 enum _ppc64_sec_type {
2915 struct _ppc64_elf_section_data
2917 struct bfd_elf_section_data elf;
2921 /* An array with one entry for each opd function descriptor. */
2922 struct _opd_sec_data
2924 /* Points to the function code section for local opd entries. */
2925 asection **func_sec;
2927 /* After editing .opd, adjust references to opd local syms. */
2931 /* An array for toc sections, indexed by offset/8. */
2932 struct _toc_sec_data
2934 /* Specifies the relocation symbol index used at a given toc offset. */
2937 /* And the relocation addend. */
2942 enum _ppc64_sec_type sec_type:2;
2944 /* Flag set when small branches are detected. Used to
2945 select suitable defaults for the stub group size. */
2946 unsigned int has_14bit_branch:1;
2949 #define ppc64_elf_section_data(sec) \
2950 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2953 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2955 if (!sec->used_by_bfd)
2957 struct _ppc64_elf_section_data *sdata;
2958 bfd_size_type amt = sizeof (*sdata);
2960 sdata = bfd_zalloc (abfd, amt);
2963 sec->used_by_bfd = sdata;
2966 return _bfd_elf_new_section_hook (abfd, sec);
2969 static struct _opd_sec_data *
2970 get_opd_info (asection * sec)
2973 && ppc64_elf_section_data (sec) != NULL
2974 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2975 return &ppc64_elf_section_data (sec)->u.opd;
2980 abiversion (bfd *abfd)
2982 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2986 set_abiversion (bfd *abfd, int ver)
2988 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2989 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2992 /* Parameters for the qsort hook. */
2993 static bfd_boolean synthetic_relocatable;
2995 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2998 compare_symbols (const void *ap, const void *bp)
3000 const asymbol *a = * (const asymbol **) ap;
3001 const asymbol *b = * (const asymbol **) bp;
3003 /* Section symbols first. */
3004 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3006 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3009 /* then .opd symbols. */
3010 if (strcmp (a->section->name, ".opd") == 0
3011 && strcmp (b->section->name, ".opd") != 0)
3013 if (strcmp (a->section->name, ".opd") != 0
3014 && strcmp (b->section->name, ".opd") == 0)
3017 /* then other code symbols. */
3018 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3019 == (SEC_CODE | SEC_ALLOC)
3020 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3021 != (SEC_CODE | SEC_ALLOC))
3024 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3025 != (SEC_CODE | SEC_ALLOC)
3026 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3027 == (SEC_CODE | SEC_ALLOC))
3030 if (synthetic_relocatable)
3032 if (a->section->id < b->section->id)
3035 if (a->section->id > b->section->id)
3039 if (a->value + a->section->vma < b->value + b->section->vma)
3042 if (a->value + a->section->vma > b->value + b->section->vma)
3045 /* For syms with the same value, prefer strong dynamic global function
3046 syms over other syms. */
3047 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3050 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3053 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3056 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3059 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3062 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3065 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3068 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3074 /* Search SYMS for a symbol of the given VALUE. */
3077 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3085 mid = (lo + hi) >> 1;
3086 if (syms[mid]->value + syms[mid]->section->vma < value)
3088 else if (syms[mid]->value + syms[mid]->section->vma > value)
3098 mid = (lo + hi) >> 1;
3099 if (syms[mid]->section->id < id)
3101 else if (syms[mid]->section->id > id)
3103 else if (syms[mid]->value < value)
3105 else if (syms[mid]->value > value)
3115 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3117 bfd_vma vma = *(bfd_vma *) ptr;
3118 return ((section->flags & SEC_ALLOC) != 0
3119 && section->vma <= vma
3120 && vma < section->vma + section->size);
3123 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3124 entry syms. Also generate @plt symbols for the glink branch table. */
3127 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3128 long static_count, asymbol **static_syms,
3129 long dyn_count, asymbol **dyn_syms,
3136 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3137 asection *opd = NULL;
3138 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3140 int abi = abiversion (abfd);
3146 opd = bfd_get_section_by_name (abfd, ".opd");
3147 if (opd == NULL && abi == 1)
3151 symcount = static_count;
3153 symcount += dyn_count;
3157 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3161 if (!relocatable && static_count != 0 && dyn_count != 0)
3163 /* Use both symbol tables. */
3164 memcpy (syms, static_syms, static_count * sizeof (*syms));
3165 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3167 else if (!relocatable && static_count == 0)
3168 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3170 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3172 synthetic_relocatable = relocatable;
3173 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3175 if (!relocatable && symcount > 1)
3178 /* Trim duplicate syms, since we may have merged the normal and
3179 dynamic symbols. Actually, we only care about syms that have
3180 different values, so trim any with the same value. */
3181 for (i = 1, j = 1; i < symcount; ++i)
3182 if (syms[i - 1]->value + syms[i - 1]->section->vma
3183 != syms[i]->value + syms[i]->section->vma)
3184 syms[j++] = syms[i];
3189 if (strcmp (syms[i]->section->name, ".opd") == 0)
3193 for (; i < symcount; ++i)
3194 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3195 != (SEC_CODE | SEC_ALLOC))
3196 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3200 for (; i < symcount; ++i)
3201 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3205 for (; i < symcount; ++i)
3206 if (strcmp (syms[i]->section->name, ".opd") != 0)
3210 for (; i < symcount; ++i)
3211 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3212 != (SEC_CODE | SEC_ALLOC))
3220 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3225 if (opdsymend == secsymend)
3228 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3229 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3233 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3240 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3244 while (r < opd->relocation + relcount
3245 && r->address < syms[i]->value + opd->vma)
3248 if (r == opd->relocation + relcount)
3251 if (r->address != syms[i]->value + opd->vma)
3254 if (r->howto->type != R_PPC64_ADDR64)
3257 sym = *r->sym_ptr_ptr;
3258 if (!sym_exists_at (syms, opdsymend, symcount,
3259 sym->section->id, sym->value + r->addend))
3262 size += sizeof (asymbol);
3263 size += strlen (syms[i]->name) + 2;
3267 s = *ret = bfd_malloc (size);
3274 names = (char *) (s + count);
3276 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3280 while (r < opd->relocation + relcount
3281 && r->address < syms[i]->value + opd->vma)
3284 if (r == opd->relocation + relcount)
3287 if (r->address != syms[i]->value + opd->vma)
3290 if (r->howto->type != R_PPC64_ADDR64)
3293 sym = *r->sym_ptr_ptr;
3294 if (!sym_exists_at (syms, opdsymend, symcount,
3295 sym->section->id, sym->value + r->addend))
3300 s->flags |= BSF_SYNTHETIC;
3301 s->section = sym->section;
3302 s->value = sym->value + r->addend;
3305 len = strlen (syms[i]->name);
3306 memcpy (names, syms[i]->name, len + 1);
3308 /* Have udata.p point back to the original symbol this
3309 synthetic symbol was derived from. */
3310 s->udata.p = syms[i];
3317 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3318 bfd_byte *contents = NULL;
3321 bfd_vma glink_vma = 0, resolv_vma = 0;
3322 asection *dynamic, *glink = NULL, *relplt = NULL;
3325 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3327 free_contents_and_exit:
3335 for (i = secsymend; i < opdsymend; ++i)
3339 /* Ignore bogus symbols. */
3340 if (syms[i]->value > opd->size - 8)
3343 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3344 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3347 size += sizeof (asymbol);
3348 size += strlen (syms[i]->name) + 2;
3352 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3354 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3356 bfd_byte *dynbuf, *extdyn, *extdynend;
3358 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3360 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3361 goto free_contents_and_exit;
3363 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3364 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3367 extdynend = extdyn + dynamic->size;
3368 for (; extdyn < extdynend; extdyn += extdynsize)
3370 Elf_Internal_Dyn dyn;
3371 (*swap_dyn_in) (abfd, extdyn, &dyn);
3373 if (dyn.d_tag == DT_NULL)
3376 if (dyn.d_tag == DT_PPC64_GLINK)
3378 /* The first glink stub starts at offset 32; see
3379 comment in ppc64_elf_finish_dynamic_sections. */
3380 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3381 /* The .glink section usually does not survive the final
3382 link; search for the section (usually .text) where the
3383 glink stubs now reside. */
3384 glink = bfd_sections_find_if (abfd, section_covers_vma,
3395 /* Determine __glink trampoline by reading the relative branch
3396 from the first glink stub. */
3398 unsigned int off = 0;
3400 while (bfd_get_section_contents (abfd, glink, buf,
3401 glink_vma + off - glink->vma, 4))
3403 unsigned int insn = bfd_get_32 (abfd, buf);
3405 if ((insn & ~0x3fffffc) == 0)
3407 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3416 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3418 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3421 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3422 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3423 goto free_contents_and_exit;
3425 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3426 size += plt_count * sizeof (asymbol);
3428 p = relplt->relocation;
3429 for (i = 0; i < plt_count; i++, p++)
3431 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3433 size += sizeof ("+0x") - 1 + 16;
3438 s = *ret = bfd_malloc (size);
3440 goto free_contents_and_exit;
3442 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3444 for (i = secsymend; i < opdsymend; ++i)
3448 if (syms[i]->value > opd->size - 8)
3451 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3456 asection *sec = abfd->sections;
3463 long mid = (lo + hi) >> 1;
3464 if (syms[mid]->section->vma < ent)
3466 else if (syms[mid]->section->vma > ent)
3470 sec = syms[mid]->section;
3475 if (lo >= hi && lo > codesecsym)
3476 sec = syms[lo - 1]->section;
3478 for (; sec != NULL; sec = sec->next)
3482 /* SEC_LOAD may not be set if SEC is from a separate debug
3484 if ((sec->flags & SEC_ALLOC) == 0)
3486 if ((sec->flags & SEC_CODE) != 0)
3489 s->flags |= BSF_SYNTHETIC;
3490 s->value = ent - s->section->vma;
3493 len = strlen (syms[i]->name);
3494 memcpy (names, syms[i]->name, len + 1);
3496 /* Have udata.p point back to the original symbol this
3497 synthetic symbol was derived from. */
3498 s->udata.p = syms[i];
3504 if (glink != NULL && relplt != NULL)
3508 /* Add a symbol for the main glink trampoline. */
3509 memset (s, 0, sizeof *s);
3511 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3513 s->value = resolv_vma - glink->vma;
3515 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3516 names += sizeof ("__glink_PLTresolve");
3521 /* FIXME: It would be very much nicer to put sym@plt on the
3522 stub rather than on the glink branch table entry. The
3523 objdump disassembler would then use a sensible symbol
3524 name on plt calls. The difficulty in doing so is
3525 a) finding the stubs, and,
3526 b) matching stubs against plt entries, and,
3527 c) there can be multiple stubs for a given plt entry.
3529 Solving (a) could be done by code scanning, but older
3530 ppc64 binaries used different stubs to current code.
3531 (b) is the tricky one since you need to known the toc
3532 pointer for at least one function that uses a pic stub to
3533 be able to calculate the plt address referenced.
3534 (c) means gdb would need to set multiple breakpoints (or
3535 find the glink branch itself) when setting breakpoints
3536 for pending shared library loads. */
3537 p = relplt->relocation;
3538 for (i = 0; i < plt_count; i++, p++)
3542 *s = **p->sym_ptr_ptr;
3543 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3544 we are defining a symbol, ensure one of them is set. */
3545 if ((s->flags & BSF_LOCAL) == 0)
3546 s->flags |= BSF_GLOBAL;
3547 s->flags |= BSF_SYNTHETIC;
3549 s->value = glink_vma - glink->vma;
3552 len = strlen ((*p->sym_ptr_ptr)->name);
3553 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3557 memcpy (names, "+0x", sizeof ("+0x") - 1);
3558 names += sizeof ("+0x") - 1;
3559 bfd_sprintf_vma (abfd, names, p->addend);
3560 names += strlen (names);
3562 memcpy (names, "@plt", sizeof ("@plt"));
3563 names += sizeof ("@plt");
3583 /* The following functions are specific to the ELF linker, while
3584 functions above are used generally. Those named ppc64_elf_* are
3585 called by the main ELF linker code. They appear in this file more
3586 or less in the order in which they are called. eg.
3587 ppc64_elf_check_relocs is called early in the link process,
3588 ppc64_elf_finish_dynamic_sections is one of the last functions
3591 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3592 functions have both a function code symbol and a function descriptor
3593 symbol. A call to foo in a relocatable object file looks like:
3600 The function definition in another object file might be:
3604 . .quad .TOC.@tocbase
3610 When the linker resolves the call during a static link, the branch
3611 unsurprisingly just goes to .foo and the .opd information is unused.
3612 If the function definition is in a shared library, things are a little
3613 different: The call goes via a plt call stub, the opd information gets
3614 copied to the plt, and the linker patches the nop.
3622 . std 2,40(1) # in practice, the call stub
3623 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3624 . addi 11,11,Lfoo@toc@l # this is the general idea
3632 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3634 The "reloc ()" notation is supposed to indicate that the linker emits
3635 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3638 What are the difficulties here? Well, firstly, the relocations
3639 examined by the linker in check_relocs are against the function code
3640 sym .foo, while the dynamic relocation in the plt is emitted against
3641 the function descriptor symbol, foo. Somewhere along the line, we need
3642 to carefully copy dynamic link information from one symbol to the other.
3643 Secondly, the generic part of the elf linker will make .foo a dynamic
3644 symbol as is normal for most other backends. We need foo dynamic
3645 instead, at least for an application final link. However, when
3646 creating a shared library containing foo, we need to have both symbols
3647 dynamic so that references to .foo are satisfied during the early
3648 stages of linking. Otherwise the linker might decide to pull in a
3649 definition from some other object, eg. a static library.
3651 Update: As of August 2004, we support a new convention. Function
3652 calls may use the function descriptor symbol, ie. "bl foo". This
3653 behaves exactly as "bl .foo". */
3655 /* Of those relocs that might be copied as dynamic relocs, this function
3656 selects those that must be copied when linking a shared library,
3657 even when the symbol is local. */
3660 must_be_dyn_reloc (struct bfd_link_info *info,
3661 enum elf_ppc64_reloc_type r_type)
3673 case R_PPC64_TPREL16:
3674 case R_PPC64_TPREL16_LO:
3675 case R_PPC64_TPREL16_HI:
3676 case R_PPC64_TPREL16_HA:
3677 case R_PPC64_TPREL16_DS:
3678 case R_PPC64_TPREL16_LO_DS:
3679 case R_PPC64_TPREL16_HIGH:
3680 case R_PPC64_TPREL16_HIGHA:
3681 case R_PPC64_TPREL16_HIGHER:
3682 case R_PPC64_TPREL16_HIGHERA:
3683 case R_PPC64_TPREL16_HIGHEST:
3684 case R_PPC64_TPREL16_HIGHESTA:
3685 case R_PPC64_TPREL64:
3686 return !info->executable;
3690 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3691 copying dynamic variables from a shared lib into an app's dynbss
3692 section, and instead use a dynamic relocation to point into the
3693 shared lib. With code that gcc generates, it's vital that this be
3694 enabled; In the PowerPC64 ABI, the address of a function is actually
3695 the address of a function descriptor, which resides in the .opd
3696 section. gcc uses the descriptor directly rather than going via the
3697 GOT as some other ABI's do, which means that initialized function
3698 pointers must reference the descriptor. Thus, a function pointer
3699 initialized to the address of a function in a shared library will
3700 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3701 redefines the function descriptor symbol to point to the copy. This
3702 presents a problem as a plt entry for that function is also
3703 initialized from the function descriptor symbol and the copy reloc
3704 may not be initialized first. */
3705 #define ELIMINATE_COPY_RELOCS 1
3707 /* Section name for stubs is the associated section name plus this
3709 #define STUB_SUFFIX ".stub"
3712 ppc_stub_long_branch:
3713 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3714 destination, but a 24 bit branch in a stub section will reach.
3717 ppc_stub_plt_branch:
3718 Similar to the above, but a 24 bit branch in the stub section won't
3719 reach its destination.
3720 . addis %r11,%r2,xxx@toc@ha
3721 . ld %r12,xxx@toc@l(%r11)
3726 Used to call a function in a shared library. If it so happens that
3727 the plt entry referenced crosses a 64k boundary, then an extra
3728 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3730 . addis %r11,%r2,xxx@toc@ha
3731 . ld %r12,xxx+0@toc@l(%r11)
3733 . ld %r2,xxx+8@toc@l(%r11)
3734 . ld %r11,xxx+16@toc@l(%r11)
3737 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3738 code to adjust the value and save r2 to support multiple toc sections.
3739 A ppc_stub_long_branch with an r2 offset looks like:
3741 . addis %r2,%r2,off@ha
3742 . addi %r2,%r2,off@l
3745 A ppc_stub_plt_branch with an r2 offset looks like:
3747 . addis %r11,%r2,xxx@toc@ha
3748 . ld %r12,xxx@toc@l(%r11)
3749 . addis %r2,%r2,off@ha
3750 . addi %r2,%r2,off@l
3754 In cases where the "addis" instruction would add zero, the "addis" is
3755 omitted and following instructions modified slightly in some cases.
3758 enum ppc_stub_type {
3760 ppc_stub_long_branch,
3761 ppc_stub_long_branch_r2off,
3762 ppc_stub_plt_branch,
3763 ppc_stub_plt_branch_r2off,
3765 ppc_stub_plt_call_r2save
3768 struct ppc_stub_hash_entry {
3770 /* Base hash table entry structure. */
3771 struct bfd_hash_entry root;
3773 enum ppc_stub_type stub_type;
3775 /* The stub section. */
3778 /* Offset within stub_sec of the beginning of this stub. */
3779 bfd_vma stub_offset;
3781 /* Given the symbol's value and its section we can determine its final
3782 value when building the stubs (so the stub knows where to jump. */
3783 bfd_vma target_value;
3784 asection *target_section;
3786 /* The symbol table entry, if any, that this was derived from. */
3787 struct ppc_link_hash_entry *h;
3788 struct plt_entry *plt_ent;
3790 /* Where this stub is being called from, or, in the case of combined
3791 stub sections, the first input section in the group. */
3794 /* Symbol st_other. */
3795 unsigned char other;
3798 struct ppc_branch_hash_entry {
3800 /* Base hash table entry structure. */
3801 struct bfd_hash_entry root;
3803 /* Offset within branch lookup table. */
3804 unsigned int offset;
3806 /* Generation marker. */
3810 /* Used to track dynamic relocations for local symbols. */
3811 struct ppc_dyn_relocs
3813 struct ppc_dyn_relocs *next;
3815 /* The input section of the reloc. */
3818 /* Total number of relocs copied for the input section. */
3819 unsigned int count : 31;
3821 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3822 unsigned int ifunc : 1;
3825 struct ppc_link_hash_entry
3827 struct elf_link_hash_entry elf;
3830 /* A pointer to the most recently used stub hash entry against this
3832 struct ppc_stub_hash_entry *stub_cache;
3834 /* A pointer to the next symbol starting with a '.' */
3835 struct ppc_link_hash_entry *next_dot_sym;
3838 /* Track dynamic relocs copied for this symbol. */
3839 struct elf_dyn_relocs *dyn_relocs;
3841 /* Link between function code and descriptor symbols. */
3842 struct ppc_link_hash_entry *oh;
3844 /* Flag function code and descriptor symbols. */
3845 unsigned int is_func:1;
3846 unsigned int is_func_descriptor:1;
3847 unsigned int fake:1;
3849 /* Whether global opd/toc sym has been adjusted or not.
3850 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3851 should be set for all globals defined in any opd/toc section. */
3852 unsigned int adjust_done:1;
3854 /* Set if we twiddled this symbol to weak at some stage. */
3855 unsigned int was_undefined:1;
3857 /* Contexts in which symbol is used in the GOT (or TOC).
3858 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3859 corresponding relocs are encountered during check_relocs.
3860 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3861 indicate the corresponding GOT entry type is not needed.
3862 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3863 a TPREL one. We use a separate flag rather than setting TPREL
3864 just for convenience in distinguishing the two cases. */
3865 #define TLS_GD 1 /* GD reloc. */
3866 #define TLS_LD 2 /* LD reloc. */
3867 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3868 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3869 #define TLS_TLS 16 /* Any TLS reloc. */
3870 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3871 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3872 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3873 unsigned char tls_mask;
3876 /* ppc64 ELF linker hash table. */
3878 struct ppc_link_hash_table
3880 struct elf_link_hash_table elf;
3882 /* The stub hash table. */
3883 struct bfd_hash_table stub_hash_table;
3885 /* Another hash table for plt_branch stubs. */
3886 struct bfd_hash_table branch_hash_table;
3888 /* Hash table for function prologue tocsave. */
3889 htab_t tocsave_htab;
3891 /* Various options and other info passed from the linker. */
3892 struct ppc64_elf_params *params;
3894 /* Array to keep track of which stub sections have been created, and
3895 information on stub grouping. */
3897 /* This is the section to which stubs in the group will be attached. */
3899 /* The stub section. */
3901 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3905 /* Temp used when calculating TOC pointers. */
3908 asection *toc_first_sec;
3910 /* Highest input section id. */
3913 /* Highest output section index. */
3916 /* Used when adding symbols. */
3917 struct ppc_link_hash_entry *dot_syms;
3919 /* List of input sections for each output section. */
3920 asection **input_list;
3922 /* Shortcuts to get to dynamic linker sections. */
3929 asection *glink_eh_frame;
3931 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3932 struct ppc_link_hash_entry *tls_get_addr;
3933 struct ppc_link_hash_entry *tls_get_addr_fd;
3935 /* The size of reliplt used by got entry relocs. */
3936 bfd_size_type got_reli_size;
3939 unsigned long stub_count[ppc_stub_plt_call_r2save];
3941 /* Number of stubs against global syms. */
3942 unsigned long stub_globals;
3944 /* Set if we're linking code with function descriptors. */
3945 unsigned int opd_abi:1;
3947 /* Support for multiple toc sections. */
3948 unsigned int do_multi_toc:1;
3949 unsigned int multi_toc_needed:1;
3950 unsigned int second_toc_pass:1;
3951 unsigned int do_toc_opt:1;
3954 unsigned int stub_error:1;
3956 /* Temp used by ppc64_elf_before_check_relocs. */
3957 unsigned int twiddled_syms:1;
3959 /* Incremented every time we size stubs. */
3960 unsigned int stub_iteration;
3962 /* Small local sym cache. */
3963 struct sym_cache sym_cache;
3966 /* Rename some of the generic section flags to better document how they
3969 /* Nonzero if this section has TLS related relocations. */
3970 #define has_tls_reloc sec_flg0
3972 /* Nonzero if this section has a call to __tls_get_addr. */
3973 #define has_tls_get_addr_call sec_flg1
3975 /* Nonzero if this section has any toc or got relocs. */
3976 #define has_toc_reloc sec_flg2
3978 /* Nonzero if this section has a call to another section that uses
3980 #define makes_toc_func_call sec_flg3
3982 /* Recursion protection when determining above flag. */
3983 #define call_check_in_progress sec_flg4
3984 #define call_check_done sec_flg5
3986 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3988 #define ppc_hash_table(p) \
3989 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3990 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3992 #define ppc_stub_hash_lookup(table, string, create, copy) \
3993 ((struct ppc_stub_hash_entry *) \
3994 bfd_hash_lookup ((table), (string), (create), (copy)))
3996 #define ppc_branch_hash_lookup(table, string, create, copy) \
3997 ((struct ppc_branch_hash_entry *) \
3998 bfd_hash_lookup ((table), (string), (create), (copy)))
4000 /* Create an entry in the stub hash table. */
4002 static struct bfd_hash_entry *
4003 stub_hash_newfunc (struct bfd_hash_entry *entry,
4004 struct bfd_hash_table *table,
4007 /* Allocate the structure if it has not already been allocated by a
4011 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016 /* Call the allocation method of the superclass. */
4017 entry = bfd_hash_newfunc (entry, table, string);
4020 struct ppc_stub_hash_entry *eh;
4022 /* Initialize the local fields. */
4023 eh = (struct ppc_stub_hash_entry *) entry;
4024 eh->stub_type = ppc_stub_none;
4025 eh->stub_sec = NULL;
4026 eh->stub_offset = 0;
4027 eh->target_value = 0;
4028 eh->target_section = NULL;
4038 /* Create an entry in the branch hash table. */
4040 static struct bfd_hash_entry *
4041 branch_hash_newfunc (struct bfd_hash_entry *entry,
4042 struct bfd_hash_table *table,
4045 /* Allocate the structure if it has not already been allocated by a
4049 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054 /* Call the allocation method of the superclass. */
4055 entry = bfd_hash_newfunc (entry, table, string);
4058 struct ppc_branch_hash_entry *eh;
4060 /* Initialize the local fields. */
4061 eh = (struct ppc_branch_hash_entry *) entry;
4069 /* Create an entry in a ppc64 ELF linker hash table. */
4071 static struct bfd_hash_entry *
4072 link_hash_newfunc (struct bfd_hash_entry *entry,
4073 struct bfd_hash_table *table,
4076 /* Allocate the structure if it has not already been allocated by a
4080 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085 /* Call the allocation method of the superclass. */
4086 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4089 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4091 memset (&eh->u.stub_cache, 0,
4092 (sizeof (struct ppc_link_hash_entry)
4093 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4095 /* When making function calls, old ABI code references function entry
4096 points (dot symbols), while new ABI code references the function
4097 descriptor symbol. We need to make any combination of reference and
4098 definition work together, without breaking archive linking.
4100 For a defined function "foo" and an undefined call to "bar":
4101 An old object defines "foo" and ".foo", references ".bar" (possibly
4103 A new object defines "foo" and references "bar".
4105 A new object thus has no problem with its undefined symbols being
4106 satisfied by definitions in an old object. On the other hand, the
4107 old object won't have ".bar" satisfied by a new object.
4109 Keep a list of newly added dot-symbols. */
4111 if (string[0] == '.')
4113 struct ppc_link_hash_table *htab;
4115 htab = (struct ppc_link_hash_table *) table;
4116 eh->u.next_dot_sym = htab->dot_syms;
4117 htab->dot_syms = eh;
4124 struct tocsave_entry {
4130 tocsave_htab_hash (const void *p)
4132 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4133 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4137 tocsave_htab_eq (const void *p1, const void *p2)
4139 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4140 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4141 return e1->sec == e2->sec && e1->offset == e2->offset;
4144 /* Destroy a ppc64 ELF linker hash table. */
4147 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4149 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4151 bfd_hash_table_free (&htab->stub_hash_table);
4152 bfd_hash_table_free (&htab->branch_hash_table);
4153 if (htab->tocsave_htab)
4154 htab_delete (htab->tocsave_htab);
4155 _bfd_elf_link_hash_table_free (hash);
4158 /* Create a ppc64 ELF linker hash table. */
4160 static struct bfd_link_hash_table *
4161 ppc64_elf_link_hash_table_create (bfd *abfd)
4163 struct ppc_link_hash_table *htab;
4164 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4166 htab = bfd_zmalloc (amt);
4170 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4171 sizeof (struct ppc_link_hash_entry),
4178 /* Init the stub hash table too. */
4179 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4180 sizeof (struct ppc_stub_hash_entry)))
4182 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4186 /* And the branch hash table. */
4187 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4188 sizeof (struct ppc_branch_hash_entry)))
4190 bfd_hash_table_free (&htab->stub_hash_table);
4191 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4195 htab->tocsave_htab = htab_try_create (1024,
4199 if (htab->tocsave_htab == NULL)
4201 bfd_hash_table_free (&htab->branch_hash_table);
4202 bfd_hash_table_free (&htab->stub_hash_table);
4203 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4206 (void) ppc64_elf_link_hash_table_free;
4208 /* Initializing two fields of the union is just cosmetic. We really
4209 only care about glist, but when compiled on a 32-bit host the
4210 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4211 debugger inspection of these fields look nicer. */
4212 htab->elf.init_got_refcount.refcount = 0;
4213 htab->elf.init_got_refcount.glist = NULL;
4214 htab->elf.init_plt_refcount.refcount = 0;
4215 htab->elf.init_plt_refcount.glist = NULL;
4216 htab->elf.init_got_offset.offset = 0;
4217 htab->elf.init_got_offset.glist = NULL;
4218 htab->elf.init_plt_offset.offset = 0;
4219 htab->elf.init_plt_offset.glist = NULL;
4221 return &htab->elf.root;
4224 /* Create sections for linker generated code. */
4227 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4229 struct ppc_link_hash_table *htab;
4232 htab = ppc_hash_table (info);
4234 /* Create .sfpr for code to save and restore fp regs. */
4235 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4236 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4237 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4239 if (htab->sfpr == NULL
4240 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4243 /* Create .glink for lazy dynamic linking support. */
4244 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4246 if (htab->glink == NULL
4247 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4250 if (!info->no_ld_generated_unwind_info)
4252 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4253 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4254 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4257 if (htab->glink_eh_frame == NULL
4258 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4262 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4263 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4264 if (htab->elf.iplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4268 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4269 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4271 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4272 if (htab->elf.irelplt == NULL
4273 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4276 /* Create branch lookup table for plt_branch stubs. */
4277 flags = (SEC_ALLOC | SEC_LOAD
4278 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4279 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4281 if (htab->brlt == NULL
4282 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4288 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4289 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4290 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4293 if (htab->relbrlt == NULL
4294 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4300 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4303 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4304 struct ppc64_elf_params *params)
4306 struct ppc_link_hash_table *htab;
4308 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4310 /* Always hook our dynamic sections into the first bfd, which is the
4311 linker created stub bfd. This ensures that the GOT header is at
4312 the start of the output TOC section. */
4313 htab = ppc_hash_table (info);
4316 htab->elf.dynobj = params->stub_bfd;
4317 htab->params = params;
4319 if (info->relocatable)
4322 return create_linkage_sections (htab->elf.dynobj, info);
4325 /* Build a name for an entry in the stub hash table. */
4328 ppc_stub_name (const asection *input_section,
4329 const asection *sym_sec,
4330 const struct ppc_link_hash_entry *h,
4331 const Elf_Internal_Rela *rel)
4336 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4337 offsets from a sym as a branch target? In fact, we could
4338 probably assume the addend is always zero. */
4339 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4343 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4344 stub_name = bfd_malloc (len);
4345 if (stub_name == NULL)
4348 len = sprintf (stub_name, "%08x.%s+%x",
4349 input_section->id & 0xffffffff,
4350 h->elf.root.root.string,
4351 (int) rel->r_addend & 0xffffffff);
4355 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4356 stub_name = bfd_malloc (len);
4357 if (stub_name == NULL)
4360 len = sprintf (stub_name, "%08x.%x:%x+%x",
4361 input_section->id & 0xffffffff,
4362 sym_sec->id & 0xffffffff,
4363 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4364 (int) rel->r_addend & 0xffffffff);
4366 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4367 stub_name[len - 2] = 0;
4371 /* Look up an entry in the stub hash. Stub entries are cached because
4372 creating the stub name takes a bit of time. */
4374 static struct ppc_stub_hash_entry *
4375 ppc_get_stub_entry (const asection *input_section,
4376 const asection *sym_sec,
4377 struct ppc_link_hash_entry *h,
4378 const Elf_Internal_Rela *rel,
4379 struct ppc_link_hash_table *htab)
4381 struct ppc_stub_hash_entry *stub_entry;
4382 const asection *id_sec;
4384 /* If this input section is part of a group of sections sharing one
4385 stub section, then use the id of the first section in the group.
4386 Stub names need to include a section id, as there may well be
4387 more than one stub used to reach say, printf, and we need to
4388 distinguish between them. */
4389 id_sec = htab->stub_group[input_section->id].link_sec;
4391 if (h != NULL && h->u.stub_cache != NULL
4392 && h->u.stub_cache->h == h
4393 && h->u.stub_cache->id_sec == id_sec)
4395 stub_entry = h->u.stub_cache;
4401 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4402 if (stub_name == NULL)
4405 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4406 stub_name, FALSE, FALSE);
4408 h->u.stub_cache = stub_entry;
4416 /* Add a new stub entry to the stub hash. Not all fields of the new
4417 stub entry are initialised. */
4419 static struct ppc_stub_hash_entry *
4420 ppc_add_stub (const char *stub_name,
4422 struct bfd_link_info *info)
4424 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4427 struct ppc_stub_hash_entry *stub_entry;
4429 link_sec = htab->stub_group[section->id].link_sec;
4430 stub_sec = htab->stub_group[section->id].stub_sec;
4431 if (stub_sec == NULL)
4433 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4434 if (stub_sec == NULL)
4440 namelen = strlen (link_sec->name);
4441 len = namelen + sizeof (STUB_SUFFIX);
4442 s_name = bfd_alloc (htab->params->stub_bfd, len);
4446 memcpy (s_name, link_sec->name, namelen);
4447 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4448 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4449 if (stub_sec == NULL)
4451 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4453 htab->stub_group[section->id].stub_sec = stub_sec;
4456 /* Enter this entry into the linker stub hash table. */
4457 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4459 if (stub_entry == NULL)
4461 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4462 section->owner, stub_name);
4466 stub_entry->stub_sec = stub_sec;
4467 stub_entry->stub_offset = 0;
4468 stub_entry->id_sec = link_sec;
4472 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4473 not already done. */
4476 create_got_section (bfd *abfd, struct bfd_link_info *info)
4478 asection *got, *relgot;
4480 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4482 if (!is_ppc64_elf (abfd))
4488 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4491 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4492 | SEC_LINKER_CREATED);
4494 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4496 || !bfd_set_section_alignment (abfd, got, 3))
4499 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4500 flags | SEC_READONLY);
4502 || ! bfd_set_section_alignment (abfd, relgot, 3))
4505 ppc64_elf_tdata (abfd)->got = got;
4506 ppc64_elf_tdata (abfd)->relgot = relgot;
4510 /* Create the dynamic sections, and set up shortcuts. */
4513 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4515 struct ppc_link_hash_table *htab;
4517 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4520 htab = ppc_hash_table (info);
4524 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4526 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4528 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4529 || (!info->shared && !htab->relbss))
4535 /* Follow indirect and warning symbol links. */
4537 static inline struct bfd_link_hash_entry *
4538 follow_link (struct bfd_link_hash_entry *h)
4540 while (h->type == bfd_link_hash_indirect
4541 || h->type == bfd_link_hash_warning)
4546 static inline struct elf_link_hash_entry *
4547 elf_follow_link (struct elf_link_hash_entry *h)
4549 return (struct elf_link_hash_entry *) follow_link (&h->root);
4552 static inline struct ppc_link_hash_entry *
4553 ppc_follow_link (struct ppc_link_hash_entry *h)
4555 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4558 /* Merge PLT info on FROM with that on TO. */
4561 move_plt_plist (struct ppc_link_hash_entry *from,
4562 struct ppc_link_hash_entry *to)
4564 if (from->elf.plt.plist != NULL)
4566 if (to->elf.plt.plist != NULL)
4568 struct plt_entry **entp;
4569 struct plt_entry *ent;
4571 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4573 struct plt_entry *dent;
4575 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4576 if (dent->addend == ent->addend)
4578 dent->plt.refcount += ent->plt.refcount;
4585 *entp = to->elf.plt.plist;
4588 to->elf.plt.plist = from->elf.plt.plist;
4589 from->elf.plt.plist = NULL;
4593 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4596 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4597 struct elf_link_hash_entry *dir,
4598 struct elf_link_hash_entry *ind)
4600 struct ppc_link_hash_entry *edir, *eind;
4602 edir = (struct ppc_link_hash_entry *) dir;
4603 eind = (struct ppc_link_hash_entry *) ind;
4605 edir->is_func |= eind->is_func;
4606 edir->is_func_descriptor |= eind->is_func_descriptor;
4607 edir->tls_mask |= eind->tls_mask;
4608 if (eind->oh != NULL)
4609 edir->oh = ppc_follow_link (eind->oh);
4611 /* If called to transfer flags for a weakdef during processing
4612 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4613 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4614 if (!(ELIMINATE_COPY_RELOCS
4615 && eind->elf.root.type != bfd_link_hash_indirect
4616 && edir->elf.dynamic_adjusted))
4617 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4619 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4620 edir->elf.ref_regular |= eind->elf.ref_regular;
4621 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4622 edir->elf.needs_plt |= eind->elf.needs_plt;
4623 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4625 /* Copy over any dynamic relocs we may have on the indirect sym. */
4626 if (eind->dyn_relocs != NULL)
4628 if (edir->dyn_relocs != NULL)
4630 struct elf_dyn_relocs **pp;
4631 struct elf_dyn_relocs *p;
4633 /* Add reloc counts against the indirect sym to the direct sym
4634 list. Merge any entries against the same section. */
4635 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4637 struct elf_dyn_relocs *q;
4639 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4640 if (q->sec == p->sec)
4642 q->pc_count += p->pc_count;
4643 q->count += p->count;
4650 *pp = edir->dyn_relocs;
4653 edir->dyn_relocs = eind->dyn_relocs;
4654 eind->dyn_relocs = NULL;
4657 /* If we were called to copy over info for a weak sym, that's all.
4658 You might think dyn_relocs need not be copied over; After all,
4659 both syms will be dynamic or both non-dynamic so we're just
4660 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4661 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4662 dyn_relocs in read-only sections, and it does so on what is the
4664 if (eind->elf.root.type != bfd_link_hash_indirect)
4667 /* Copy over got entries that we may have already seen to the
4668 symbol which just became indirect. */
4669 if (eind->elf.got.glist != NULL)
4671 if (edir->elf.got.glist != NULL)
4673 struct got_entry **entp;
4674 struct got_entry *ent;
4676 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4678 struct got_entry *dent;
4680 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4681 if (dent->addend == ent->addend
4682 && dent->owner == ent->owner
4683 && dent->tls_type == ent->tls_type)
4685 dent->got.refcount += ent->got.refcount;
4692 *entp = edir->elf.got.glist;
4695 edir->elf.got.glist = eind->elf.got.glist;
4696 eind->elf.got.glist = NULL;
4699 /* And plt entries. */
4700 move_plt_plist (eind, edir);
4702 if (eind->elf.dynindx != -1)
4704 if (edir->elf.dynindx != -1)
4705 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4706 edir->elf.dynstr_index);
4707 edir->elf.dynindx = eind->elf.dynindx;
4708 edir->elf.dynstr_index = eind->elf.dynstr_index;
4709 eind->elf.dynindx = -1;
4710 eind->elf.dynstr_index = 0;
4714 /* Find the function descriptor hash entry from the given function code
4715 hash entry FH. Link the entries via their OH fields. */
4717 static struct ppc_link_hash_entry *
4718 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4720 struct ppc_link_hash_entry *fdh = fh->oh;
4724 const char *fd_name = fh->elf.root.root.string + 1;
4726 fdh = (struct ppc_link_hash_entry *)
4727 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4731 fdh->is_func_descriptor = 1;
4737 return ppc_follow_link (fdh);
4740 /* Make a fake function descriptor sym for the code sym FH. */
4742 static struct ppc_link_hash_entry *
4743 make_fdh (struct bfd_link_info *info,
4744 struct ppc_link_hash_entry *fh)
4748 struct bfd_link_hash_entry *bh;
4749 struct ppc_link_hash_entry *fdh;
4751 abfd = fh->elf.root.u.undef.abfd;
4752 newsym = bfd_make_empty_symbol (abfd);
4753 newsym->name = fh->elf.root.root.string + 1;
4754 newsym->section = bfd_und_section_ptr;
4756 newsym->flags = BSF_WEAK;
4759 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4760 newsym->flags, newsym->section,
4761 newsym->value, NULL, FALSE, FALSE,
4765 fdh = (struct ppc_link_hash_entry *) bh;
4766 fdh->elf.non_elf = 0;
4768 fdh->is_func_descriptor = 1;
4775 /* Fix function descriptor symbols defined in .opd sections to be
4779 ppc64_elf_add_symbol_hook (bfd *ibfd,
4780 struct bfd_link_info *info,
4781 Elf_Internal_Sym *isym,
4783 flagword *flags ATTRIBUTE_UNUSED,
4785 bfd_vma *value ATTRIBUTE_UNUSED)
4787 if ((ibfd->flags & DYNAMIC) == 0
4788 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4789 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4791 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4793 if ((ibfd->flags & DYNAMIC) == 0)
4794 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4796 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4798 else if (*sec != NULL
4799 && strcmp ((*sec)->name, ".opd") == 0)
4800 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4802 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4804 if (abiversion (ibfd) == 0)
4805 set_abiversion (ibfd, 2);
4806 else if (abiversion (ibfd) == 1)
4808 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4809 " for ABI version 1\n"), name);
4810 bfd_set_error (bfd_error_bad_value);
4818 /* Merge non-visibility st_other attributes: local entry point. */
4821 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4822 const Elf_Internal_Sym *isym,
4823 bfd_boolean definition,
4824 bfd_boolean dynamic)
4826 if (definition && !dynamic)
4827 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4828 | ELF_ST_VISIBILITY (h->other));
4831 /* This function makes an old ABI object reference to ".bar" cause the
4832 inclusion of a new ABI object archive that defines "bar".
4833 NAME is a symbol defined in an archive. Return a symbol in the hash
4834 table that might be satisfied by the archive symbols. */
4836 static struct elf_link_hash_entry *
4837 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4838 struct bfd_link_info *info,
4841 struct elf_link_hash_entry *h;
4845 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4847 /* Don't return this sym if it is a fake function descriptor
4848 created by add_symbol_adjust. */
4849 && !(h->root.type == bfd_link_hash_undefweak
4850 && ((struct ppc_link_hash_entry *) h)->fake))
4856 len = strlen (name);
4857 dot_name = bfd_alloc (abfd, len + 2);
4858 if (dot_name == NULL)
4859 return (struct elf_link_hash_entry *) 0 - 1;
4861 memcpy (dot_name + 1, name, len + 1);
4862 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4863 bfd_release (abfd, dot_name);
4867 /* This function satisfies all old ABI object references to ".bar" if a
4868 new ABI object defines "bar". Well, at least, undefined dot symbols
4869 are made weak. This stops later archive searches from including an
4870 object if we already have a function descriptor definition. It also
4871 prevents the linker complaining about undefined symbols.
4872 We also check and correct mismatched symbol visibility here. The
4873 most restrictive visibility of the function descriptor and the
4874 function entry symbol is used. */
4877 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4879 struct ppc_link_hash_table *htab;
4880 struct ppc_link_hash_entry *fdh;
4882 if (eh->elf.root.type == bfd_link_hash_indirect)
4885 if (eh->elf.root.type == bfd_link_hash_warning)
4886 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4888 if (eh->elf.root.root.string[0] != '.')
4891 htab = ppc_hash_table (info);
4895 fdh = lookup_fdh (eh, htab);
4898 if (!info->relocatable
4899 && (eh->elf.root.type == bfd_link_hash_undefined
4900 || eh->elf.root.type == bfd_link_hash_undefweak)
4901 && eh->elf.ref_regular)
4903 /* Make an undefweak function descriptor sym, which is enough to
4904 pull in an --as-needed shared lib, but won't cause link
4905 errors. Archives are handled elsewhere. */
4906 fdh = make_fdh (info, eh);
4909 fdh->elf.ref_regular = 1;
4914 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4915 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4916 if (entry_vis < descr_vis)
4917 fdh->elf.other += entry_vis - descr_vis;
4918 else if (entry_vis > descr_vis)
4919 eh->elf.other += descr_vis - entry_vis;
4921 if ((fdh->elf.root.type == bfd_link_hash_defined
4922 || fdh->elf.root.type == bfd_link_hash_defweak)
4923 && eh->elf.root.type == bfd_link_hash_undefined)
4925 eh->elf.root.type = bfd_link_hash_undefweak;
4926 eh->was_undefined = 1;
4927 htab->twiddled_syms = 1;
4934 /* Set up opd section info and abiversion for IBFD, and process list
4935 of dot-symbols we made in link_hash_newfunc. */
4938 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4940 struct ppc_link_hash_table *htab;
4941 struct ppc_link_hash_entry **p, *eh;
4943 if (!is_ppc64_elf (info->output_bfd))
4945 htab = ppc_hash_table (info);
4949 if (is_ppc64_elf (ibfd))
4951 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4953 if (opd != NULL && opd->size != 0)
4955 if (abiversion (ibfd) == 0)
4956 set_abiversion (ibfd, 1);
4957 else if (abiversion (ibfd) == 2)
4959 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4961 ibfd, abiversion (ibfd));
4962 bfd_set_error (bfd_error_bad_value);
4966 if ((ibfd->flags & DYNAMIC) == 0
4967 && (opd->flags & SEC_RELOC) != 0
4968 && opd->reloc_count != 0
4969 && !bfd_is_abs_section (opd->output_section))
4971 /* Garbage collection needs some extra help with .opd sections.
4972 We don't want to necessarily keep everything referenced by
4973 relocs in .opd, as that would keep all functions. Instead,
4974 if we reference an .opd symbol (a function descriptor), we
4975 want to keep the function code symbol's section. This is
4976 easy for global symbols, but for local syms we need to keep
4977 information about the associated function section. */
4979 asection **opd_sym_map;
4981 amt = opd->size * sizeof (*opd_sym_map) / 8;
4982 opd_sym_map = bfd_zalloc (ibfd, amt);
4983 if (opd_sym_map == NULL)
4985 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4986 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4987 ppc64_elf_section_data (opd)->sec_type = sec_opd;
4991 /* For input files without an explicit abiversion in e_flags
4992 we should have flagged any with symbol st_other bits set
4993 as ELFv1 and above flagged those with .opd as ELFv2.
4994 Set the output abiversion if not yet set, and for any input
4995 still ambiguous, take its abiversion from the output.
4996 Differences in ABI are reported later. */
4997 if (abiversion (info->output_bfd) == 0)
4998 set_abiversion (info->output_bfd, abiversion (ibfd));
4999 else if (abiversion (ibfd) == 0)
5000 set_abiversion (ibfd, abiversion (info->output_bfd));
5002 p = &htab->dot_syms;
5003 while ((eh = *p) != NULL)
5006 if (&eh->elf == htab->elf.hgot)
5008 else if (htab->elf.hgot == NULL
5009 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5010 htab->elf.hgot = &eh->elf;
5011 else if (!add_symbol_adjust (eh, info))
5013 p = &eh->u.next_dot_sym;
5017 /* Clear the list for non-ppc64 input files. */
5018 p = &htab->dot_syms;
5019 while ((eh = *p) != NULL)
5022 p = &eh->u.next_dot_sym;
5025 /* We need to fix the undefs list for any syms we have twiddled to
5027 if (htab->twiddled_syms)
5029 bfd_link_repair_undef_list (&htab->elf.root);
5030 htab->twiddled_syms = 0;
5035 /* Undo hash table changes when an --as-needed input file is determined
5036 not to be needed. */
5039 ppc64_elf_notice_as_needed (bfd *ibfd,
5040 struct bfd_link_info *info,
5041 enum notice_asneeded_action act)
5043 if (act == notice_not_needed)
5045 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5050 htab->dot_syms = NULL;
5052 return _bfd_elf_notice_as_needed (ibfd, info, act);
5055 /* If --just-symbols against a final linked binary, then assume we need
5056 toc adjusting stubs when calling functions defined there. */
5059 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5061 if ((sec->flags & SEC_CODE) != 0
5062 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5063 && is_ppc64_elf (sec->owner))
5065 if (abiversion (sec->owner) >= 2
5066 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5067 sec->has_toc_reloc = 1;
5069 _bfd_elf_link_just_syms (sec, info);
5072 static struct plt_entry **
5073 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5074 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5076 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5077 struct plt_entry **local_plt;
5078 unsigned char *local_got_tls_masks;
5080 if (local_got_ents == NULL)
5082 bfd_size_type size = symtab_hdr->sh_info;
5084 size *= (sizeof (*local_got_ents)
5085 + sizeof (*local_plt)
5086 + sizeof (*local_got_tls_masks));
5087 local_got_ents = bfd_zalloc (abfd, size);
5088 if (local_got_ents == NULL)
5090 elf_local_got_ents (abfd) = local_got_ents;
5093 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5095 struct got_entry *ent;
5097 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5098 if (ent->addend == r_addend
5099 && ent->owner == abfd
5100 && ent->tls_type == tls_type)
5104 bfd_size_type amt = sizeof (*ent);
5105 ent = bfd_alloc (abfd, amt);
5108 ent->next = local_got_ents[r_symndx];
5109 ent->addend = r_addend;
5111 ent->tls_type = tls_type;
5112 ent->is_indirect = FALSE;
5113 ent->got.refcount = 0;
5114 local_got_ents[r_symndx] = ent;
5116 ent->got.refcount += 1;
5119 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5120 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5121 local_got_tls_masks[r_symndx] |= tls_type;
5123 return local_plt + r_symndx;
5127 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5129 struct plt_entry *ent;
5131 for (ent = *plist; ent != NULL; ent = ent->next)
5132 if (ent->addend == addend)
5136 bfd_size_type amt = sizeof (*ent);
5137 ent = bfd_alloc (abfd, amt);
5141 ent->addend = addend;
5142 ent->plt.refcount = 0;
5145 ent->plt.refcount += 1;
5150 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5152 return (r_type == R_PPC64_REL24
5153 || r_type == R_PPC64_REL14
5154 || r_type == R_PPC64_REL14_BRTAKEN
5155 || r_type == R_PPC64_REL14_BRNTAKEN
5156 || r_type == R_PPC64_ADDR24
5157 || r_type == R_PPC64_ADDR14
5158 || r_type == R_PPC64_ADDR14_BRTAKEN
5159 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5162 /* Look through the relocs for a section during the first phase, and
5163 calculate needed space in the global offset table, procedure
5164 linkage table, and dynamic reloc sections. */
5167 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5168 asection *sec, const Elf_Internal_Rela *relocs)
5170 struct ppc_link_hash_table *htab;
5171 Elf_Internal_Shdr *symtab_hdr;
5172 struct elf_link_hash_entry **sym_hashes;
5173 const Elf_Internal_Rela *rel;
5174 const Elf_Internal_Rela *rel_end;
5176 asection **opd_sym_map;
5177 struct elf_link_hash_entry *tga, *dottga;
5179 if (info->relocatable)
5182 /* Don't do anything special with non-loaded, non-alloced sections.
5183 In particular, any relocs in such sections should not affect GOT
5184 and PLT reference counting (ie. we don't allow them to create GOT
5185 or PLT entries), there's no possibility or desire to optimize TLS
5186 relocs, and there's not much point in propagating relocs to shared
5187 libs that the dynamic linker won't relocate. */
5188 if ((sec->flags & SEC_ALLOC) == 0)
5191 BFD_ASSERT (is_ppc64_elf (abfd));
5193 htab = ppc_hash_table (info);
5197 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5198 FALSE, FALSE, TRUE);
5199 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5200 FALSE, FALSE, TRUE);
5201 symtab_hdr = &elf_symtab_hdr (abfd);
5202 sym_hashes = elf_sym_hashes (abfd);
5205 if (ppc64_elf_section_data (sec) != NULL
5206 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5207 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5209 rel_end = relocs + sec->reloc_count;
5210 for (rel = relocs; rel < rel_end; rel++)
5212 unsigned long r_symndx;
5213 struct elf_link_hash_entry *h;
5214 enum elf_ppc64_reloc_type r_type;
5216 struct _ppc64_elf_section_data *ppc64_sec;
5217 struct plt_entry **ifunc;
5219 r_symndx = ELF64_R_SYM (rel->r_info);
5220 if (r_symndx < symtab_hdr->sh_info)
5224 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5225 h = elf_follow_link (h);
5227 /* PR15323, ref flags aren't set for references in the same
5229 h->root.non_ir_ref = 1;
5231 if (h == htab->elf.hgot)
5232 sec->has_toc_reloc = 1;
5239 if (h->type == STT_GNU_IFUNC)
5242 ifunc = &h->plt.plist;
5247 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5252 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5254 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5255 rel->r_addend, PLT_IFUNC);
5260 r_type = ELF64_R_TYPE (rel->r_info);
5261 if (is_branch_reloc (r_type))
5263 if (h != NULL && (h == tga || h == dottga))
5266 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5267 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5268 /* We have a new-style __tls_get_addr call with a marker
5272 /* Mark this section as having an old-style call. */
5273 sec->has_tls_get_addr_call = 1;
5276 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5278 && !update_plt_info (abfd, ifunc, rel->r_addend))
5286 /* These special tls relocs tie a call to __tls_get_addr with
5287 its parameter symbol. */
5290 case R_PPC64_GOT_TLSLD16:
5291 case R_PPC64_GOT_TLSLD16_LO:
5292 case R_PPC64_GOT_TLSLD16_HI:
5293 case R_PPC64_GOT_TLSLD16_HA:
5294 tls_type = TLS_TLS | TLS_LD;
5297 case R_PPC64_GOT_TLSGD16:
5298 case R_PPC64_GOT_TLSGD16_LO:
5299 case R_PPC64_GOT_TLSGD16_HI:
5300 case R_PPC64_GOT_TLSGD16_HA:
5301 tls_type = TLS_TLS | TLS_GD;
5304 case R_PPC64_GOT_TPREL16_DS:
5305 case R_PPC64_GOT_TPREL16_LO_DS:
5306 case R_PPC64_GOT_TPREL16_HI:
5307 case R_PPC64_GOT_TPREL16_HA:
5308 if (!info->executable)
5309 info->flags |= DF_STATIC_TLS;
5310 tls_type = TLS_TLS | TLS_TPREL;
5313 case R_PPC64_GOT_DTPREL16_DS:
5314 case R_PPC64_GOT_DTPREL16_LO_DS:
5315 case R_PPC64_GOT_DTPREL16_HI:
5316 case R_PPC64_GOT_DTPREL16_HA:
5317 tls_type = TLS_TLS | TLS_DTPREL;
5319 sec->has_tls_reloc = 1;
5323 case R_PPC64_GOT16_DS:
5324 case R_PPC64_GOT16_HA:
5325 case R_PPC64_GOT16_HI:
5326 case R_PPC64_GOT16_LO:
5327 case R_PPC64_GOT16_LO_DS:
5328 /* This symbol requires a global offset table entry. */
5329 sec->has_toc_reloc = 1;
5330 if (r_type == R_PPC64_GOT_TLSLD16
5331 || r_type == R_PPC64_GOT_TLSGD16
5332 || r_type == R_PPC64_GOT_TPREL16_DS
5333 || r_type == R_PPC64_GOT_DTPREL16_DS
5334 || r_type == R_PPC64_GOT16
5335 || r_type == R_PPC64_GOT16_DS)
5337 htab->do_multi_toc = 1;
5338 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5341 if (ppc64_elf_tdata (abfd)->got == NULL
5342 && !create_got_section (abfd, info))
5347 struct ppc_link_hash_entry *eh;
5348 struct got_entry *ent;
5350 eh = (struct ppc_link_hash_entry *) h;
5351 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5352 if (ent->addend == rel->r_addend
5353 && ent->owner == abfd
5354 && ent->tls_type == tls_type)
5358 bfd_size_type amt = sizeof (*ent);
5359 ent = bfd_alloc (abfd, amt);
5362 ent->next = eh->elf.got.glist;
5363 ent->addend = rel->r_addend;
5365 ent->tls_type = tls_type;
5366 ent->is_indirect = FALSE;
5367 ent->got.refcount = 0;
5368 eh->elf.got.glist = ent;
5370 ent->got.refcount += 1;
5371 eh->tls_mask |= tls_type;
5374 /* This is a global offset table entry for a local symbol. */
5375 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5376 rel->r_addend, tls_type))
5379 /* We may also need a plt entry if the symbol turns out to be
5381 if (h != NULL && !info->shared && abiversion (abfd) != 1)
5383 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5388 case R_PPC64_PLT16_HA:
5389 case R_PPC64_PLT16_HI:
5390 case R_PPC64_PLT16_LO:
5393 /* This symbol requires a procedure linkage table entry. We
5394 actually build the entry in adjust_dynamic_symbol,
5395 because this might be a case of linking PIC code without
5396 linking in any dynamic objects, in which case we don't
5397 need to generate a procedure linkage table after all. */
5400 /* It does not make sense to have a procedure linkage
5401 table entry for a local symbol. */
5402 bfd_set_error (bfd_error_bad_value);
5407 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5410 if (h->root.root.string[0] == '.'
5411 && h->root.root.string[1] != '\0')
5412 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5416 /* The following relocations don't need to propagate the
5417 relocation if linking a shared object since they are
5418 section relative. */
5419 case R_PPC64_SECTOFF:
5420 case R_PPC64_SECTOFF_LO:
5421 case R_PPC64_SECTOFF_HI:
5422 case R_PPC64_SECTOFF_HA:
5423 case R_PPC64_SECTOFF_DS:
5424 case R_PPC64_SECTOFF_LO_DS:
5425 case R_PPC64_DTPREL16:
5426 case R_PPC64_DTPREL16_LO:
5427 case R_PPC64_DTPREL16_HI:
5428 case R_PPC64_DTPREL16_HA:
5429 case R_PPC64_DTPREL16_DS:
5430 case R_PPC64_DTPREL16_LO_DS:
5431 case R_PPC64_DTPREL16_HIGH:
5432 case R_PPC64_DTPREL16_HIGHA:
5433 case R_PPC64_DTPREL16_HIGHER:
5434 case R_PPC64_DTPREL16_HIGHERA:
5435 case R_PPC64_DTPREL16_HIGHEST:
5436 case R_PPC64_DTPREL16_HIGHESTA:
5441 case R_PPC64_REL16_LO:
5442 case R_PPC64_REL16_HI:
5443 case R_PPC64_REL16_HA:
5446 /* Not supported as a dynamic relocation. */
5447 case R_PPC64_ADDR64_LOCAL:
5450 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5452 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5453 "in shared libraries and PIEs.\n"),
5454 abfd, sec, rel->r_offset,
5455 ppc64_elf_howto_table[r_type]->name);
5456 bfd_set_error (bfd_error_bad_value);
5462 case R_PPC64_TOC16_DS:
5463 htab->do_multi_toc = 1;
5464 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5465 case R_PPC64_TOC16_LO:
5466 case R_PPC64_TOC16_HI:
5467 case R_PPC64_TOC16_HA:
5468 case R_PPC64_TOC16_LO_DS:
5469 sec->has_toc_reloc = 1;
5472 /* This relocation describes the C++ object vtable hierarchy.
5473 Reconstruct it for later use during GC. */
5474 case R_PPC64_GNU_VTINHERIT:
5475 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5479 /* This relocation describes which C++ vtable entries are actually
5480 used. Record for later use during GC. */
5481 case R_PPC64_GNU_VTENTRY:
5482 BFD_ASSERT (h != NULL);
5484 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5489 case R_PPC64_REL14_BRTAKEN:
5490 case R_PPC64_REL14_BRNTAKEN:
5492 asection *dest = NULL;
5494 /* Heuristic: If jumping outside our section, chances are
5495 we are going to need a stub. */
5498 /* If the sym is weak it may be overridden later, so
5499 don't assume we know where a weak sym lives. */
5500 if (h->root.type == bfd_link_hash_defined)
5501 dest = h->root.u.def.section;
5505 Elf_Internal_Sym *isym;
5507 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5512 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5516 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5521 if (h != NULL && ifunc == NULL)
5523 /* We may need a .plt entry if the function this reloc
5524 refers to is in a shared lib. */
5525 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5528 if (h->root.root.string[0] == '.'
5529 && h->root.root.string[1] != '\0')
5530 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5531 if (h == tga || h == dottga)
5532 sec->has_tls_reloc = 1;
5536 case R_PPC64_TPREL64:
5537 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5538 if (!info->executable)
5539 info->flags |= DF_STATIC_TLS;
5542 case R_PPC64_DTPMOD64:
5543 if (rel + 1 < rel_end
5544 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5545 && rel[1].r_offset == rel->r_offset + 8)
5546 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5548 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5551 case R_PPC64_DTPREL64:
5552 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5554 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5555 && rel[-1].r_offset == rel->r_offset - 8)
5556 /* This is the second reloc of a dtpmod, dtprel pair.
5557 Don't mark with TLS_DTPREL. */
5561 sec->has_tls_reloc = 1;
5564 struct ppc_link_hash_entry *eh;
5565 eh = (struct ppc_link_hash_entry *) h;
5566 eh->tls_mask |= tls_type;
5569 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5570 rel->r_addend, tls_type))
5573 ppc64_sec = ppc64_elf_section_data (sec);
5574 if (ppc64_sec->sec_type != sec_toc)
5578 /* One extra to simplify get_tls_mask. */
5579 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5580 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5581 if (ppc64_sec->u.toc.symndx == NULL)
5583 amt = sec->size * sizeof (bfd_vma) / 8;
5584 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5585 if (ppc64_sec->u.toc.add == NULL)
5587 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5588 ppc64_sec->sec_type = sec_toc;
5590 BFD_ASSERT (rel->r_offset % 8 == 0);
5591 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5592 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5594 /* Mark the second slot of a GD or LD entry.
5595 -1 to indicate GD and -2 to indicate LD. */
5596 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5597 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5598 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5599 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5602 case R_PPC64_TPREL16:
5603 case R_PPC64_TPREL16_LO:
5604 case R_PPC64_TPREL16_HI:
5605 case R_PPC64_TPREL16_HA:
5606 case R_PPC64_TPREL16_DS:
5607 case R_PPC64_TPREL16_LO_DS:
5608 case R_PPC64_TPREL16_HIGH:
5609 case R_PPC64_TPREL16_HIGHA:
5610 case R_PPC64_TPREL16_HIGHER:
5611 case R_PPC64_TPREL16_HIGHERA:
5612 case R_PPC64_TPREL16_HIGHEST:
5613 case R_PPC64_TPREL16_HIGHESTA:
5616 if (!info->executable)
5617 info->flags |= DF_STATIC_TLS;
5622 case R_PPC64_ADDR64:
5623 if (opd_sym_map != NULL
5624 && rel + 1 < rel_end
5625 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5629 if (h->root.root.string[0] == '.'
5630 && h->root.root.string[1] != 0
5631 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5634 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5639 Elf_Internal_Sym *isym;
5641 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5646 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5647 if (s != NULL && s != sec)
5648 opd_sym_map[rel->r_offset / 8] = s;
5653 case R_PPC64_ADDR16:
5654 case R_PPC64_ADDR16_DS:
5655 case R_PPC64_ADDR16_HA:
5656 case R_PPC64_ADDR16_HI:
5657 case R_PPC64_ADDR16_HIGH:
5658 case R_PPC64_ADDR16_HIGHA:
5659 case R_PPC64_ADDR16_HIGHER:
5660 case R_PPC64_ADDR16_HIGHERA:
5661 case R_PPC64_ADDR16_HIGHEST:
5662 case R_PPC64_ADDR16_HIGHESTA:
5663 case R_PPC64_ADDR16_LO:
5664 case R_PPC64_ADDR16_LO_DS:
5665 if (h != NULL && !info->shared && abiversion (abfd) != 1
5666 && rel->r_addend == 0)
5668 /* We may need a .plt entry if this reloc refers to a
5669 function in a shared lib. */
5670 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5672 h->pointer_equality_needed = 1;
5679 case R_PPC64_ADDR14:
5680 case R_PPC64_ADDR14_BRNTAKEN:
5681 case R_PPC64_ADDR14_BRTAKEN:
5682 case R_PPC64_ADDR24:
5683 case R_PPC64_ADDR32:
5684 case R_PPC64_UADDR16:
5685 case R_PPC64_UADDR32:
5686 case R_PPC64_UADDR64:
5688 if (h != NULL && !info->shared)
5689 /* We may need a copy reloc. */
5692 /* Don't propagate .opd relocs. */
5693 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5696 /* If we are creating a shared library, and this is a reloc
5697 against a global symbol, or a non PC relative reloc
5698 against a local symbol, then we need to copy the reloc
5699 into the shared library. However, if we are linking with
5700 -Bsymbolic, we do not need to copy a reloc against a
5701 global symbol which is defined in an object we are
5702 including in the link (i.e., DEF_REGULAR is set). At
5703 this point we have not seen all the input files, so it is
5704 possible that DEF_REGULAR is not set now but will be set
5705 later (it is never cleared). In case of a weak definition,
5706 DEF_REGULAR may be cleared later by a strong definition in
5707 a shared library. We account for that possibility below by
5708 storing information in the dyn_relocs field of the hash
5709 table entry. A similar situation occurs when creating
5710 shared libraries and symbol visibility changes render the
5713 If on the other hand, we are creating an executable, we
5714 may need to keep relocations for symbols satisfied by a
5715 dynamic library if we manage to avoid copy relocs for the
5719 && (must_be_dyn_reloc (info, r_type)
5721 && (!SYMBOLIC_BIND (info, h)
5722 || h->root.type == bfd_link_hash_defweak
5723 || !h->def_regular))))
5724 || (ELIMINATE_COPY_RELOCS
5727 && (h->root.type == bfd_link_hash_defweak
5728 || !h->def_regular))
5732 /* We must copy these reloc types into the output file.
5733 Create a reloc section in dynobj and make room for
5737 sreloc = _bfd_elf_make_dynamic_reloc_section
5738 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5744 /* If this is a global symbol, we count the number of
5745 relocations we need for this symbol. */
5748 struct elf_dyn_relocs *p;
5749 struct elf_dyn_relocs **head;
5751 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5753 if (p == NULL || p->sec != sec)
5755 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5765 if (!must_be_dyn_reloc (info, r_type))
5770 /* Track dynamic relocs needed for local syms too.
5771 We really need local syms available to do this
5773 struct ppc_dyn_relocs *p;
5774 struct ppc_dyn_relocs **head;
5775 bfd_boolean is_ifunc;
5778 Elf_Internal_Sym *isym;
5780 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5785 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5789 vpp = &elf_section_data (s)->local_dynrel;
5790 head = (struct ppc_dyn_relocs **) vpp;
5791 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5793 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5795 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5797 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5803 p->ifunc = is_ifunc;
5819 /* Merge backend specific data from an object file to the output
5820 object file when linking. */
5823 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5825 unsigned long iflags, oflags;
5827 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5830 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5833 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5836 iflags = elf_elfheader (ibfd)->e_flags;
5837 oflags = elf_elfheader (obfd)->e_flags;
5839 if (iflags & ~EF_PPC64_ABI)
5841 (*_bfd_error_handler)
5842 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5843 bfd_set_error (bfd_error_bad_value);
5846 else if (iflags != oflags && iflags != 0)
5848 (*_bfd_error_handler)
5849 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5850 ibfd, iflags, oflags);
5851 bfd_set_error (bfd_error_bad_value);
5855 /* Merge Tag_compatibility attributes and any common GNU ones. */
5856 _bfd_elf_merge_object_attributes (ibfd, obfd);
5862 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5864 /* Print normal ELF private data. */
5865 _bfd_elf_print_private_bfd_data (abfd, ptr);
5867 if (elf_elfheader (abfd)->e_flags != 0)
5871 /* xgettext:c-format */
5872 fprintf (file, _("private flags = 0x%lx:"),
5873 elf_elfheader (abfd)->e_flags);
5875 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5876 fprintf (file, _(" [abiv%ld]"),
5877 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5884 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5885 of the code entry point, and its section. */
5888 opd_entry_value (asection *opd_sec,
5890 asection **code_sec,
5892 bfd_boolean in_code_sec)
5894 bfd *opd_bfd = opd_sec->owner;
5895 Elf_Internal_Rela *relocs;
5896 Elf_Internal_Rela *lo, *hi, *look;
5899 /* No relocs implies we are linking a --just-symbols object, or looking
5900 at a final linked executable with addr2line or somesuch. */
5901 if (opd_sec->reloc_count == 0)
5903 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5905 if (contents == NULL)
5907 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5908 return (bfd_vma) -1;
5909 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5912 val = bfd_get_64 (opd_bfd, contents + offset);
5913 if (code_sec != NULL)
5915 asection *sec, *likely = NULL;
5921 && val < sec->vma + sec->size)
5927 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5929 && (sec->flags & SEC_LOAD) != 0
5930 && (sec->flags & SEC_ALLOC) != 0)
5935 if (code_off != NULL)
5936 *code_off = val - likely->vma;
5942 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5944 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5946 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5948 /* Go find the opd reloc at the sym address. */
5950 BFD_ASSERT (lo != NULL);
5951 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5955 look = lo + (hi - lo) / 2;
5956 if (look->r_offset < offset)
5958 else if (look->r_offset > offset)
5962 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5964 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5965 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5967 unsigned long symndx = ELF64_R_SYM (look->r_info);
5970 if (symndx < symtab_hdr->sh_info
5971 || elf_sym_hashes (opd_bfd) == NULL)
5973 Elf_Internal_Sym *sym;
5975 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5978 size_t symcnt = symtab_hdr->sh_info;
5979 if (elf_sym_hashes (opd_bfd) == NULL)
5980 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5981 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5982 0, NULL, NULL, NULL);
5985 symtab_hdr->contents = (bfd_byte *) sym;
5989 val = sym->st_value;
5990 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5991 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5995 struct elf_link_hash_entry **sym_hashes;
5996 struct elf_link_hash_entry *rh;
5998 sym_hashes = elf_sym_hashes (opd_bfd);
5999 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6002 rh = elf_follow_link (rh);
6003 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6004 || rh->root.type == bfd_link_hash_defweak);
6005 val = rh->root.u.def.value;
6006 sec = rh->root.u.def.section;
6010 /* Handle the odd case where we can be called
6011 during bfd_elf_link_add_symbols before the
6012 symbol hashes have been fully populated. */
6013 Elf_Internal_Sym *sym;
6015 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6016 symndx, NULL, NULL, NULL);
6020 val = sym->st_value;
6021 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6025 val += look->r_addend;
6026 if (code_off != NULL)
6028 if (code_sec != NULL)
6030 if (in_code_sec && *code_sec != sec)
6035 if (sec != NULL && sec->output_section != NULL)
6036 val += sec->output_section->vma + sec->output_offset;
6045 /* If the ELF symbol SYM might be a function in SEC, return the
6046 function size and set *CODE_OFF to the function's entry point,
6047 otherwise return zero. */
6049 static bfd_size_type
6050 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6055 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6056 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6060 if (!(sym->flags & BSF_SYNTHETIC))
6061 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6063 if (strcmp (sym->section->name, ".opd") == 0)
6065 if (opd_entry_value (sym->section, sym->value,
6066 &sec, code_off, TRUE) == (bfd_vma) -1)
6068 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6069 symbol. This size has nothing to do with the code size of the
6070 function, which is what we're supposed to return, but the
6071 code size isn't available without looking up the dot-sym.
6072 However, doing that would be a waste of time particularly
6073 since elf_find_function will look at the dot-sym anyway.
6074 Now, elf_find_function will keep the largest size of any
6075 function sym found at the code address of interest, so return
6076 1 here to avoid it incorrectly caching a larger function size
6077 for a small function. This does mean we return the wrong
6078 size for a new-ABI function of size 24, but all that does is
6079 disable caching for such functions. */
6085 if (sym->section != sec)
6087 *code_off = sym->value;
6094 /* Return true if symbol is defined in a regular object file. */
6097 is_static_defined (struct elf_link_hash_entry *h)
6099 return ((h->root.type == bfd_link_hash_defined
6100 || h->root.type == bfd_link_hash_defweak)
6101 && h->root.u.def.section != NULL
6102 && h->root.u.def.section->output_section != NULL);
6105 /* If FDH is a function descriptor symbol, return the associated code
6106 entry symbol if it is defined. Return NULL otherwise. */
6108 static struct ppc_link_hash_entry *
6109 defined_code_entry (struct ppc_link_hash_entry *fdh)
6111 if (fdh->is_func_descriptor)
6113 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6114 if (fh->elf.root.type == bfd_link_hash_defined
6115 || fh->elf.root.type == bfd_link_hash_defweak)
6121 /* If FH is a function code entry symbol, return the associated
6122 function descriptor symbol if it is defined. Return NULL otherwise. */
6124 static struct ppc_link_hash_entry *
6125 defined_func_desc (struct ppc_link_hash_entry *fh)
6128 && fh->oh->is_func_descriptor)
6130 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6131 if (fdh->elf.root.type == bfd_link_hash_defined
6132 || fdh->elf.root.type == bfd_link_hash_defweak)
6138 /* Mark all our entry sym sections, both opd and code section. */
6141 ppc64_elf_gc_keep (struct bfd_link_info *info)
6143 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6144 struct bfd_sym_chain *sym;
6149 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6151 struct ppc_link_hash_entry *eh, *fh;
6154 eh = (struct ppc_link_hash_entry *)
6155 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6158 if (eh->elf.root.type != bfd_link_hash_defined
6159 && eh->elf.root.type != bfd_link_hash_defweak)
6162 fh = defined_code_entry (eh);
6165 sec = fh->elf.root.u.def.section;
6166 sec->flags |= SEC_KEEP;
6168 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6169 && opd_entry_value (eh->elf.root.u.def.section,
6170 eh->elf.root.u.def.value,
6171 &sec, NULL, FALSE) != (bfd_vma) -1)
6172 sec->flags |= SEC_KEEP;
6174 sec = eh->elf.root.u.def.section;
6175 sec->flags |= SEC_KEEP;
6179 /* Mark sections containing dynamically referenced symbols. When
6180 building shared libraries, we must assume that any visible symbol is
6184 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6186 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6187 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6188 struct ppc_link_hash_entry *fdh;
6189 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6191 /* Dynamic linking info is on the func descriptor sym. */
6192 fdh = defined_func_desc (eh);
6196 if ((eh->elf.root.type == bfd_link_hash_defined
6197 || eh->elf.root.type == bfd_link_hash_defweak)
6198 && (eh->elf.ref_dynamic
6199 || (eh->elf.def_regular
6200 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6201 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6202 && (!info->executable
6203 || info->export_dynamic
6206 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6207 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6208 || !bfd_hide_sym_by_version (info->version_info,
6209 eh->elf.root.root.string)))))
6212 struct ppc_link_hash_entry *fh;
6214 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6216 /* Function descriptor syms cause the associated
6217 function code sym section to be marked. */
6218 fh = defined_code_entry (eh);
6221 code_sec = fh->elf.root.u.def.section;
6222 code_sec->flags |= SEC_KEEP;
6224 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6225 && opd_entry_value (eh->elf.root.u.def.section,
6226 eh->elf.root.u.def.value,
6227 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6228 code_sec->flags |= SEC_KEEP;
6234 /* Return the section that should be marked against GC for a given
6238 ppc64_elf_gc_mark_hook (asection *sec,
6239 struct bfd_link_info *info,
6240 Elf_Internal_Rela *rel,
6241 struct elf_link_hash_entry *h,
6242 Elf_Internal_Sym *sym)
6246 /* Syms return NULL if we're marking .opd, so we avoid marking all
6247 function sections, as all functions are referenced in .opd. */
6249 if (get_opd_info (sec) != NULL)
6254 enum elf_ppc64_reloc_type r_type;
6255 struct ppc_link_hash_entry *eh, *fh, *fdh;
6257 r_type = ELF64_R_TYPE (rel->r_info);
6260 case R_PPC64_GNU_VTINHERIT:
6261 case R_PPC64_GNU_VTENTRY:
6265 switch (h->root.type)
6267 case bfd_link_hash_defined:
6268 case bfd_link_hash_defweak:
6269 eh = (struct ppc_link_hash_entry *) h;
6270 fdh = defined_func_desc (eh);
6274 /* Function descriptor syms cause the associated
6275 function code sym section to be marked. */
6276 fh = defined_code_entry (eh);
6279 /* They also mark their opd section. */
6280 eh->elf.root.u.def.section->gc_mark = 1;
6282 rsec = fh->elf.root.u.def.section;
6284 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6285 && opd_entry_value (eh->elf.root.u.def.section,
6286 eh->elf.root.u.def.value,
6287 &rsec, NULL, FALSE) != (bfd_vma) -1)
6288 eh->elf.root.u.def.section->gc_mark = 1;
6290 rsec = h->root.u.def.section;
6293 case bfd_link_hash_common:
6294 rsec = h->root.u.c.p->section;
6298 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6304 struct _opd_sec_data *opd;
6306 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6307 opd = get_opd_info (rsec);
6308 if (opd != NULL && opd->func_sec != NULL)
6312 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6319 /* Update the .got, .plt. and dynamic reloc reference counts for the
6320 section being removed. */
6323 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6324 asection *sec, const Elf_Internal_Rela *relocs)
6326 struct ppc_link_hash_table *htab;
6327 Elf_Internal_Shdr *symtab_hdr;
6328 struct elf_link_hash_entry **sym_hashes;
6329 struct got_entry **local_got_ents;
6330 const Elf_Internal_Rela *rel, *relend;
6332 if (info->relocatable)
6335 if ((sec->flags & SEC_ALLOC) == 0)
6338 elf_section_data (sec)->local_dynrel = NULL;
6340 htab = ppc_hash_table (info);
6344 symtab_hdr = &elf_symtab_hdr (abfd);
6345 sym_hashes = elf_sym_hashes (abfd);
6346 local_got_ents = elf_local_got_ents (abfd);
6348 relend = relocs + sec->reloc_count;
6349 for (rel = relocs; rel < relend; rel++)
6351 unsigned long r_symndx;
6352 enum elf_ppc64_reloc_type r_type;
6353 struct elf_link_hash_entry *h = NULL;
6354 unsigned char tls_type = 0;
6356 r_symndx = ELF64_R_SYM (rel->r_info);
6357 r_type = ELF64_R_TYPE (rel->r_info);
6358 if (r_symndx >= symtab_hdr->sh_info)
6360 struct ppc_link_hash_entry *eh;
6361 struct elf_dyn_relocs **pp;
6362 struct elf_dyn_relocs *p;
6364 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6365 h = elf_follow_link (h);
6366 eh = (struct ppc_link_hash_entry *) h;
6368 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6371 /* Everything must go for SEC. */
6377 if (is_branch_reloc (r_type))
6379 struct plt_entry **ifunc = NULL;
6382 if (h->type == STT_GNU_IFUNC)
6383 ifunc = &h->plt.plist;
6385 else if (local_got_ents != NULL)
6387 struct plt_entry **local_plt = (struct plt_entry **)
6388 (local_got_ents + symtab_hdr->sh_info);
6389 unsigned char *local_got_tls_masks = (unsigned char *)
6390 (local_plt + symtab_hdr->sh_info);
6391 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6392 ifunc = local_plt + r_symndx;
6396 struct plt_entry *ent;
6398 for (ent = *ifunc; ent != NULL; ent = ent->next)
6399 if (ent->addend == rel->r_addend)
6403 if (ent->plt.refcount > 0)
6404 ent->plt.refcount -= 1;
6411 case R_PPC64_GOT_TLSLD16:
6412 case R_PPC64_GOT_TLSLD16_LO:
6413 case R_PPC64_GOT_TLSLD16_HI:
6414 case R_PPC64_GOT_TLSLD16_HA:
6415 tls_type = TLS_TLS | TLS_LD;
6418 case R_PPC64_GOT_TLSGD16:
6419 case R_PPC64_GOT_TLSGD16_LO:
6420 case R_PPC64_GOT_TLSGD16_HI:
6421 case R_PPC64_GOT_TLSGD16_HA:
6422 tls_type = TLS_TLS | TLS_GD;
6425 case R_PPC64_GOT_TPREL16_DS:
6426 case R_PPC64_GOT_TPREL16_LO_DS:
6427 case R_PPC64_GOT_TPREL16_HI:
6428 case R_PPC64_GOT_TPREL16_HA:
6429 tls_type = TLS_TLS | TLS_TPREL;
6432 case R_PPC64_GOT_DTPREL16_DS:
6433 case R_PPC64_GOT_DTPREL16_LO_DS:
6434 case R_PPC64_GOT_DTPREL16_HI:
6435 case R_PPC64_GOT_DTPREL16_HA:
6436 tls_type = TLS_TLS | TLS_DTPREL;
6440 case R_PPC64_GOT16_DS:
6441 case R_PPC64_GOT16_HA:
6442 case R_PPC64_GOT16_HI:
6443 case R_PPC64_GOT16_LO:
6444 case R_PPC64_GOT16_LO_DS:
6447 struct got_entry *ent;
6452 ent = local_got_ents[r_symndx];
6454 for (; ent != NULL; ent = ent->next)
6455 if (ent->addend == rel->r_addend
6456 && ent->owner == abfd
6457 && ent->tls_type == tls_type)
6461 if (ent->got.refcount > 0)
6462 ent->got.refcount -= 1;
6466 case R_PPC64_PLT16_HA:
6467 case R_PPC64_PLT16_HI:
6468 case R_PPC64_PLT16_LO:
6472 case R_PPC64_REL14_BRNTAKEN:
6473 case R_PPC64_REL14_BRTAKEN:
6477 struct plt_entry *ent;
6479 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6480 if (ent->addend == rel->r_addend)
6482 if (ent != NULL && ent->plt.refcount > 0)
6483 ent->plt.refcount -= 1;
6494 /* The maximum size of .sfpr. */
6495 #define SFPR_MAX (218*4)
6497 struct sfpr_def_parms
6499 const char name[12];
6500 unsigned char lo, hi;
6501 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6502 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6505 /* Auto-generate _save*, _rest* functions in .sfpr. */
6508 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6510 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6512 size_t len = strlen (parm->name);
6513 bfd_boolean writing = FALSE;
6519 memcpy (sym, parm->name, len);
6522 for (i = parm->lo; i <= parm->hi; i++)
6524 struct elf_link_hash_entry *h;
6526 sym[len + 0] = i / 10 + '0';
6527 sym[len + 1] = i % 10 + '0';
6528 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6532 h->root.type = bfd_link_hash_defined;
6533 h->root.u.def.section = htab->sfpr;
6534 h->root.u.def.value = htab->sfpr->size;
6537 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6539 if (htab->sfpr->contents == NULL)
6541 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6542 if (htab->sfpr->contents == NULL)
6548 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6550 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6552 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6553 htab->sfpr->size = p - htab->sfpr->contents;
6561 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6563 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6568 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6570 p = savegpr0 (abfd, p, r);
6571 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6573 bfd_put_32 (abfd, BLR, p);
6578 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6580 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6587 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6589 p = restgpr0 (abfd, p, r);
6590 bfd_put_32 (abfd, MTLR_R0, p);
6594 p = restgpr0 (abfd, p, 30);
6595 p = restgpr0 (abfd, p, 31);
6597 bfd_put_32 (abfd, BLR, p);
6602 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6604 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6609 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6611 p = savegpr1 (abfd, p, r);
6612 bfd_put_32 (abfd, BLR, p);
6617 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6619 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6624 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6626 p = restgpr1 (abfd, p, r);
6627 bfd_put_32 (abfd, BLR, p);
6632 savefpr (bfd *abfd, bfd_byte *p, int r)
6634 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6639 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6641 p = savefpr (abfd, p, r);
6642 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6644 bfd_put_32 (abfd, BLR, p);
6649 restfpr (bfd *abfd, bfd_byte *p, int r)
6651 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6656 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6658 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6660 p = restfpr (abfd, p, r);
6661 bfd_put_32 (abfd, MTLR_R0, p);
6665 p = restfpr (abfd, p, 30);
6666 p = restfpr (abfd, p, 31);
6668 bfd_put_32 (abfd, BLR, p);
6673 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6675 p = savefpr (abfd, p, r);
6676 bfd_put_32 (abfd, BLR, p);
6681 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6683 p = restfpr (abfd, p, r);
6684 bfd_put_32 (abfd, BLR, p);
6689 savevr (bfd *abfd, bfd_byte *p, int r)
6691 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6693 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6698 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6700 p = savevr (abfd, p, r);
6701 bfd_put_32 (abfd, BLR, p);
6706 restvr (bfd *abfd, bfd_byte *p, int r)
6708 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6710 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6715 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6717 p = restvr (abfd, p, r);
6718 bfd_put_32 (abfd, BLR, p);
6722 /* Called via elf_link_hash_traverse to transfer dynamic linking
6723 information on function code symbol entries to their corresponding
6724 function descriptor symbol entries. */
6727 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6729 struct bfd_link_info *info;
6730 struct ppc_link_hash_table *htab;
6731 struct plt_entry *ent;
6732 struct ppc_link_hash_entry *fh;
6733 struct ppc_link_hash_entry *fdh;
6734 bfd_boolean force_local;
6736 fh = (struct ppc_link_hash_entry *) h;
6737 if (fh->elf.root.type == bfd_link_hash_indirect)
6741 htab = ppc_hash_table (info);
6745 /* Resolve undefined references to dot-symbols as the value
6746 in the function descriptor, if we have one in a regular object.
6747 This is to satisfy cases like ".quad .foo". Calls to functions
6748 in dynamic objects are handled elsewhere. */
6749 if (fh->elf.root.type == bfd_link_hash_undefweak
6750 && fh->was_undefined
6751 && (fdh = defined_func_desc (fh)) != NULL
6752 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6753 && opd_entry_value (fdh->elf.root.u.def.section,
6754 fdh->elf.root.u.def.value,
6755 &fh->elf.root.u.def.section,
6756 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6758 fh->elf.root.type = fdh->elf.root.type;
6759 fh->elf.forced_local = 1;
6760 fh->elf.def_regular = fdh->elf.def_regular;
6761 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6764 /* If this is a function code symbol, transfer dynamic linking
6765 information to the function descriptor symbol. */
6769 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6770 if (ent->plt.refcount > 0)
6773 || fh->elf.root.root.string[0] != '.'
6774 || fh->elf.root.root.string[1] == '\0')
6777 /* Find the corresponding function descriptor symbol. Create it
6778 as undefined if necessary. */
6780 fdh = lookup_fdh (fh, htab);
6782 && !info->executable
6783 && (fh->elf.root.type == bfd_link_hash_undefined
6784 || fh->elf.root.type == bfd_link_hash_undefweak))
6786 fdh = make_fdh (info, fh);
6791 /* Fake function descriptors are made undefweak. If the function
6792 code symbol is strong undefined, make the fake sym the same.
6793 If the function code symbol is defined, then force the fake
6794 descriptor local; We can't support overriding of symbols in a
6795 shared library on a fake descriptor. */
6799 && fdh->elf.root.type == bfd_link_hash_undefweak)
6801 if (fh->elf.root.type == bfd_link_hash_undefined)
6803 fdh->elf.root.type = bfd_link_hash_undefined;
6804 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6806 else if (fh->elf.root.type == bfd_link_hash_defined
6807 || fh->elf.root.type == bfd_link_hash_defweak)
6809 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6814 && !fdh->elf.forced_local
6815 && (!info->executable
6816 || fdh->elf.def_dynamic
6817 || fdh->elf.ref_dynamic
6818 || (fdh->elf.root.type == bfd_link_hash_undefweak
6819 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6821 if (fdh->elf.dynindx == -1)
6822 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6824 fdh->elf.ref_regular |= fh->elf.ref_regular;
6825 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6826 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6827 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6828 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6830 move_plt_plist (fh, fdh);
6831 fdh->elf.needs_plt = 1;
6833 fdh->is_func_descriptor = 1;
6838 /* Now that the info is on the function descriptor, clear the
6839 function code sym info. Any function code syms for which we
6840 don't have a definition in a regular file, we force local.
6841 This prevents a shared library from exporting syms that have
6842 been imported from another library. Function code syms that
6843 are really in the library we must leave global to prevent the
6844 linker dragging in a definition from a static library. */
6845 force_local = (!fh->elf.def_regular
6847 || !fdh->elf.def_regular
6848 || fdh->elf.forced_local);
6849 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6854 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6855 this hook to a) provide some gcc support functions, and b) transfer
6856 dynamic linking information gathered so far on function code symbol
6857 entries, to their corresponding function descriptor symbol entries. */
6860 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6861 struct bfd_link_info *info)
6863 struct ppc_link_hash_table *htab;
6865 static const struct sfpr_def_parms funcs[] =
6867 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6868 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6869 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6870 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6871 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6872 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6873 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6874 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6875 { "._savef", 14, 31, savefpr, savefpr1_tail },
6876 { "._restf", 14, 31, restfpr, restfpr1_tail },
6877 { "_savevr_", 20, 31, savevr, savevr_tail },
6878 { "_restvr_", 20, 31, restvr, restvr_tail }
6881 htab = ppc_hash_table (info);
6885 if (!info->relocatable
6886 && htab->elf.hgot != NULL)
6888 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6889 /* Make .TOC. defined so as to prevent it being made dynamic.
6890 The wrong value here is fixed later in ppc64_elf_set_toc. */
6891 htab->elf.hgot->type = STT_OBJECT;
6892 htab->elf.hgot->root.type = bfd_link_hash_defined;
6893 htab->elf.hgot->root.u.def.value = 0;
6894 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6895 htab->elf.hgot->def_regular = 1;
6896 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6900 if (htab->sfpr == NULL)
6901 /* We don't have any relocs. */
6904 /* Provide any missing _save* and _rest* functions. */
6905 htab->sfpr->size = 0;
6906 if (htab->params->save_restore_funcs)
6907 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6908 if (!sfpr_define (info, &funcs[i]))
6911 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6913 if (htab->sfpr->size == 0)
6914 htab->sfpr->flags |= SEC_EXCLUDE;
6919 /* Return true if we have dynamic relocs that apply to read-only sections. */
6922 readonly_dynrelocs (struct elf_link_hash_entry *h)
6924 struct ppc_link_hash_entry *eh;
6925 struct elf_dyn_relocs *p;
6927 eh = (struct ppc_link_hash_entry *) h;
6928 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6930 asection *s = p->sec->output_section;
6932 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6938 /* Adjust a symbol defined by a dynamic object and referenced by a
6939 regular object. The current definition is in some section of the
6940 dynamic object, but we're not including those sections. We have to
6941 change the definition to something the rest of the link can
6945 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6946 struct elf_link_hash_entry *h)
6948 struct ppc_link_hash_table *htab;
6951 htab = ppc_hash_table (info);
6955 /* Deal with function syms. */
6956 if (h->type == STT_FUNC
6957 || h->type == STT_GNU_IFUNC
6960 /* Clear procedure linkage table information for any symbol that
6961 won't need a .plt entry. */
6962 struct plt_entry *ent;
6963 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6964 if (ent->plt.refcount > 0)
6967 || (h->type != STT_GNU_IFUNC
6968 && (SYMBOL_CALLS_LOCAL (info, h)
6969 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6970 && h->root.type == bfd_link_hash_undefweak))))
6972 h->plt.plist = NULL;
6975 else if (abiversion (info->output_bfd) == 2)
6977 /* After adjust_dynamic_symbol, non_got_ref set in the
6978 non-shared case means that we have allocated space in
6979 .dynbss for the symbol and thus dyn_relocs for this
6980 symbol should be discarded.
6981 If we get here we know we are making a PLT entry for this
6982 symbol, and in an executable we'd normally resolve
6983 relocations against this symbol to the PLT entry. Allow
6984 dynamic relocs if the reference is weak, and the dynamic
6985 relocs will not cause text relocation. */
6986 if (!h->ref_regular_nonweak
6988 && h->type != STT_GNU_IFUNC
6989 && !readonly_dynrelocs (h))
6992 /* If making a plt entry, then we don't need copy relocs. */
6997 h->plt.plist = NULL;
6999 /* If this is a weak symbol, and there is a real definition, the
7000 processor independent code will have arranged for us to see the
7001 real definition first, and we can just use the same value. */
7002 if (h->u.weakdef != NULL)
7004 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7005 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7006 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7007 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7008 if (ELIMINATE_COPY_RELOCS)
7009 h->non_got_ref = h->u.weakdef->non_got_ref;
7013 /* If we are creating a shared library, we must presume that the
7014 only references to the symbol are via the global offset table.
7015 For such cases we need not do anything here; the relocations will
7016 be handled correctly by relocate_section. */
7020 /* If there are no references to this symbol that do not use the
7021 GOT, we don't need to generate a copy reloc. */
7022 if (!h->non_got_ref)
7025 /* Don't generate a copy reloc for symbols defined in the executable. */
7026 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7029 /* If we didn't find any dynamic relocs in read-only sections, then
7030 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7031 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7037 if (h->plt.plist != NULL)
7039 /* We should never get here, but unfortunately there are versions
7040 of gcc out there that improperly (for this ABI) put initialized
7041 function pointers, vtable refs and suchlike in read-only
7042 sections. Allow them to proceed, but warn that this might
7043 break at runtime. */
7044 info->callbacks->einfo
7045 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7046 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7047 h->root.root.string);
7050 /* This is a reference to a symbol defined by a dynamic object which
7051 is not a function. */
7053 /* We must allocate the symbol in our .dynbss section, which will
7054 become part of the .bss section of the executable. There will be
7055 an entry for this symbol in the .dynsym section. The dynamic
7056 object will contain position independent code, so all references
7057 from the dynamic object to this symbol will go through the global
7058 offset table. The dynamic linker will use the .dynsym entry to
7059 determine the address it must put in the global offset table, so
7060 both the dynamic object and the regular object will refer to the
7061 same memory location for the variable. */
7063 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7064 to copy the initial value out of the dynamic object and into the
7065 runtime process image. We need to remember the offset into the
7066 .rela.bss section we are going to use. */
7067 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7069 htab->relbss->size += sizeof (Elf64_External_Rela);
7075 return _bfd_elf_adjust_dynamic_copy (h, s);
7078 /* If given a function descriptor symbol, hide both the function code
7079 sym and the descriptor. */
7081 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7082 struct elf_link_hash_entry *h,
7083 bfd_boolean force_local)
7085 struct ppc_link_hash_entry *eh;
7086 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7088 eh = (struct ppc_link_hash_entry *) h;
7089 if (eh->is_func_descriptor)
7091 struct ppc_link_hash_entry *fh = eh->oh;
7096 struct ppc_link_hash_table *htab;
7099 /* We aren't supposed to use alloca in BFD because on
7100 systems which do not have alloca the version in libiberty
7101 calls xmalloc, which might cause the program to crash
7102 when it runs out of memory. This function doesn't have a
7103 return status, so there's no way to gracefully return an
7104 error. So cheat. We know that string[-1] can be safely
7105 accessed; It's either a string in an ELF string table,
7106 or allocated in an objalloc structure. */
7108 p = eh->elf.root.root.string - 1;
7111 htab = ppc_hash_table (info);
7115 fh = (struct ppc_link_hash_entry *)
7116 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7119 /* Unfortunately, if it so happens that the string we were
7120 looking for was allocated immediately before this string,
7121 then we overwrote the string terminator. That's the only
7122 reason the lookup should fail. */
7125 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7126 while (q >= eh->elf.root.root.string && *q == *p)
7128 if (q < eh->elf.root.root.string && *p == '.')
7129 fh = (struct ppc_link_hash_entry *)
7130 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7139 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7144 get_sym_h (struct elf_link_hash_entry **hp,
7145 Elf_Internal_Sym **symp,
7147 unsigned char **tls_maskp,
7148 Elf_Internal_Sym **locsymsp,
7149 unsigned long r_symndx,
7152 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7154 if (r_symndx >= symtab_hdr->sh_info)
7156 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7157 struct elf_link_hash_entry *h;
7159 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7160 h = elf_follow_link (h);
7168 if (symsecp != NULL)
7170 asection *symsec = NULL;
7171 if (h->root.type == bfd_link_hash_defined
7172 || h->root.type == bfd_link_hash_defweak)
7173 symsec = h->root.u.def.section;
7177 if (tls_maskp != NULL)
7179 struct ppc_link_hash_entry *eh;
7181 eh = (struct ppc_link_hash_entry *) h;
7182 *tls_maskp = &eh->tls_mask;
7187 Elf_Internal_Sym *sym;
7188 Elf_Internal_Sym *locsyms = *locsymsp;
7190 if (locsyms == NULL)
7192 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7193 if (locsyms == NULL)
7194 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7195 symtab_hdr->sh_info,
7196 0, NULL, NULL, NULL);
7197 if (locsyms == NULL)
7199 *locsymsp = locsyms;
7201 sym = locsyms + r_symndx;
7209 if (symsecp != NULL)
7210 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7212 if (tls_maskp != NULL)
7214 struct got_entry **lgot_ents;
7215 unsigned char *tls_mask;
7218 lgot_ents = elf_local_got_ents (ibfd);
7219 if (lgot_ents != NULL)
7221 struct plt_entry **local_plt = (struct plt_entry **)
7222 (lgot_ents + symtab_hdr->sh_info);
7223 unsigned char *lgot_masks = (unsigned char *)
7224 (local_plt + symtab_hdr->sh_info);
7225 tls_mask = &lgot_masks[r_symndx];
7227 *tls_maskp = tls_mask;
7233 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7234 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7235 type suitable for optimization, and 1 otherwise. */
7238 get_tls_mask (unsigned char **tls_maskp,
7239 unsigned long *toc_symndx,
7240 bfd_vma *toc_addend,
7241 Elf_Internal_Sym **locsymsp,
7242 const Elf_Internal_Rela *rel,
7245 unsigned long r_symndx;
7247 struct elf_link_hash_entry *h;
7248 Elf_Internal_Sym *sym;
7252 r_symndx = ELF64_R_SYM (rel->r_info);
7253 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7256 if ((*tls_maskp != NULL && **tls_maskp != 0)
7258 || ppc64_elf_section_data (sec) == NULL
7259 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7262 /* Look inside a TOC section too. */
7265 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7266 off = h->root.u.def.value;
7269 off = sym->st_value;
7270 off += rel->r_addend;
7271 BFD_ASSERT (off % 8 == 0);
7272 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7273 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7274 if (toc_symndx != NULL)
7275 *toc_symndx = r_symndx;
7276 if (toc_addend != NULL)
7277 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7278 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7280 if ((h == NULL || is_static_defined (h))
7281 && (next_r == -1 || next_r == -2))
7286 /* Find (or create) an entry in the tocsave hash table. */
7288 static struct tocsave_entry *
7289 tocsave_find (struct ppc_link_hash_table *htab,
7290 enum insert_option insert,
7291 Elf_Internal_Sym **local_syms,
7292 const Elf_Internal_Rela *irela,
7295 unsigned long r_indx;
7296 struct elf_link_hash_entry *h;
7297 Elf_Internal_Sym *sym;
7298 struct tocsave_entry ent, *p;
7300 struct tocsave_entry **slot;
7302 r_indx = ELF64_R_SYM (irela->r_info);
7303 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7305 if (ent.sec == NULL || ent.sec->output_section == NULL)
7307 (*_bfd_error_handler)
7308 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7313 ent.offset = h->root.u.def.value;
7315 ent.offset = sym->st_value;
7316 ent.offset += irela->r_addend;
7318 hash = tocsave_htab_hash (&ent);
7319 slot = ((struct tocsave_entry **)
7320 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7326 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7335 /* Adjust all global syms defined in opd sections. In gcc generated
7336 code for the old ABI, these will already have been done. */
7339 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7341 struct ppc_link_hash_entry *eh;
7343 struct _opd_sec_data *opd;
7345 if (h->root.type == bfd_link_hash_indirect)
7348 if (h->root.type != bfd_link_hash_defined
7349 && h->root.type != bfd_link_hash_defweak)
7352 eh = (struct ppc_link_hash_entry *) h;
7353 if (eh->adjust_done)
7356 sym_sec = eh->elf.root.u.def.section;
7357 opd = get_opd_info (sym_sec);
7358 if (opd != NULL && opd->adjust != NULL)
7360 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7363 /* This entry has been deleted. */
7364 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7367 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7368 if (discarded_section (dsec))
7370 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7374 eh->elf.root.u.def.value = 0;
7375 eh->elf.root.u.def.section = dsec;
7378 eh->elf.root.u.def.value += adjust;
7379 eh->adjust_done = 1;
7384 /* Handles decrementing dynamic reloc counts for the reloc specified by
7385 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7386 have already been determined. */
7389 dec_dynrel_count (bfd_vma r_info,
7391 struct bfd_link_info *info,
7392 Elf_Internal_Sym **local_syms,
7393 struct elf_link_hash_entry *h,
7394 Elf_Internal_Sym *sym)
7396 enum elf_ppc64_reloc_type r_type;
7397 asection *sym_sec = NULL;
7399 /* Can this reloc be dynamic? This switch, and later tests here
7400 should be kept in sync with the code in check_relocs. */
7401 r_type = ELF64_R_TYPE (r_info);
7407 case R_PPC64_TPREL16:
7408 case R_PPC64_TPREL16_LO:
7409 case R_PPC64_TPREL16_HI:
7410 case R_PPC64_TPREL16_HA:
7411 case R_PPC64_TPREL16_DS:
7412 case R_PPC64_TPREL16_LO_DS:
7413 case R_PPC64_TPREL16_HIGH:
7414 case R_PPC64_TPREL16_HIGHA:
7415 case R_PPC64_TPREL16_HIGHER:
7416 case R_PPC64_TPREL16_HIGHERA:
7417 case R_PPC64_TPREL16_HIGHEST:
7418 case R_PPC64_TPREL16_HIGHESTA:
7422 case R_PPC64_TPREL64:
7423 case R_PPC64_DTPMOD64:
7424 case R_PPC64_DTPREL64:
7425 case R_PPC64_ADDR64:
7429 case R_PPC64_ADDR14:
7430 case R_PPC64_ADDR14_BRNTAKEN:
7431 case R_PPC64_ADDR14_BRTAKEN:
7432 case R_PPC64_ADDR16:
7433 case R_PPC64_ADDR16_DS:
7434 case R_PPC64_ADDR16_HA:
7435 case R_PPC64_ADDR16_HI:
7436 case R_PPC64_ADDR16_HIGH:
7437 case R_PPC64_ADDR16_HIGHA:
7438 case R_PPC64_ADDR16_HIGHER:
7439 case R_PPC64_ADDR16_HIGHERA:
7440 case R_PPC64_ADDR16_HIGHEST:
7441 case R_PPC64_ADDR16_HIGHESTA:
7442 case R_PPC64_ADDR16_LO:
7443 case R_PPC64_ADDR16_LO_DS:
7444 case R_PPC64_ADDR24:
7445 case R_PPC64_ADDR32:
7446 case R_PPC64_UADDR16:
7447 case R_PPC64_UADDR32:
7448 case R_PPC64_UADDR64:
7453 if (local_syms != NULL)
7455 unsigned long r_symndx;
7456 bfd *ibfd = sec->owner;
7458 r_symndx = ELF64_R_SYM (r_info);
7459 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7464 && (must_be_dyn_reloc (info, r_type)
7466 && (!SYMBOLIC_BIND (info, h)
7467 || h->root.type == bfd_link_hash_defweak
7468 || !h->def_regular))))
7469 || (ELIMINATE_COPY_RELOCS
7472 && (h->root.type == bfd_link_hash_defweak
7473 || !h->def_regular)))
7480 struct elf_dyn_relocs *p;
7481 struct elf_dyn_relocs **pp;
7482 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7484 /* elf_gc_sweep may have already removed all dyn relocs associated
7485 with local syms for a given section. Also, symbol flags are
7486 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7487 report a dynreloc miscount. */
7488 if (*pp == NULL && info->gc_sections)
7491 while ((p = *pp) != NULL)
7495 if (!must_be_dyn_reloc (info, r_type))
7507 struct ppc_dyn_relocs *p;
7508 struct ppc_dyn_relocs **pp;
7510 bfd_boolean is_ifunc;
7512 if (local_syms == NULL)
7513 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7514 if (sym_sec == NULL)
7517 vpp = &elf_section_data (sym_sec)->local_dynrel;
7518 pp = (struct ppc_dyn_relocs **) vpp;
7520 if (*pp == NULL && info->gc_sections)
7523 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7524 while ((p = *pp) != NULL)
7526 if (p->sec == sec && p->ifunc == is_ifunc)
7537 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7539 bfd_set_error (bfd_error_bad_value);
7543 /* Remove unused Official Procedure Descriptor entries. Currently we
7544 only remove those associated with functions in discarded link-once
7545 sections, or weakly defined functions that have been overridden. It
7546 would be possible to remove many more entries for statically linked
7550 ppc64_elf_edit_opd (struct bfd_link_info *info)
7553 bfd_boolean some_edited = FALSE;
7554 asection *need_pad = NULL;
7555 struct ppc_link_hash_table *htab;
7557 htab = ppc_hash_table (info);
7561 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7564 Elf_Internal_Rela *relstart, *rel, *relend;
7565 Elf_Internal_Shdr *symtab_hdr;
7566 Elf_Internal_Sym *local_syms;
7568 struct _opd_sec_data *opd;
7569 bfd_boolean need_edit, add_aux_fields;
7570 bfd_size_type cnt_16b = 0;
7572 if (!is_ppc64_elf (ibfd))
7575 sec = bfd_get_section_by_name (ibfd, ".opd");
7576 if (sec == NULL || sec->size == 0)
7579 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7582 if (sec->output_section == bfd_abs_section_ptr)
7585 /* Look through the section relocs. */
7586 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7590 symtab_hdr = &elf_symtab_hdr (ibfd);
7592 /* Read the relocations. */
7593 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7595 if (relstart == NULL)
7598 /* First run through the relocs to check they are sane, and to
7599 determine whether we need to edit this opd section. */
7603 relend = relstart + sec->reloc_count;
7604 for (rel = relstart; rel < relend; )
7606 enum elf_ppc64_reloc_type r_type;
7607 unsigned long r_symndx;
7609 struct elf_link_hash_entry *h;
7610 Elf_Internal_Sym *sym;
7612 /* .opd contains a regular array of 16 or 24 byte entries. We're
7613 only interested in the reloc pointing to a function entry
7615 if (rel->r_offset != offset
7616 || rel + 1 >= relend
7617 || (rel + 1)->r_offset != offset + 8)
7619 /* If someone messes with .opd alignment then after a
7620 "ld -r" we might have padding in the middle of .opd.
7621 Also, there's nothing to prevent someone putting
7622 something silly in .opd with the assembler. No .opd
7623 optimization for them! */
7625 (*_bfd_error_handler)
7626 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7631 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7632 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7634 (*_bfd_error_handler)
7635 (_("%B: unexpected reloc type %u in .opd section"),
7641 r_symndx = ELF64_R_SYM (rel->r_info);
7642 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7646 if (sym_sec == NULL || sym_sec->owner == NULL)
7648 const char *sym_name;
7650 sym_name = h->root.root.string;
7652 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7655 (*_bfd_error_handler)
7656 (_("%B: undefined sym `%s' in .opd section"),
7662 /* opd entries are always for functions defined in the
7663 current input bfd. If the symbol isn't defined in the
7664 input bfd, then we won't be using the function in this
7665 bfd; It must be defined in a linkonce section in another
7666 bfd, or is weak. It's also possible that we are
7667 discarding the function due to a linker script /DISCARD/,
7668 which we test for via the output_section. */
7669 if (sym_sec->owner != ibfd
7670 || sym_sec->output_section == bfd_abs_section_ptr)
7675 || (rel + 1 == relend && rel->r_offset == offset + 16))
7677 if (sec->size == offset + 24)
7682 if (rel == relend && sec->size == offset + 16)
7690 if (rel->r_offset == offset + 24)
7692 else if (rel->r_offset != offset + 16)
7694 else if (rel + 1 < relend
7695 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7696 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7701 else if (rel + 2 < relend
7702 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7703 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7712 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7714 if (need_edit || add_aux_fields)
7716 Elf_Internal_Rela *write_rel;
7717 Elf_Internal_Shdr *rel_hdr;
7718 bfd_byte *rptr, *wptr;
7719 bfd_byte *new_contents;
7724 new_contents = NULL;
7725 amt = sec->size * sizeof (long) / 8;
7726 opd = &ppc64_elf_section_data (sec)->u.opd;
7727 opd->adjust = bfd_zalloc (sec->owner, amt);
7728 if (opd->adjust == NULL)
7730 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7732 /* This seems a waste of time as input .opd sections are all
7733 zeros as generated by gcc, but I suppose there's no reason
7734 this will always be so. We might start putting something in
7735 the third word of .opd entries. */
7736 if ((sec->flags & SEC_IN_MEMORY) == 0)
7739 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7744 if (local_syms != NULL
7745 && symtab_hdr->contents != (unsigned char *) local_syms)
7747 if (elf_section_data (sec)->relocs != relstart)
7751 sec->contents = loc;
7752 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7755 elf_section_data (sec)->relocs = relstart;
7757 new_contents = sec->contents;
7760 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7761 if (new_contents == NULL)
7765 wptr = new_contents;
7766 rptr = sec->contents;
7768 write_rel = relstart;
7772 for (rel = relstart; rel < relend; rel++)
7774 unsigned long r_symndx;
7776 struct elf_link_hash_entry *h;
7777 Elf_Internal_Sym *sym;
7779 r_symndx = ELF64_R_SYM (rel->r_info);
7780 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7784 if (rel->r_offset == offset)
7786 struct ppc_link_hash_entry *fdh = NULL;
7788 /* See if the .opd entry is full 24 byte or
7789 16 byte (with fd_aux entry overlapped with next
7792 if ((rel + 2 == relend && sec->size == offset + 16)
7793 || (rel + 3 < relend
7794 && rel[2].r_offset == offset + 16
7795 && rel[3].r_offset == offset + 24
7796 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7797 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7801 && h->root.root.string[0] == '.')
7803 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7805 && fdh->elf.root.type != bfd_link_hash_defined
7806 && fdh->elf.root.type != bfd_link_hash_defweak)
7810 skip = (sym_sec->owner != ibfd
7811 || sym_sec->output_section == bfd_abs_section_ptr);
7814 if (fdh != NULL && sym_sec->owner == ibfd)
7816 /* Arrange for the function descriptor sym
7818 fdh->elf.root.u.def.value = 0;
7819 fdh->elf.root.u.def.section = sym_sec;
7821 opd->adjust[rel->r_offset / 8] = -1;
7825 /* We'll be keeping this opd entry. */
7829 /* Redefine the function descriptor symbol to
7830 this location in the opd section. It is
7831 necessary to update the value here rather
7832 than using an array of adjustments as we do
7833 for local symbols, because various places
7834 in the generic ELF code use the value
7835 stored in u.def.value. */
7836 fdh->elf.root.u.def.value = wptr - new_contents;
7837 fdh->adjust_done = 1;
7840 /* Local syms are a bit tricky. We could
7841 tweak them as they can be cached, but
7842 we'd need to look through the local syms
7843 for the function descriptor sym which we
7844 don't have at the moment. So keep an
7845 array of adjustments. */
7846 opd->adjust[rel->r_offset / 8]
7847 = (wptr - new_contents) - (rptr - sec->contents);
7850 memcpy (wptr, rptr, opd_ent_size);
7851 wptr += opd_ent_size;
7852 if (add_aux_fields && opd_ent_size == 16)
7854 memset (wptr, '\0', 8);
7858 rptr += opd_ent_size;
7859 offset += opd_ent_size;
7865 && !info->relocatable
7866 && !dec_dynrel_count (rel->r_info, sec, info,
7872 /* We need to adjust any reloc offsets to point to the
7873 new opd entries. While we're at it, we may as well
7874 remove redundant relocs. */
7875 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7876 if (write_rel != rel)
7877 memcpy (write_rel, rel, sizeof (*rel));
7882 sec->size = wptr - new_contents;
7883 sec->reloc_count = write_rel - relstart;
7886 free (sec->contents);
7887 sec->contents = new_contents;
7890 /* Fudge the header size too, as this is used later in
7891 elf_bfd_final_link if we are emitting relocs. */
7892 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7893 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7896 else if (elf_section_data (sec)->relocs != relstart)
7899 if (local_syms != NULL
7900 && symtab_hdr->contents != (unsigned char *) local_syms)
7902 if (!info->keep_memory)
7905 symtab_hdr->contents = (unsigned char *) local_syms;
7910 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7912 /* If we are doing a final link and the last .opd entry is just 16 byte
7913 long, add a 8 byte padding after it. */
7914 if (need_pad != NULL && !info->relocatable)
7918 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7920 BFD_ASSERT (need_pad->size > 0);
7922 p = bfd_malloc (need_pad->size + 8);
7926 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7927 p, 0, need_pad->size))
7930 need_pad->contents = p;
7931 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7935 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7939 need_pad->contents = p;
7942 memset (need_pad->contents + need_pad->size, 0, 8);
7943 need_pad->size += 8;
7949 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7952 ppc64_elf_tls_setup (struct bfd_link_info *info)
7954 struct ppc_link_hash_table *htab;
7956 htab = ppc_hash_table (info);
7960 if (abiversion (info->output_bfd) == 1)
7963 if (htab->params->no_multi_toc)
7964 htab->do_multi_toc = 0;
7965 else if (!htab->do_multi_toc)
7966 htab->params->no_multi_toc = 1;
7968 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7969 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7970 FALSE, FALSE, TRUE));
7971 /* Move dynamic linking info to the function descriptor sym. */
7972 if (htab->tls_get_addr != NULL)
7973 func_desc_adjust (&htab->tls_get_addr->elf, info);
7974 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7975 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7976 FALSE, FALSE, TRUE));
7977 if (!htab->params->no_tls_get_addr_opt)
7979 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7981 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7982 FALSE, FALSE, TRUE);
7984 func_desc_adjust (opt, info);
7985 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7986 FALSE, FALSE, TRUE);
7988 && (opt_fd->root.type == bfd_link_hash_defined
7989 || opt_fd->root.type == bfd_link_hash_defweak))
7991 /* If glibc supports an optimized __tls_get_addr call stub,
7992 signalled by the presence of __tls_get_addr_opt, and we'll
7993 be calling __tls_get_addr via a plt call stub, then
7994 make __tls_get_addr point to __tls_get_addr_opt. */
7995 tga_fd = &htab->tls_get_addr_fd->elf;
7996 if (htab->elf.dynamic_sections_created
7998 && (tga_fd->type == STT_FUNC
7999 || tga_fd->needs_plt)
8000 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8001 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8002 && tga_fd->root.type == bfd_link_hash_undefweak)))
8004 struct plt_entry *ent;
8006 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8007 if (ent->plt.refcount > 0)
8011 tga_fd->root.type = bfd_link_hash_indirect;
8012 tga_fd->root.u.i.link = &opt_fd->root;
8013 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8014 if (opt_fd->dynindx != -1)
8016 /* Use __tls_get_addr_opt in dynamic relocations. */
8017 opt_fd->dynindx = -1;
8018 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8019 opt_fd->dynstr_index);
8020 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8023 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8024 tga = &htab->tls_get_addr->elf;
8025 if (opt != NULL && tga != NULL)
8027 tga->root.type = bfd_link_hash_indirect;
8028 tga->root.u.i.link = &opt->root;
8029 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8030 _bfd_elf_link_hash_hide_symbol (info, opt,
8032 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8034 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8035 htab->tls_get_addr_fd->is_func_descriptor = 1;
8036 if (htab->tls_get_addr != NULL)
8038 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8039 htab->tls_get_addr->is_func = 1;
8045 htab->params->no_tls_get_addr_opt = TRUE;
8047 return _bfd_elf_tls_setup (info->output_bfd, info);
8050 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8054 branch_reloc_hash_match (const bfd *ibfd,
8055 const Elf_Internal_Rela *rel,
8056 const struct ppc_link_hash_entry *hash1,
8057 const struct ppc_link_hash_entry *hash2)
8059 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8060 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8061 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8063 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8065 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8066 struct elf_link_hash_entry *h;
8068 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8069 h = elf_follow_link (h);
8070 if (h == &hash1->elf || h == &hash2->elf)
8076 /* Run through all the TLS relocs looking for optimization
8077 opportunities. The linker has been hacked (see ppc64elf.em) to do
8078 a preliminary section layout so that we know the TLS segment
8079 offsets. We can't optimize earlier because some optimizations need
8080 to know the tp offset, and we need to optimize before allocating
8081 dynamic relocations. */
8084 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8088 struct ppc_link_hash_table *htab;
8089 unsigned char *toc_ref;
8092 if (info->relocatable || !info->executable)
8095 htab = ppc_hash_table (info);
8099 /* Make two passes over the relocs. On the first pass, mark toc
8100 entries involved with tls relocs, and check that tls relocs
8101 involved in setting up a tls_get_addr call are indeed followed by
8102 such a call. If they are not, we can't do any tls optimization.
8103 On the second pass twiddle tls_mask flags to notify
8104 relocate_section that optimization can be done, and adjust got
8105 and plt refcounts. */
8107 for (pass = 0; pass < 2; ++pass)
8108 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8110 Elf_Internal_Sym *locsyms = NULL;
8111 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8113 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8114 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8116 Elf_Internal_Rela *relstart, *rel, *relend;
8117 bfd_boolean found_tls_get_addr_arg = 0;
8119 /* Read the relocations. */
8120 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8122 if (relstart == NULL)
8128 relend = relstart + sec->reloc_count;
8129 for (rel = relstart; rel < relend; rel++)
8131 enum elf_ppc64_reloc_type r_type;
8132 unsigned long r_symndx;
8133 struct elf_link_hash_entry *h;
8134 Elf_Internal_Sym *sym;
8136 unsigned char *tls_mask;
8137 unsigned char tls_set, tls_clear, tls_type = 0;
8139 bfd_boolean ok_tprel, is_local;
8140 long toc_ref_index = 0;
8141 int expecting_tls_get_addr = 0;
8142 bfd_boolean ret = FALSE;
8144 r_symndx = ELF64_R_SYM (rel->r_info);
8145 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8149 if (elf_section_data (sec)->relocs != relstart)
8151 if (toc_ref != NULL)
8154 && (elf_symtab_hdr (ibfd).contents
8155 != (unsigned char *) locsyms))
8162 if (h->root.type == bfd_link_hash_defined
8163 || h->root.type == bfd_link_hash_defweak)
8164 value = h->root.u.def.value;
8165 else if (h->root.type == bfd_link_hash_undefweak)
8169 found_tls_get_addr_arg = 0;
8174 /* Symbols referenced by TLS relocs must be of type
8175 STT_TLS. So no need for .opd local sym adjust. */
8176 value = sym->st_value;
8185 && h->root.type == bfd_link_hash_undefweak)
8189 value += sym_sec->output_offset;
8190 value += sym_sec->output_section->vma;
8191 value -= htab->elf.tls_sec->vma;
8192 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8193 < (bfd_vma) 1 << 32);
8197 r_type = ELF64_R_TYPE (rel->r_info);
8198 /* If this section has old-style __tls_get_addr calls
8199 without marker relocs, then check that each
8200 __tls_get_addr call reloc is preceded by a reloc
8201 that conceivably belongs to the __tls_get_addr arg
8202 setup insn. If we don't find matching arg setup
8203 relocs, don't do any tls optimization. */
8205 && sec->has_tls_get_addr_call
8207 && (h == &htab->tls_get_addr->elf
8208 || h == &htab->tls_get_addr_fd->elf)
8209 && !found_tls_get_addr_arg
8210 && is_branch_reloc (r_type))
8212 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8213 "TLS optimization disabled\n"),
8214 ibfd, sec, rel->r_offset);
8219 found_tls_get_addr_arg = 0;
8222 case R_PPC64_GOT_TLSLD16:
8223 case R_PPC64_GOT_TLSLD16_LO:
8224 expecting_tls_get_addr = 1;
8225 found_tls_get_addr_arg = 1;
8228 case R_PPC64_GOT_TLSLD16_HI:
8229 case R_PPC64_GOT_TLSLD16_HA:
8230 /* These relocs should never be against a symbol
8231 defined in a shared lib. Leave them alone if
8232 that turns out to be the case. */
8239 tls_type = TLS_TLS | TLS_LD;
8242 case R_PPC64_GOT_TLSGD16:
8243 case R_PPC64_GOT_TLSGD16_LO:
8244 expecting_tls_get_addr = 1;
8245 found_tls_get_addr_arg = 1;
8248 case R_PPC64_GOT_TLSGD16_HI:
8249 case R_PPC64_GOT_TLSGD16_HA:
8255 tls_set = TLS_TLS | TLS_TPRELGD;
8257 tls_type = TLS_TLS | TLS_GD;
8260 case R_PPC64_GOT_TPREL16_DS:
8261 case R_PPC64_GOT_TPREL16_LO_DS:
8262 case R_PPC64_GOT_TPREL16_HI:
8263 case R_PPC64_GOT_TPREL16_HA:
8268 tls_clear = TLS_TPREL;
8269 tls_type = TLS_TLS | TLS_TPREL;
8276 found_tls_get_addr_arg = 1;
8281 case R_PPC64_TOC16_LO:
8282 if (sym_sec == NULL || sym_sec != toc)
8285 /* Mark this toc entry as referenced by a TLS
8286 code sequence. We can do that now in the
8287 case of R_PPC64_TLS, and after checking for
8288 tls_get_addr for the TOC16 relocs. */
8289 if (toc_ref == NULL)
8290 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8291 if (toc_ref == NULL)
8295 value = h->root.u.def.value;
8297 value = sym->st_value;
8298 value += rel->r_addend;
8299 BFD_ASSERT (value < toc->size && value % 8 == 0);
8300 toc_ref_index = (value + toc->output_offset) / 8;
8301 if (r_type == R_PPC64_TLS
8302 || r_type == R_PPC64_TLSGD
8303 || r_type == R_PPC64_TLSLD)
8305 toc_ref[toc_ref_index] = 1;
8309 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8314 expecting_tls_get_addr = 2;
8317 case R_PPC64_TPREL64:
8321 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8326 tls_set = TLS_EXPLICIT;
8327 tls_clear = TLS_TPREL;
8332 case R_PPC64_DTPMOD64:
8336 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8338 if (rel + 1 < relend
8340 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8341 && rel[1].r_offset == rel->r_offset + 8)
8345 tls_set = TLS_EXPLICIT | TLS_GD;
8348 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8357 tls_set = TLS_EXPLICIT;
8368 if (!expecting_tls_get_addr
8369 || !sec->has_tls_get_addr_call)
8372 if (rel + 1 < relend
8373 && branch_reloc_hash_match (ibfd, rel + 1,
8375 htab->tls_get_addr_fd))
8377 if (expecting_tls_get_addr == 2)
8379 /* Check for toc tls entries. */
8380 unsigned char *toc_tls;
8383 retval = get_tls_mask (&toc_tls, NULL, NULL,
8388 if (toc_tls != NULL)
8390 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8391 found_tls_get_addr_arg = 1;
8393 toc_ref[toc_ref_index] = 1;
8399 if (expecting_tls_get_addr != 1)
8402 /* Uh oh, we didn't find the expected call. We
8403 could just mark this symbol to exclude it
8404 from tls optimization but it's safer to skip
8405 the entire optimization. */
8406 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8407 "TLS optimization disabled\n"),
8408 ibfd, sec, rel->r_offset);
8413 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8415 struct plt_entry *ent;
8416 for (ent = htab->tls_get_addr->elf.plt.plist;
8419 if (ent->addend == 0)
8421 if (ent->plt.refcount > 0)
8423 ent->plt.refcount -= 1;
8424 expecting_tls_get_addr = 0;
8430 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8432 struct plt_entry *ent;
8433 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8436 if (ent->addend == 0)
8438 if (ent->plt.refcount > 0)
8439 ent->plt.refcount -= 1;
8447 if ((tls_set & TLS_EXPLICIT) == 0)
8449 struct got_entry *ent;
8451 /* Adjust got entry for this reloc. */
8455 ent = elf_local_got_ents (ibfd)[r_symndx];
8457 for (; ent != NULL; ent = ent->next)
8458 if (ent->addend == rel->r_addend
8459 && ent->owner == ibfd
8460 && ent->tls_type == tls_type)
8467 /* We managed to get rid of a got entry. */
8468 if (ent->got.refcount > 0)
8469 ent->got.refcount -= 1;
8474 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8475 we'll lose one or two dyn relocs. */
8476 if (!dec_dynrel_count (rel->r_info, sec, info,
8480 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8482 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8488 *tls_mask |= tls_set;
8489 *tls_mask &= ~tls_clear;
8492 if (elf_section_data (sec)->relocs != relstart)
8497 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8499 if (!info->keep_memory)
8502 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8506 if (toc_ref != NULL)
8511 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8512 the values of any global symbols in a toc section that has been
8513 edited. Globals in toc sections should be a rarity, so this function
8514 sets a flag if any are found in toc sections other than the one just
8515 edited, so that futher hash table traversals can be avoided. */
8517 struct adjust_toc_info
8520 unsigned long *skip;
8521 bfd_boolean global_toc_syms;
8524 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8527 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8529 struct ppc_link_hash_entry *eh;
8530 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8533 if (h->root.type != bfd_link_hash_defined
8534 && h->root.type != bfd_link_hash_defweak)
8537 eh = (struct ppc_link_hash_entry *) h;
8538 if (eh->adjust_done)
8541 if (eh->elf.root.u.def.section == toc_inf->toc)
8543 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8544 i = toc_inf->toc->rawsize >> 3;
8546 i = eh->elf.root.u.def.value >> 3;
8548 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8550 (*_bfd_error_handler)
8551 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8554 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8555 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8558 eh->elf.root.u.def.value -= toc_inf->skip[i];
8559 eh->adjust_done = 1;
8561 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8562 toc_inf->global_toc_syms = TRUE;
8567 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8570 ok_lo_toc_insn (unsigned int insn)
8572 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8573 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8574 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8575 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8576 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8577 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8578 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8579 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8580 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8581 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8582 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8583 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8584 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8585 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8586 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8588 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8589 && ((insn & 3) == 0 || (insn & 3) == 3))
8590 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8593 /* Examine all relocs referencing .toc sections in order to remove
8594 unused .toc entries. */
8597 ppc64_elf_edit_toc (struct bfd_link_info *info)
8600 struct adjust_toc_info toc_inf;
8601 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8603 htab->do_toc_opt = 1;
8604 toc_inf.global_toc_syms = TRUE;
8605 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8607 asection *toc, *sec;
8608 Elf_Internal_Shdr *symtab_hdr;
8609 Elf_Internal_Sym *local_syms;
8610 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8611 unsigned long *skip, *drop;
8612 unsigned char *used;
8613 unsigned char *keep, last, some_unused;
8615 if (!is_ppc64_elf (ibfd))
8618 toc = bfd_get_section_by_name (ibfd, ".toc");
8621 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8622 || discarded_section (toc))
8627 symtab_hdr = &elf_symtab_hdr (ibfd);
8629 /* Look at sections dropped from the final link. */
8632 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8634 if (sec->reloc_count == 0
8635 || !discarded_section (sec)
8636 || get_opd_info (sec)
8637 || (sec->flags & SEC_ALLOC) == 0
8638 || (sec->flags & SEC_DEBUGGING) != 0)
8641 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8642 if (relstart == NULL)
8645 /* Run through the relocs to see which toc entries might be
8647 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8649 enum elf_ppc64_reloc_type r_type;
8650 unsigned long r_symndx;
8652 struct elf_link_hash_entry *h;
8653 Elf_Internal_Sym *sym;
8656 r_type = ELF64_R_TYPE (rel->r_info);
8663 case R_PPC64_TOC16_LO:
8664 case R_PPC64_TOC16_HI:
8665 case R_PPC64_TOC16_HA:
8666 case R_PPC64_TOC16_DS:
8667 case R_PPC64_TOC16_LO_DS:
8671 r_symndx = ELF64_R_SYM (rel->r_info);
8672 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8680 val = h->root.u.def.value;
8682 val = sym->st_value;
8683 val += rel->r_addend;
8685 if (val >= toc->size)
8688 /* Anything in the toc ought to be aligned to 8 bytes.
8689 If not, don't mark as unused. */
8695 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8700 skip[val >> 3] = ref_from_discarded;
8703 if (elf_section_data (sec)->relocs != relstart)
8707 /* For largetoc loads of address constants, we can convert
8708 . addis rx,2,addr@got@ha
8709 . ld ry,addr@got@l(rx)
8711 . addis rx,2,addr@toc@ha
8712 . addi ry,rx,addr@toc@l
8713 when addr is within 2G of the toc pointer. This then means
8714 that the word storing "addr" in the toc is no longer needed. */
8716 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8717 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8718 && toc->reloc_count != 0)
8720 /* Read toc relocs. */
8721 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8723 if (toc_relocs == NULL)
8726 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8728 enum elf_ppc64_reloc_type r_type;
8729 unsigned long r_symndx;
8731 struct elf_link_hash_entry *h;
8732 Elf_Internal_Sym *sym;
8735 r_type = ELF64_R_TYPE (rel->r_info);
8736 if (r_type != R_PPC64_ADDR64)
8739 r_symndx = ELF64_R_SYM (rel->r_info);
8740 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8745 || discarded_section (sym_sec))
8748 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8753 if (h->type == STT_GNU_IFUNC)
8755 val = h->root.u.def.value;
8759 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8761 val = sym->st_value;
8763 val += rel->r_addend;
8764 val += sym_sec->output_section->vma + sym_sec->output_offset;
8766 /* We don't yet know the exact toc pointer value, but we
8767 know it will be somewhere in the toc section. Don't
8768 optimize if the difference from any possible toc
8769 pointer is outside [ff..f80008000, 7fff7fff]. */
8770 addr = toc->output_section->vma + TOC_BASE_OFF;
8771 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8774 addr = toc->output_section->vma + toc->output_section->rawsize;
8775 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8780 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8785 skip[rel->r_offset >> 3]
8786 |= can_optimize | ((rel - toc_relocs) << 2);
8793 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8797 if (local_syms != NULL
8798 && symtab_hdr->contents != (unsigned char *) local_syms)
8802 && elf_section_data (sec)->relocs != relstart)
8804 if (toc_relocs != NULL
8805 && elf_section_data (toc)->relocs != toc_relocs)
8812 /* Now check all kept sections that might reference the toc.
8813 Check the toc itself last. */
8814 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8817 sec = (sec == toc ? NULL
8818 : sec->next == NULL ? toc
8819 : sec->next == toc && toc->next ? toc->next
8824 if (sec->reloc_count == 0
8825 || discarded_section (sec)
8826 || get_opd_info (sec)
8827 || (sec->flags & SEC_ALLOC) == 0
8828 || (sec->flags & SEC_DEBUGGING) != 0)
8831 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8833 if (relstart == NULL)
8839 /* Mark toc entries referenced as used. */
8843 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8845 enum elf_ppc64_reloc_type r_type;
8846 unsigned long r_symndx;
8848 struct elf_link_hash_entry *h;
8849 Elf_Internal_Sym *sym;
8851 enum {no_check, check_lo, check_ha} insn_check;
8853 r_type = ELF64_R_TYPE (rel->r_info);
8857 insn_check = no_check;
8860 case R_PPC64_GOT_TLSLD16_HA:
8861 case R_PPC64_GOT_TLSGD16_HA:
8862 case R_PPC64_GOT_TPREL16_HA:
8863 case R_PPC64_GOT_DTPREL16_HA:
8864 case R_PPC64_GOT16_HA:
8865 case R_PPC64_TOC16_HA:
8866 insn_check = check_ha;
8869 case R_PPC64_GOT_TLSLD16_LO:
8870 case R_PPC64_GOT_TLSGD16_LO:
8871 case R_PPC64_GOT_TPREL16_LO_DS:
8872 case R_PPC64_GOT_DTPREL16_LO_DS:
8873 case R_PPC64_GOT16_LO:
8874 case R_PPC64_GOT16_LO_DS:
8875 case R_PPC64_TOC16_LO:
8876 case R_PPC64_TOC16_LO_DS:
8877 insn_check = check_lo;
8881 if (insn_check != no_check)
8883 bfd_vma off = rel->r_offset & ~3;
8884 unsigned char buf[4];
8887 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8892 insn = bfd_get_32 (ibfd, buf);
8893 if (insn_check == check_lo
8894 ? !ok_lo_toc_insn (insn)
8895 : ((insn & ((0x3f << 26) | 0x1f << 16))
8896 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8900 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8901 sprintf (str, "%#08x", insn);
8902 info->callbacks->einfo
8903 (_("%P: %H: toc optimization is not supported for"
8904 " %s instruction.\n"),
8905 ibfd, sec, rel->r_offset & ~3, str);
8912 case R_PPC64_TOC16_LO:
8913 case R_PPC64_TOC16_HI:
8914 case R_PPC64_TOC16_HA:
8915 case R_PPC64_TOC16_DS:
8916 case R_PPC64_TOC16_LO_DS:
8917 /* In case we're taking addresses of toc entries. */
8918 case R_PPC64_ADDR64:
8925 r_symndx = ELF64_R_SYM (rel->r_info);
8926 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8937 val = h->root.u.def.value;
8939 val = sym->st_value;
8940 val += rel->r_addend;
8942 if (val >= toc->size)
8945 if ((skip[val >> 3] & can_optimize) != 0)
8952 case R_PPC64_TOC16_HA:
8955 case R_PPC64_TOC16_LO_DS:
8956 off = rel->r_offset;
8957 off += (bfd_big_endian (ibfd) ? -2 : 3);
8958 if (!bfd_get_section_contents (ibfd, sec, &opc,
8964 if ((opc & (0x3f << 2)) == (58u << 2))
8969 /* Wrong sort of reloc, or not a ld. We may
8970 as well clear ref_from_discarded too. */
8977 /* For the toc section, we only mark as used if this
8978 entry itself isn't unused. */
8979 else if ((used[rel->r_offset >> 3]
8980 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8983 /* Do all the relocs again, to catch reference
8992 if (elf_section_data (sec)->relocs != relstart)
8996 /* Merge the used and skip arrays. Assume that TOC
8997 doublewords not appearing as either used or unused belong
8998 to to an entry more than one doubleword in size. */
8999 for (drop = skip, keep = used, last = 0, some_unused = 0;
9000 drop < skip + (toc->size + 7) / 8;
9005 *drop &= ~ref_from_discarded;
9006 if ((*drop & can_optimize) != 0)
9010 else if ((*drop & ref_from_discarded) != 0)
9013 last = ref_from_discarded;
9023 bfd_byte *contents, *src;
9025 Elf_Internal_Sym *sym;
9026 bfd_boolean local_toc_syms = FALSE;
9028 /* Shuffle the toc contents, and at the same time convert the
9029 skip array from booleans into offsets. */
9030 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9033 elf_section_data (toc)->this_hdr.contents = contents;
9035 for (src = contents, off = 0, drop = skip;
9036 src < contents + toc->size;
9039 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9044 memcpy (src - off, src, 8);
9048 toc->rawsize = toc->size;
9049 toc->size = src - contents - off;
9051 /* Adjust addends for relocs against the toc section sym,
9052 and optimize any accesses we can. */
9053 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9055 if (sec->reloc_count == 0
9056 || discarded_section (sec))
9059 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9061 if (relstart == NULL)
9064 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9066 enum elf_ppc64_reloc_type r_type;
9067 unsigned long r_symndx;
9069 struct elf_link_hash_entry *h;
9072 r_type = ELF64_R_TYPE (rel->r_info);
9079 case R_PPC64_TOC16_LO:
9080 case R_PPC64_TOC16_HI:
9081 case R_PPC64_TOC16_HA:
9082 case R_PPC64_TOC16_DS:
9083 case R_PPC64_TOC16_LO_DS:
9084 case R_PPC64_ADDR64:
9088 r_symndx = ELF64_R_SYM (rel->r_info);
9089 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9097 val = h->root.u.def.value;
9100 val = sym->st_value;
9102 local_toc_syms = TRUE;
9105 val += rel->r_addend;
9107 if (val > toc->rawsize)
9109 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9111 else if ((skip[val >> 3] & can_optimize) != 0)
9113 Elf_Internal_Rela *tocrel
9114 = toc_relocs + (skip[val >> 3] >> 2);
9115 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9119 case R_PPC64_TOC16_HA:
9120 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9123 case R_PPC64_TOC16_LO_DS:
9124 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9128 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9130 info->callbacks->einfo
9131 (_("%P: %H: %s references "
9132 "optimized away TOC entry\n"),
9133 ibfd, sec, rel->r_offset,
9134 ppc64_elf_howto_table[r_type]->name);
9135 bfd_set_error (bfd_error_bad_value);
9138 rel->r_addend = tocrel->r_addend;
9139 elf_section_data (sec)->relocs = relstart;
9143 if (h != NULL || sym->st_value != 0)
9146 rel->r_addend -= skip[val >> 3];
9147 elf_section_data (sec)->relocs = relstart;
9150 if (elf_section_data (sec)->relocs != relstart)
9154 /* We shouldn't have local or global symbols defined in the TOC,
9155 but handle them anyway. */
9156 if (local_syms != NULL)
9157 for (sym = local_syms;
9158 sym < local_syms + symtab_hdr->sh_info;
9160 if (sym->st_value != 0
9161 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9165 if (sym->st_value > toc->rawsize)
9166 i = toc->rawsize >> 3;
9168 i = sym->st_value >> 3;
9170 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9173 (*_bfd_error_handler)
9174 (_("%s defined on removed toc entry"),
9175 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9178 while ((skip[i] & (ref_from_discarded | can_optimize)));
9179 sym->st_value = (bfd_vma) i << 3;
9182 sym->st_value -= skip[i];
9183 symtab_hdr->contents = (unsigned char *) local_syms;
9186 /* Adjust any global syms defined in this toc input section. */
9187 if (toc_inf.global_toc_syms)
9190 toc_inf.skip = skip;
9191 toc_inf.global_toc_syms = FALSE;
9192 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9196 if (toc->reloc_count != 0)
9198 Elf_Internal_Shdr *rel_hdr;
9199 Elf_Internal_Rela *wrel;
9202 /* Remove unused toc relocs, and adjust those we keep. */
9203 if (toc_relocs == NULL)
9204 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9206 if (toc_relocs == NULL)
9210 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9211 if ((skip[rel->r_offset >> 3]
9212 & (ref_from_discarded | can_optimize)) == 0)
9214 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9215 wrel->r_info = rel->r_info;
9216 wrel->r_addend = rel->r_addend;
9219 else if (!dec_dynrel_count (rel->r_info, toc, info,
9220 &local_syms, NULL, NULL))
9223 elf_section_data (toc)->relocs = toc_relocs;
9224 toc->reloc_count = wrel - toc_relocs;
9225 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9226 sz = rel_hdr->sh_entsize;
9227 rel_hdr->sh_size = toc->reloc_count * sz;
9230 else if (toc_relocs != NULL
9231 && elf_section_data (toc)->relocs != toc_relocs)
9234 if (local_syms != NULL
9235 && symtab_hdr->contents != (unsigned char *) local_syms)
9237 if (!info->keep_memory)
9240 symtab_hdr->contents = (unsigned char *) local_syms;
9248 /* Return true iff input section I references the TOC using
9249 instructions limited to +/-32k offsets. */
9252 ppc64_elf_has_small_toc_reloc (asection *i)
9254 return (is_ppc64_elf (i->owner)
9255 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9258 /* Allocate space for one GOT entry. */
9261 allocate_got (struct elf_link_hash_entry *h,
9262 struct bfd_link_info *info,
9263 struct got_entry *gent)
9265 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9267 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9268 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9270 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9271 ? 2 : 1) * sizeof (Elf64_External_Rela);
9272 asection *got = ppc64_elf_tdata (gent->owner)->got;
9274 gent->got.offset = got->size;
9275 got->size += entsize;
9277 dyn = htab->elf.dynamic_sections_created;
9278 if (h->type == STT_GNU_IFUNC)
9280 htab->elf.irelplt->size += rentsize;
9281 htab->got_reli_size += rentsize;
9283 else if ((info->shared
9284 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9285 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9286 || h->root.type != bfd_link_hash_undefweak))
9288 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9289 relgot->size += rentsize;
9293 /* This function merges got entries in the same toc group. */
9296 merge_got_entries (struct got_entry **pent)
9298 struct got_entry *ent, *ent2;
9300 for (ent = *pent; ent != NULL; ent = ent->next)
9301 if (!ent->is_indirect)
9302 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9303 if (!ent2->is_indirect
9304 && ent2->addend == ent->addend
9305 && ent2->tls_type == ent->tls_type
9306 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9308 ent2->is_indirect = TRUE;
9309 ent2->got.ent = ent;
9313 /* Allocate space in .plt, .got and associated reloc sections for
9317 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9319 struct bfd_link_info *info;
9320 struct ppc_link_hash_table *htab;
9322 struct ppc_link_hash_entry *eh;
9323 struct elf_dyn_relocs *p;
9324 struct got_entry **pgent, *gent;
9326 if (h->root.type == bfd_link_hash_indirect)
9329 info = (struct bfd_link_info *) inf;
9330 htab = ppc_hash_table (info);
9334 if ((htab->elf.dynamic_sections_created
9336 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9337 || h->type == STT_GNU_IFUNC)
9339 struct plt_entry *pent;
9340 bfd_boolean doneone = FALSE;
9341 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9342 if (pent->plt.refcount > 0)
9344 if (!htab->elf.dynamic_sections_created
9345 || h->dynindx == -1)
9348 pent->plt.offset = s->size;
9349 s->size += PLT_ENTRY_SIZE (htab);
9350 s = htab->elf.irelplt;
9354 /* If this is the first .plt entry, make room for the special
9358 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9360 pent->plt.offset = s->size;
9362 /* Make room for this entry. */
9363 s->size += PLT_ENTRY_SIZE (htab);
9365 /* Make room for the .glink code. */
9368 s->size += GLINK_CALL_STUB_SIZE;
9371 /* We need bigger stubs past index 32767. */
9372 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9379 /* We also need to make an entry in the .rela.plt section. */
9380 s = htab->elf.srelplt;
9382 s->size += sizeof (Elf64_External_Rela);
9386 pent->plt.offset = (bfd_vma) -1;
9389 h->plt.plist = NULL;
9395 h->plt.plist = NULL;
9399 eh = (struct ppc_link_hash_entry *) h;
9400 /* Run through the TLS GD got entries first if we're changing them
9402 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9403 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9404 if (gent->got.refcount > 0
9405 && (gent->tls_type & TLS_GD) != 0)
9407 /* This was a GD entry that has been converted to TPREL. If
9408 there happens to be a TPREL entry we can use that one. */
9409 struct got_entry *ent;
9410 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9411 if (ent->got.refcount > 0
9412 && (ent->tls_type & TLS_TPREL) != 0
9413 && ent->addend == gent->addend
9414 && ent->owner == gent->owner)
9416 gent->got.refcount = 0;
9420 /* If not, then we'll be using our own TPREL entry. */
9421 if (gent->got.refcount != 0)
9422 gent->tls_type = TLS_TLS | TLS_TPREL;
9425 /* Remove any list entry that won't generate a word in the GOT before
9426 we call merge_got_entries. Otherwise we risk merging to empty
9428 pgent = &h->got.glist;
9429 while ((gent = *pgent) != NULL)
9430 if (gent->got.refcount > 0)
9432 if ((gent->tls_type & TLS_LD) != 0
9435 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9436 *pgent = gent->next;
9439 pgent = &gent->next;
9442 *pgent = gent->next;
9444 if (!htab->do_multi_toc)
9445 merge_got_entries (&h->got.glist);
9447 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9448 if (!gent->is_indirect)
9450 /* Make sure this symbol is output as a dynamic symbol.
9451 Undefined weak syms won't yet be marked as dynamic,
9452 nor will all TLS symbols. */
9453 if (h->dynindx == -1
9455 && h->type != STT_GNU_IFUNC
9456 && htab->elf.dynamic_sections_created)
9458 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9462 if (!is_ppc64_elf (gent->owner))
9465 allocate_got (h, info, gent);
9468 if (eh->dyn_relocs == NULL
9469 || (!htab->elf.dynamic_sections_created
9470 && h->type != STT_GNU_IFUNC))
9473 /* In the shared -Bsymbolic case, discard space allocated for
9474 dynamic pc-relative relocs against symbols which turn out to be
9475 defined in regular objects. For the normal shared case, discard
9476 space for relocs that have become local due to symbol visibility
9481 /* Relocs that use pc_count are those that appear on a call insn,
9482 or certain REL relocs (see must_be_dyn_reloc) that can be
9483 generated via assembly. We want calls to protected symbols to
9484 resolve directly to the function rather than going via the plt.
9485 If people want function pointer comparisons to work as expected
9486 then they should avoid writing weird assembly. */
9487 if (SYMBOL_CALLS_LOCAL (info, h))
9489 struct elf_dyn_relocs **pp;
9491 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9493 p->count -= p->pc_count;
9502 /* Also discard relocs on undefined weak syms with non-default
9504 if (eh->dyn_relocs != NULL
9505 && h->root.type == bfd_link_hash_undefweak)
9507 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9508 eh->dyn_relocs = NULL;
9510 /* Make sure this symbol is output as a dynamic symbol.
9511 Undefined weak syms won't yet be marked as dynamic. */
9512 else if (h->dynindx == -1
9513 && !h->forced_local)
9515 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9520 else if (h->type == STT_GNU_IFUNC)
9522 if (!h->non_got_ref)
9523 eh->dyn_relocs = NULL;
9525 else if (ELIMINATE_COPY_RELOCS)
9527 /* For the non-shared case, discard space for relocs against
9528 symbols which turn out to need copy relocs or are not
9534 /* Make sure this symbol is output as a dynamic symbol.
9535 Undefined weak syms won't yet be marked as dynamic. */
9536 if (h->dynindx == -1
9537 && !h->forced_local)
9539 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9543 /* If that succeeded, we know we'll be keeping all the
9545 if (h->dynindx != -1)
9549 eh->dyn_relocs = NULL;
9554 /* Finally, allocate space. */
9555 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9557 asection *sreloc = elf_section_data (p->sec)->sreloc;
9558 if (eh->elf.type == STT_GNU_IFUNC)
9559 sreloc = htab->elf.irelplt;
9560 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9566 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9567 to set up space for global entry stubs. These are put in glink,
9568 after the branch table. */
9571 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9573 struct bfd_link_info *info;
9574 struct ppc_link_hash_table *htab;
9575 struct plt_entry *pent;
9578 if (h->root.type == bfd_link_hash_indirect)
9581 if (!h->pointer_equality_needed)
9588 htab = ppc_hash_table (info);
9593 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9594 if (pent->plt.offset != (bfd_vma) -1
9595 && pent->addend == 0)
9597 /* For ELFv2, if this symbol is not defined in a regular file
9598 and we are not generating a shared library or pie, then we
9599 need to define the symbol in the executable on a call stub.
9600 This is to avoid text relocations. */
9601 s->size = (s->size + 15) & -16;
9602 h->root.u.def.section = s;
9603 h->root.u.def.value = s->size;
9610 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9611 read-only sections. */
9614 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9616 if (h->root.type == bfd_link_hash_indirect)
9619 if (readonly_dynrelocs (h))
9621 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9623 /* Not an error, just cut short the traversal. */
9629 /* Set the sizes of the dynamic sections. */
9632 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9633 struct bfd_link_info *info)
9635 struct ppc_link_hash_table *htab;
9640 struct got_entry *first_tlsld;
9642 htab = ppc_hash_table (info);
9646 dynobj = htab->elf.dynobj;
9650 if (htab->elf.dynamic_sections_created)
9652 /* Set the contents of the .interp section to the interpreter. */
9653 if (info->executable)
9655 s = bfd_get_linker_section (dynobj, ".interp");
9658 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9659 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9663 /* Set up .got offsets for local syms, and space for local dynamic
9665 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9667 struct got_entry **lgot_ents;
9668 struct got_entry **end_lgot_ents;
9669 struct plt_entry **local_plt;
9670 struct plt_entry **end_local_plt;
9671 unsigned char *lgot_masks;
9672 bfd_size_type locsymcount;
9673 Elf_Internal_Shdr *symtab_hdr;
9675 if (!is_ppc64_elf (ibfd))
9678 for (s = ibfd->sections; s != NULL; s = s->next)
9680 struct ppc_dyn_relocs *p;
9682 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9684 if (!bfd_is_abs_section (p->sec)
9685 && bfd_is_abs_section (p->sec->output_section))
9687 /* Input section has been discarded, either because
9688 it is a copy of a linkonce section or due to
9689 linker script /DISCARD/, so we'll be discarding
9692 else if (p->count != 0)
9694 asection *srel = elf_section_data (p->sec)->sreloc;
9696 srel = htab->elf.irelplt;
9697 srel->size += p->count * sizeof (Elf64_External_Rela);
9698 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9699 info->flags |= DF_TEXTREL;
9704 lgot_ents = elf_local_got_ents (ibfd);
9708 symtab_hdr = &elf_symtab_hdr (ibfd);
9709 locsymcount = symtab_hdr->sh_info;
9710 end_lgot_ents = lgot_ents + locsymcount;
9711 local_plt = (struct plt_entry **) end_lgot_ents;
9712 end_local_plt = local_plt + locsymcount;
9713 lgot_masks = (unsigned char *) end_local_plt;
9714 s = ppc64_elf_tdata (ibfd)->got;
9715 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9717 struct got_entry **pent, *ent;
9720 while ((ent = *pent) != NULL)
9721 if (ent->got.refcount > 0)
9723 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9725 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9730 unsigned int ent_size = 8;
9731 unsigned int rel_size = sizeof (Elf64_External_Rela);
9733 ent->got.offset = s->size;
9734 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9739 s->size += ent_size;
9740 if ((*lgot_masks & PLT_IFUNC) != 0)
9742 htab->elf.irelplt->size += rel_size;
9743 htab->got_reli_size += rel_size;
9745 else if (info->shared)
9747 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9748 srel->size += rel_size;
9757 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9758 for (; local_plt < end_local_plt; ++local_plt)
9760 struct plt_entry *ent;
9762 for (ent = *local_plt; ent != NULL; ent = ent->next)
9763 if (ent->plt.refcount > 0)
9766 ent->plt.offset = s->size;
9767 s->size += PLT_ENTRY_SIZE (htab);
9769 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9772 ent->plt.offset = (bfd_vma) -1;
9776 /* Allocate global sym .plt and .got entries, and space for global
9777 sym dynamic relocs. */
9778 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9779 /* Stash the end of glink branch table. */
9780 if (htab->glink != NULL)
9781 htab->glink->rawsize = htab->glink->size;
9783 if (!htab->opd_abi && !info->shared)
9784 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9787 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9789 struct got_entry *ent;
9791 if (!is_ppc64_elf (ibfd))
9794 ent = ppc64_tlsld_got (ibfd);
9795 if (ent->got.refcount > 0)
9797 if (!htab->do_multi_toc && first_tlsld != NULL)
9799 ent->is_indirect = TRUE;
9800 ent->got.ent = first_tlsld;
9804 if (first_tlsld == NULL)
9806 s = ppc64_elf_tdata (ibfd)->got;
9807 ent->got.offset = s->size;
9812 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9813 srel->size += sizeof (Elf64_External_Rela);
9818 ent->got.offset = (bfd_vma) -1;
9821 /* We now have determined the sizes of the various dynamic sections.
9822 Allocate memory for them. */
9824 for (s = dynobj->sections; s != NULL; s = s->next)
9826 if ((s->flags & SEC_LINKER_CREATED) == 0)
9829 if (s == htab->brlt || s == htab->relbrlt)
9830 /* These haven't been allocated yet; don't strip. */
9832 else if (s == htab->elf.sgot
9833 || s == htab->elf.splt
9834 || s == htab->elf.iplt
9836 || s == htab->dynbss)
9838 /* Strip this section if we don't need it; see the
9841 else if (s == htab->glink_eh_frame)
9843 if (!bfd_is_abs_section (s->output_section))
9844 /* Not sized yet. */
9847 else if (CONST_STRNEQ (s->name, ".rela"))
9851 if (s != htab->elf.srelplt)
9854 /* We use the reloc_count field as a counter if we need
9855 to copy relocs into the output file. */
9861 /* It's not one of our sections, so don't allocate space. */
9867 /* If we don't need this section, strip it from the
9868 output file. This is mostly to handle .rela.bss and
9869 .rela.plt. We must create both sections in
9870 create_dynamic_sections, because they must be created
9871 before the linker maps input sections to output
9872 sections. The linker does that before
9873 adjust_dynamic_symbol is called, and it is that
9874 function which decides whether anything needs to go
9875 into these sections. */
9876 s->flags |= SEC_EXCLUDE;
9880 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9883 /* Allocate memory for the section contents. We use bfd_zalloc
9884 here in case unused entries are not reclaimed before the
9885 section's contents are written out. This should not happen,
9886 but this way if it does we get a R_PPC64_NONE reloc in .rela
9887 sections instead of garbage.
9888 We also rely on the section contents being zero when writing
9890 s->contents = bfd_zalloc (dynobj, s->size);
9891 if (s->contents == NULL)
9895 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9897 if (!is_ppc64_elf (ibfd))
9900 s = ppc64_elf_tdata (ibfd)->got;
9901 if (s != NULL && s != htab->elf.sgot)
9904 s->flags |= SEC_EXCLUDE;
9907 s->contents = bfd_zalloc (ibfd, s->size);
9908 if (s->contents == NULL)
9912 s = ppc64_elf_tdata (ibfd)->relgot;
9916 s->flags |= SEC_EXCLUDE;
9919 s->contents = bfd_zalloc (ibfd, s->size);
9920 if (s->contents == NULL)
9928 if (htab->elf.dynamic_sections_created)
9930 bfd_boolean tls_opt;
9932 /* Add some entries to the .dynamic section. We fill in the
9933 values later, in ppc64_elf_finish_dynamic_sections, but we
9934 must add the entries now so that we get the correct size for
9935 the .dynamic section. The DT_DEBUG entry is filled in by the
9936 dynamic linker and used by the debugger. */
9937 #define add_dynamic_entry(TAG, VAL) \
9938 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9940 if (info->executable)
9942 if (!add_dynamic_entry (DT_DEBUG, 0))
9946 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9948 if (!add_dynamic_entry (DT_PLTGOT, 0)
9949 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9950 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9951 || !add_dynamic_entry (DT_JMPREL, 0)
9952 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9956 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9958 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9959 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9963 tls_opt = (!htab->params->no_tls_get_addr_opt
9964 && htab->tls_get_addr_fd != NULL
9965 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9966 if (tls_opt || !htab->opd_abi)
9968 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9974 if (!add_dynamic_entry (DT_RELA, 0)
9975 || !add_dynamic_entry (DT_RELASZ, 0)
9976 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9979 /* If any dynamic relocs apply to a read-only section,
9980 then we need a DT_TEXTREL entry. */
9981 if ((info->flags & DF_TEXTREL) == 0)
9982 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9984 if ((info->flags & DF_TEXTREL) != 0)
9986 if (!add_dynamic_entry (DT_TEXTREL, 0))
9991 #undef add_dynamic_entry
9996 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9999 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10001 if (h->plt.plist != NULL
10003 && !h->pointer_equality_needed)
10006 return _bfd_elf_hash_symbol (h);
10009 /* Determine the type of stub needed, if any, for a call. */
10011 static inline enum ppc_stub_type
10012 ppc_type_of_stub (asection *input_sec,
10013 const Elf_Internal_Rela *rel,
10014 struct ppc_link_hash_entry **hash,
10015 struct plt_entry **plt_ent,
10016 bfd_vma destination,
10017 unsigned long local_off)
10019 struct ppc_link_hash_entry *h = *hash;
10021 bfd_vma branch_offset;
10022 bfd_vma max_branch_offset;
10023 enum elf_ppc64_reloc_type r_type;
10027 struct plt_entry *ent;
10028 struct ppc_link_hash_entry *fdh = h;
10030 && h->oh->is_func_descriptor)
10032 fdh = ppc_follow_link (h->oh);
10036 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10037 if (ent->addend == rel->r_addend
10038 && ent->plt.offset != (bfd_vma) -1)
10041 return ppc_stub_plt_call;
10044 /* Here, we know we don't have a plt entry. If we don't have a
10045 either a defined function descriptor or a defined entry symbol
10046 in a regular object file, then it is pointless trying to make
10047 any other type of stub. */
10048 if (!is_static_defined (&fdh->elf)
10049 && !is_static_defined (&h->elf))
10050 return ppc_stub_none;
10052 else if (elf_local_got_ents (input_sec->owner) != NULL)
10054 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10055 struct plt_entry **local_plt = (struct plt_entry **)
10056 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10057 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10059 if (local_plt[r_symndx] != NULL)
10061 struct plt_entry *ent;
10063 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10064 if (ent->addend == rel->r_addend
10065 && ent->plt.offset != (bfd_vma) -1)
10068 return ppc_stub_plt_call;
10073 /* Determine where the call point is. */
10074 location = (input_sec->output_offset
10075 + input_sec->output_section->vma
10078 branch_offset = destination - location;
10079 r_type = ELF64_R_TYPE (rel->r_info);
10081 /* Determine if a long branch stub is needed. */
10082 max_branch_offset = 1 << 25;
10083 if (r_type != R_PPC64_REL24)
10084 max_branch_offset = 1 << 15;
10086 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10087 /* We need a stub. Figure out whether a long_branch or plt_branch
10088 is needed later. */
10089 return ppc_stub_long_branch;
10091 return ppc_stub_none;
10094 /* With power7 weakly ordered memory model, it is possible for ld.so
10095 to update a plt entry in one thread and have another thread see a
10096 stale zero toc entry. To avoid this we need some sort of acquire
10097 barrier in the call stub. One solution is to make the load of the
10098 toc word seem to appear to depend on the load of the function entry
10099 word. Another solution is to test for r2 being zero, and branch to
10100 the appropriate glink entry if so.
10102 . fake dep barrier compare
10103 . ld 12,xxx(2) ld 12,xxx(2)
10104 . mtctr 12 mtctr 12
10105 . xor 11,12,12 ld 2,xxx+8(2)
10106 . add 2,2,11 cmpldi 2,0
10107 . ld 2,xxx+8(2) bnectr+
10108 . bctr b <glink_entry>
10110 The solution involving the compare turns out to be faster, so
10111 that's what we use unless the branch won't reach. */
10113 #define ALWAYS_USE_FAKE_DEP 0
10114 #define ALWAYS_EMIT_R2SAVE 0
10116 #define PPC_LO(v) ((v) & 0xffff)
10117 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10118 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10120 static inline unsigned int
10121 plt_stub_size (struct ppc_link_hash_table *htab,
10122 struct ppc_stub_hash_entry *stub_entry,
10125 unsigned size = 12;
10127 if (ALWAYS_EMIT_R2SAVE
10128 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10130 if (PPC_HA (off) != 0)
10135 if (htab->params->plt_static_chain)
10137 if (htab->params->plt_thread_safe)
10139 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10142 if (stub_entry->h != NULL
10143 && (stub_entry->h == htab->tls_get_addr_fd
10144 || stub_entry->h == htab->tls_get_addr)
10145 && !htab->params->no_tls_get_addr_opt)
10150 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10151 then return the padding needed to do so. */
10152 static inline unsigned int
10153 plt_stub_pad (struct ppc_link_hash_table *htab,
10154 struct ppc_stub_hash_entry *stub_entry,
10157 int stub_align = 1 << htab->params->plt_stub_align;
10158 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10159 bfd_vma stub_off = stub_entry->stub_sec->size;
10161 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10162 > (stub_size & -stub_align))
10163 return stub_align - (stub_off & (stub_align - 1));
10167 /* Build a .plt call stub. */
10169 static inline bfd_byte *
10170 build_plt_stub (struct ppc_link_hash_table *htab,
10171 struct ppc_stub_hash_entry *stub_entry,
10172 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10174 bfd *obfd = htab->params->stub_bfd;
10175 bfd_boolean plt_load_toc = htab->opd_abi;
10176 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10177 bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10178 bfd_boolean use_fake_dep = plt_thread_safe;
10179 bfd_vma cmp_branch_off = 0;
10181 if (!ALWAYS_USE_FAKE_DEP
10184 && !(stub_entry->h != NULL
10185 && (stub_entry->h == htab->tls_get_addr_fd
10186 || stub_entry->h == htab->tls_get_addr)
10187 && !htab->params->no_tls_get_addr_opt))
10189 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10190 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10191 / PLT_ENTRY_SIZE (htab));
10192 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10195 if (pltindex > 32768)
10196 glinkoff += (pltindex - 32768) * 4;
10198 + htab->glink->output_offset
10199 + htab->glink->output_section->vma);
10200 from = (p - stub_entry->stub_sec->contents
10201 + 4 * (ALWAYS_EMIT_R2SAVE
10202 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10203 + 4 * (PPC_HA (offset) != 0)
10204 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10205 != PPC_HA (offset))
10206 + 4 * (plt_static_chain != 0)
10208 + stub_entry->stub_sec->output_offset
10209 + stub_entry->stub_sec->output_section->vma);
10210 cmp_branch_off = to - from;
10211 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10214 if (PPC_HA (offset) != 0)
10218 if (ALWAYS_EMIT_R2SAVE
10219 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10220 r[0].r_offset += 4;
10221 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10222 r[1].r_offset = r[0].r_offset + 4;
10223 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10224 r[1].r_addend = r[0].r_addend;
10227 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10229 r[2].r_offset = r[1].r_offset + 4;
10230 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10231 r[2].r_addend = r[0].r_addend;
10235 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10236 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10237 r[2].r_addend = r[0].r_addend + 8;
10238 if (plt_static_chain)
10240 r[3].r_offset = r[2].r_offset + 4;
10241 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10242 r[3].r_addend = r[0].r_addend + 16;
10247 if (ALWAYS_EMIT_R2SAVE
10248 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10249 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10252 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10253 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10257 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10258 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10261 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10263 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10266 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10271 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10272 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10274 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10275 if (plt_static_chain)
10276 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10283 if (ALWAYS_EMIT_R2SAVE
10284 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10285 r[0].r_offset += 4;
10286 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10289 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10291 r[1].r_offset = r[0].r_offset + 4;
10292 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10293 r[1].r_addend = r[0].r_addend;
10297 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10298 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10299 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10300 if (plt_static_chain)
10302 r[2].r_offset = r[1].r_offset + 4;
10303 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10304 r[2].r_addend = r[0].r_addend + 8;
10309 if (ALWAYS_EMIT_R2SAVE
10310 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10311 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10312 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10314 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10316 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10319 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10324 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10325 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10327 if (plt_static_chain)
10328 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10329 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10332 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10334 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10335 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10336 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10339 bfd_put_32 (obfd, BCTR, p), p += 4;
10343 /* Build a special .plt call stub for __tls_get_addr. */
10345 #define LD_R11_0R3 0xe9630000
10346 #define LD_R12_0R3 0xe9830000
10347 #define MR_R0_R3 0x7c601b78
10348 #define CMPDI_R11_0 0x2c2b0000
10349 #define ADD_R3_R12_R13 0x7c6c6a14
10350 #define BEQLR 0x4d820020
10351 #define MR_R3_R0 0x7c030378
10352 #define STD_R11_0R1 0xf9610000
10353 #define BCTRL 0x4e800421
10354 #define LD_R11_0R1 0xe9610000
10355 #define MTLR_R11 0x7d6803a6
10357 static inline bfd_byte *
10358 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10359 struct ppc_stub_hash_entry *stub_entry,
10360 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10362 bfd *obfd = htab->params->stub_bfd;
10364 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10365 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10366 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10367 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10368 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10369 bfd_put_32 (obfd, BEQLR, p), p += 4;
10370 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10371 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10372 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10375 r[0].r_offset += 9 * 4;
10376 p = build_plt_stub (htab, stub_entry, p, offset, r);
10377 bfd_put_32 (obfd, BCTRL, p - 4);
10379 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10380 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10381 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10382 bfd_put_32 (obfd, BLR, p), p += 4;
10387 static Elf_Internal_Rela *
10388 get_relocs (asection *sec, int count)
10390 Elf_Internal_Rela *relocs;
10391 struct bfd_elf_section_data *elfsec_data;
10393 elfsec_data = elf_section_data (sec);
10394 relocs = elfsec_data->relocs;
10395 if (relocs == NULL)
10397 bfd_size_type relsize;
10398 relsize = sec->reloc_count * sizeof (*relocs);
10399 relocs = bfd_alloc (sec->owner, relsize);
10400 if (relocs == NULL)
10402 elfsec_data->relocs = relocs;
10403 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10404 sizeof (Elf_Internal_Shdr));
10405 if (elfsec_data->rela.hdr == NULL)
10407 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10408 * sizeof (Elf64_External_Rela));
10409 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10410 sec->reloc_count = 0;
10412 relocs += sec->reloc_count;
10413 sec->reloc_count += count;
10418 get_r2off (struct bfd_link_info *info,
10419 struct ppc_stub_hash_entry *stub_entry)
10421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10422 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10426 /* Support linking -R objects. Get the toc pointer from the
10429 if (!htab->opd_abi)
10431 asection *opd = stub_entry->h->elf.root.u.def.section;
10432 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10434 if (strcmp (opd->name, ".opd") != 0
10435 || opd->reloc_count != 0)
10437 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10438 stub_entry->h->elf.root.root.string);
10439 bfd_set_error (bfd_error_bad_value);
10442 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10444 r2off = bfd_get_64 (opd->owner, buf);
10445 r2off -= elf_gp (info->output_bfd);
10447 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10452 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10454 struct ppc_stub_hash_entry *stub_entry;
10455 struct ppc_branch_hash_entry *br_entry;
10456 struct bfd_link_info *info;
10457 struct ppc_link_hash_table *htab;
10462 Elf_Internal_Rela *r;
10465 /* Massage our args to the form they really have. */
10466 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10469 htab = ppc_hash_table (info);
10473 /* Make a note of the offset within the stubs for this entry. */
10474 stub_entry->stub_offset = stub_entry->stub_sec->size;
10475 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10477 htab->stub_count[stub_entry->stub_type - 1] += 1;
10478 switch (stub_entry->stub_type)
10480 case ppc_stub_long_branch:
10481 case ppc_stub_long_branch_r2off:
10482 /* Branches are relative. This is where we are going to. */
10483 dest = (stub_entry->target_value
10484 + stub_entry->target_section->output_offset
10485 + stub_entry->target_section->output_section->vma);
10486 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10489 /* And this is where we are coming from. */
10490 off -= (stub_entry->stub_offset
10491 + stub_entry->stub_sec->output_offset
10492 + stub_entry->stub_sec->output_section->vma);
10495 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10497 bfd_vma r2off = get_r2off (info, stub_entry);
10501 htab->stub_error = TRUE;
10504 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10507 if (PPC_HA (r2off) != 0)
10510 bfd_put_32 (htab->params->stub_bfd,
10511 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10514 bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10518 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10520 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10522 info->callbacks->einfo
10523 (_("%P: long branch stub `%s' offset overflow\n"),
10524 stub_entry->root.string);
10525 htab->stub_error = TRUE;
10529 if (info->emitrelocations)
10531 r = get_relocs (stub_entry->stub_sec, 1);
10534 r->r_offset = loc - stub_entry->stub_sec->contents;
10535 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10536 r->r_addend = dest;
10537 if (stub_entry->h != NULL)
10539 struct elf_link_hash_entry **hashes;
10540 unsigned long symndx;
10541 struct ppc_link_hash_entry *h;
10543 hashes = elf_sym_hashes (htab->params->stub_bfd);
10544 if (hashes == NULL)
10546 bfd_size_type hsize;
10548 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10549 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10550 if (hashes == NULL)
10552 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10553 htab->stub_globals = 1;
10555 symndx = htab->stub_globals++;
10557 hashes[symndx] = &h->elf;
10558 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10559 if (h->oh != NULL && h->oh->is_func)
10560 h = ppc_follow_link (h->oh);
10561 if (h->elf.root.u.def.section != stub_entry->target_section)
10562 /* H is an opd symbol. The addend must be zero. */
10566 off = (h->elf.root.u.def.value
10567 + h->elf.root.u.def.section->output_offset
10568 + h->elf.root.u.def.section->output_section->vma);
10569 r->r_addend -= off;
10575 case ppc_stub_plt_branch:
10576 case ppc_stub_plt_branch_r2off:
10577 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10578 stub_entry->root.string + 9,
10580 if (br_entry == NULL)
10582 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10583 stub_entry->root.string);
10584 htab->stub_error = TRUE;
10588 dest = (stub_entry->target_value
10589 + stub_entry->target_section->output_offset
10590 + stub_entry->target_section->output_section->vma);
10591 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10592 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10594 bfd_put_64 (htab->brlt->owner, dest,
10595 htab->brlt->contents + br_entry->offset);
10597 if (br_entry->iter == htab->stub_iteration)
10599 br_entry->iter = 0;
10601 if (htab->relbrlt != NULL)
10603 /* Create a reloc for the branch lookup table entry. */
10604 Elf_Internal_Rela rela;
10607 rela.r_offset = (br_entry->offset
10608 + htab->brlt->output_offset
10609 + htab->brlt->output_section->vma);
10610 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10611 rela.r_addend = dest;
10613 rl = htab->relbrlt->contents;
10614 rl += (htab->relbrlt->reloc_count++
10615 * sizeof (Elf64_External_Rela));
10616 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10618 else if (info->emitrelocations)
10620 r = get_relocs (htab->brlt, 1);
10623 /* brlt, being SEC_LINKER_CREATED does not go through the
10624 normal reloc processing. Symbols and offsets are not
10625 translated from input file to output file form, so
10626 set up the offset per the output file. */
10627 r->r_offset = (br_entry->offset
10628 + htab->brlt->output_offset
10629 + htab->brlt->output_section->vma);
10630 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10631 r->r_addend = dest;
10635 dest = (br_entry->offset
10636 + htab->brlt->output_offset
10637 + htab->brlt->output_section->vma);
10640 - elf_gp (htab->brlt->output_section->owner)
10641 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10643 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10645 info->callbacks->einfo
10646 (_("%P: linkage table error against `%T'\n"),
10647 stub_entry->root.string);
10648 bfd_set_error (bfd_error_bad_value);
10649 htab->stub_error = TRUE;
10653 if (info->emitrelocations)
10655 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10658 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10659 if (bfd_big_endian (info->output_bfd))
10660 r[0].r_offset += 2;
10661 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10662 r[0].r_offset += 4;
10663 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10664 r[0].r_addend = dest;
10665 if (PPC_HA (off) != 0)
10667 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10668 r[1].r_offset = r[0].r_offset + 4;
10669 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10670 r[1].r_addend = r[0].r_addend;
10674 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10676 if (PPC_HA (off) != 0)
10679 bfd_put_32 (htab->params->stub_bfd,
10680 ADDIS_R12_R2 | PPC_HA (off), loc);
10682 bfd_put_32 (htab->params->stub_bfd,
10683 LD_R12_0R12 | PPC_LO (off), loc);
10688 bfd_put_32 (htab->params->stub_bfd,
10689 LD_R12_0R2 | PPC_LO (off), loc);
10694 bfd_vma r2off = get_r2off (info, stub_entry);
10696 if (r2off == 0 && htab->opd_abi)
10698 htab->stub_error = TRUE;
10702 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10705 if (PPC_HA (off) != 0)
10708 bfd_put_32 (htab->params->stub_bfd,
10709 ADDIS_R12_R2 | PPC_HA (off), loc);
10711 bfd_put_32 (htab->params->stub_bfd,
10712 LD_R12_0R12 | PPC_LO (off), loc);
10715 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10717 if (PPC_HA (r2off) != 0)
10721 bfd_put_32 (htab->params->stub_bfd,
10722 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10724 if (PPC_LO (r2off) != 0)
10728 bfd_put_32 (htab->params->stub_bfd,
10729 ADDI_R2_R2 | PPC_LO (r2off), loc);
10733 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10735 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10738 case ppc_stub_plt_call:
10739 case ppc_stub_plt_call_r2save:
10740 if (stub_entry->h != NULL
10741 && stub_entry->h->is_func_descriptor
10742 && stub_entry->h->oh != NULL)
10744 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10746 /* If the old-ABI "dot-symbol" is undefined make it weak so
10747 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10748 FIXME: We used to define the symbol on one of the call
10749 stubs instead, which is why we test symbol section id
10750 against htab->top_id in various places. Likely all
10751 these checks could now disappear. */
10752 if (fh->elf.root.type == bfd_link_hash_undefined)
10753 fh->elf.root.type = bfd_link_hash_undefweak;
10754 /* Stop undo_symbol_twiddle changing it back to undefined. */
10755 fh->was_undefined = 0;
10758 /* Now build the stub. */
10759 dest = stub_entry->plt_ent->plt.offset & ~1;
10760 if (dest >= (bfd_vma) -2)
10763 plt = htab->elf.splt;
10764 if (!htab->elf.dynamic_sections_created
10765 || stub_entry->h == NULL
10766 || stub_entry->h->elf.dynindx == -1)
10767 plt = htab->elf.iplt;
10769 dest += plt->output_offset + plt->output_section->vma;
10771 if (stub_entry->h == NULL
10772 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10774 Elf_Internal_Rela rela;
10777 rela.r_offset = dest;
10779 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10781 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10782 rela.r_addend = (stub_entry->target_value
10783 + stub_entry->target_section->output_offset
10784 + stub_entry->target_section->output_section->vma);
10786 rl = (htab->elf.irelplt->contents
10787 + (htab->elf.irelplt->reloc_count++
10788 * sizeof (Elf64_External_Rela)));
10789 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10790 stub_entry->plt_ent->plt.offset |= 1;
10794 - elf_gp (plt->output_section->owner)
10795 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10797 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10799 info->callbacks->einfo
10800 (_("%P: linkage table error against `%T'\n"),
10801 stub_entry->h != NULL
10802 ? stub_entry->h->elf.root.root.string
10804 bfd_set_error (bfd_error_bad_value);
10805 htab->stub_error = TRUE;
10809 if (htab->params->plt_stub_align != 0)
10811 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10813 stub_entry->stub_sec->size += pad;
10814 stub_entry->stub_offset = stub_entry->stub_sec->size;
10819 if (info->emitrelocations)
10821 r = get_relocs (stub_entry->stub_sec,
10822 ((PPC_HA (off) != 0)
10824 ? 2 + (htab->params->plt_static_chain
10825 && PPC_HA (off + 16) == PPC_HA (off))
10829 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10830 if (bfd_big_endian (info->output_bfd))
10831 r[0].r_offset += 2;
10832 r[0].r_addend = dest;
10834 if (stub_entry->h != NULL
10835 && (stub_entry->h == htab->tls_get_addr_fd
10836 || stub_entry->h == htab->tls_get_addr)
10837 && !htab->params->no_tls_get_addr_opt)
10838 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10840 p = build_plt_stub (htab, stub_entry, loc, off, r);
10849 stub_entry->stub_sec->size += size;
10851 if (htab->params->emit_stub_syms)
10853 struct elf_link_hash_entry *h;
10856 const char *const stub_str[] = { "long_branch",
10857 "long_branch_r2off",
10859 "plt_branch_r2off",
10863 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10864 len2 = strlen (stub_entry->root.string);
10865 name = bfd_malloc (len1 + len2 + 2);
10868 memcpy (name, stub_entry->root.string, 9);
10869 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10870 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10871 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10874 if (h->root.type == bfd_link_hash_new)
10876 h->root.type = bfd_link_hash_defined;
10877 h->root.u.def.section = stub_entry->stub_sec;
10878 h->root.u.def.value = stub_entry->stub_offset;
10879 h->ref_regular = 1;
10880 h->def_regular = 1;
10881 h->ref_regular_nonweak = 1;
10882 h->forced_local = 1;
10890 /* As above, but don't actually build the stub. Just bump offset so
10891 we know stub section sizes, and select plt_branch stubs where
10892 long_branch stubs won't do. */
10895 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10897 struct ppc_stub_hash_entry *stub_entry;
10898 struct bfd_link_info *info;
10899 struct ppc_link_hash_table *htab;
10903 /* Massage our args to the form they really have. */
10904 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10907 htab = ppc_hash_table (info);
10911 if (stub_entry->stub_type == ppc_stub_plt_call
10912 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10915 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10916 if (off >= (bfd_vma) -2)
10918 plt = htab->elf.splt;
10919 if (!htab->elf.dynamic_sections_created
10920 || stub_entry->h == NULL
10921 || stub_entry->h->elf.dynindx == -1)
10922 plt = htab->elf.iplt;
10923 off += (plt->output_offset
10924 + plt->output_section->vma
10925 - elf_gp (plt->output_section->owner)
10926 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10928 size = plt_stub_size (htab, stub_entry, off);
10929 if (htab->params->plt_stub_align)
10930 size += plt_stub_pad (htab, stub_entry, off);
10931 if (info->emitrelocations)
10933 stub_entry->stub_sec->reloc_count
10934 += ((PPC_HA (off) != 0)
10936 ? 2 + (htab->params->plt_static_chain
10937 && PPC_HA (off + 16) == PPC_HA (off))
10939 stub_entry->stub_sec->flags |= SEC_RELOC;
10944 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10947 bfd_vma local_off = 0;
10949 off = (stub_entry->target_value
10950 + stub_entry->target_section->output_offset
10951 + stub_entry->target_section->output_section->vma);
10952 off -= (stub_entry->stub_sec->size
10953 + stub_entry->stub_sec->output_offset
10954 + stub_entry->stub_sec->output_section->vma);
10956 /* Reset the stub type from the plt variant in case we now
10957 can reach with a shorter stub. */
10958 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10959 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10962 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10964 r2off = get_r2off (info, stub_entry);
10965 if (r2off == 0 && htab->opd_abi)
10967 htab->stub_error = TRUE;
10971 if (PPC_HA (r2off) != 0)
10976 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10978 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10979 Do the same for -R objects without function descriptors. */
10980 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10981 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10984 struct ppc_branch_hash_entry *br_entry;
10986 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10987 stub_entry->root.string + 9,
10989 if (br_entry == NULL)
10991 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10992 stub_entry->root.string);
10993 htab->stub_error = TRUE;
10997 if (br_entry->iter != htab->stub_iteration)
10999 br_entry->iter = htab->stub_iteration;
11000 br_entry->offset = htab->brlt->size;
11001 htab->brlt->size += 8;
11003 if (htab->relbrlt != NULL)
11004 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11005 else if (info->emitrelocations)
11007 htab->brlt->reloc_count += 1;
11008 htab->brlt->flags |= SEC_RELOC;
11012 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11013 off = (br_entry->offset
11014 + htab->brlt->output_offset
11015 + htab->brlt->output_section->vma
11016 - elf_gp (htab->brlt->output_section->owner)
11017 - htab->stub_group[stub_entry->id_sec->id].toc_off);
11019 if (info->emitrelocations)
11021 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11022 stub_entry->stub_sec->flags |= SEC_RELOC;
11025 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11028 if (PPC_HA (off) != 0)
11034 if (PPC_HA (off) != 0)
11037 if (PPC_HA (r2off) != 0)
11039 if (PPC_LO (r2off) != 0)
11043 else if (info->emitrelocations)
11045 stub_entry->stub_sec->reloc_count += 1;
11046 stub_entry->stub_sec->flags |= SEC_RELOC;
11050 stub_entry->stub_sec->size += size;
11054 /* Set up various things so that we can make a list of input sections
11055 for each output section included in the link. Returns -1 on error,
11056 0 when no stubs will be needed, and 1 on success. */
11059 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11062 int top_id, top_index, id;
11064 asection **input_list;
11066 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11071 /* Find the top input section id. */
11072 for (input_bfd = info->input_bfds, top_id = 3;
11074 input_bfd = input_bfd->link.next)
11076 for (section = input_bfd->sections;
11078 section = section->next)
11080 if (top_id < section->id)
11081 top_id = section->id;
11085 htab->top_id = top_id;
11086 amt = sizeof (struct map_stub) * (top_id + 1);
11087 htab->stub_group = bfd_zmalloc (amt);
11088 if (htab->stub_group == NULL)
11091 /* Set toc_off for com, und, abs and ind sections. */
11092 for (id = 0; id < 3; id++)
11093 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11095 /* We can't use output_bfd->section_count here to find the top output
11096 section index as some sections may have been removed, and
11097 strip_excluded_output_sections doesn't renumber the indices. */
11098 for (section = info->output_bfd->sections, top_index = 0;
11100 section = section->next)
11102 if (top_index < section->index)
11103 top_index = section->index;
11106 htab->top_index = top_index;
11107 amt = sizeof (asection *) * (top_index + 1);
11108 input_list = bfd_zmalloc (amt);
11109 htab->input_list = input_list;
11110 if (input_list == NULL)
11116 /* Set up for first pass at multitoc partitioning. */
11119 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11121 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11123 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11124 htab->toc_bfd = NULL;
11125 htab->toc_first_sec = NULL;
11128 /* The linker repeatedly calls this function for each TOC input section
11129 and linker generated GOT section. Group input bfds such that the toc
11130 within a group is less than 64k in size. */
11133 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11135 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11136 bfd_vma addr, off, limit;
11141 if (!htab->second_toc_pass)
11143 /* Keep track of the first .toc or .got section for this input bfd. */
11144 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11148 htab->toc_bfd = isec->owner;
11149 htab->toc_first_sec = isec;
11152 addr = isec->output_offset + isec->output_section->vma;
11153 off = addr - htab->toc_curr;
11154 limit = 0x80008000;
11155 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11157 if (off + isec->size > limit)
11159 addr = (htab->toc_first_sec->output_offset
11160 + htab->toc_first_sec->output_section->vma);
11161 htab->toc_curr = addr;
11164 /* toc_curr is the base address of this toc group. Set elf_gp
11165 for the input section to be the offset relative to the
11166 output toc base plus 0x8000. Making the input elf_gp an
11167 offset allows us to move the toc as a whole without
11168 recalculating input elf_gp. */
11169 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11170 off += TOC_BASE_OFF;
11172 /* Die if someone uses a linker script that doesn't keep input
11173 file .toc and .got together. */
11175 && elf_gp (isec->owner) != 0
11176 && elf_gp (isec->owner) != off)
11179 elf_gp (isec->owner) = off;
11183 /* During the second pass toc_first_sec points to the start of
11184 a toc group, and toc_curr is used to track the old elf_gp.
11185 We use toc_bfd to ensure we only look at each bfd once. */
11186 if (htab->toc_bfd == isec->owner)
11188 htab->toc_bfd = isec->owner;
11190 if (htab->toc_first_sec == NULL
11191 || htab->toc_curr != elf_gp (isec->owner))
11193 htab->toc_curr = elf_gp (isec->owner);
11194 htab->toc_first_sec = isec;
11196 addr = (htab->toc_first_sec->output_offset
11197 + htab->toc_first_sec->output_section->vma);
11198 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11199 elf_gp (isec->owner) = off;
11204 /* Called via elf_link_hash_traverse to merge GOT entries for global
11208 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11210 if (h->root.type == bfd_link_hash_indirect)
11213 merge_got_entries (&h->got.glist);
11218 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11222 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11224 struct got_entry *gent;
11226 if (h->root.type == bfd_link_hash_indirect)
11229 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11230 if (!gent->is_indirect)
11231 allocate_got (h, (struct bfd_link_info *) inf, gent);
11235 /* Called on the first multitoc pass after the last call to
11236 ppc64_elf_next_toc_section. This function removes duplicate GOT
11240 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11242 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11243 struct bfd *ibfd, *ibfd2;
11244 bfd_boolean done_something;
11246 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11248 if (!htab->do_multi_toc)
11251 /* Merge global sym got entries within a toc group. */
11252 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11254 /* And tlsld_got. */
11255 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11257 struct got_entry *ent, *ent2;
11259 if (!is_ppc64_elf (ibfd))
11262 ent = ppc64_tlsld_got (ibfd);
11263 if (!ent->is_indirect
11264 && ent->got.offset != (bfd_vma) -1)
11266 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11268 if (!is_ppc64_elf (ibfd2))
11271 ent2 = ppc64_tlsld_got (ibfd2);
11272 if (!ent2->is_indirect
11273 && ent2->got.offset != (bfd_vma) -1
11274 && elf_gp (ibfd2) == elf_gp (ibfd))
11276 ent2->is_indirect = TRUE;
11277 ent2->got.ent = ent;
11283 /* Zap sizes of got sections. */
11284 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11285 htab->elf.irelplt->size -= htab->got_reli_size;
11286 htab->got_reli_size = 0;
11288 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11290 asection *got, *relgot;
11292 if (!is_ppc64_elf (ibfd))
11295 got = ppc64_elf_tdata (ibfd)->got;
11298 got->rawsize = got->size;
11300 relgot = ppc64_elf_tdata (ibfd)->relgot;
11301 relgot->rawsize = relgot->size;
11306 /* Now reallocate the got, local syms first. We don't need to
11307 allocate section contents again since we never increase size. */
11308 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11310 struct got_entry **lgot_ents;
11311 struct got_entry **end_lgot_ents;
11312 struct plt_entry **local_plt;
11313 struct plt_entry **end_local_plt;
11314 unsigned char *lgot_masks;
11315 bfd_size_type locsymcount;
11316 Elf_Internal_Shdr *symtab_hdr;
11319 if (!is_ppc64_elf (ibfd))
11322 lgot_ents = elf_local_got_ents (ibfd);
11326 symtab_hdr = &elf_symtab_hdr (ibfd);
11327 locsymcount = symtab_hdr->sh_info;
11328 end_lgot_ents = lgot_ents + locsymcount;
11329 local_plt = (struct plt_entry **) end_lgot_ents;
11330 end_local_plt = local_plt + locsymcount;
11331 lgot_masks = (unsigned char *) end_local_plt;
11332 s = ppc64_elf_tdata (ibfd)->got;
11333 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11335 struct got_entry *ent;
11337 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11339 unsigned int ent_size = 8;
11340 unsigned int rel_size = sizeof (Elf64_External_Rela);
11342 ent->got.offset = s->size;
11343 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11348 s->size += ent_size;
11349 if ((*lgot_masks & PLT_IFUNC) != 0)
11351 htab->elf.irelplt->size += rel_size;
11352 htab->got_reli_size += rel_size;
11354 else if (info->shared)
11356 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11357 srel->size += rel_size;
11363 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11365 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11367 struct got_entry *ent;
11369 if (!is_ppc64_elf (ibfd))
11372 ent = ppc64_tlsld_got (ibfd);
11373 if (!ent->is_indirect
11374 && ent->got.offset != (bfd_vma) -1)
11376 asection *s = ppc64_elf_tdata (ibfd)->got;
11377 ent->got.offset = s->size;
11381 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11382 srel->size += sizeof (Elf64_External_Rela);
11387 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11388 if (!done_something)
11389 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11393 if (!is_ppc64_elf (ibfd))
11396 got = ppc64_elf_tdata (ibfd)->got;
11399 done_something = got->rawsize != got->size;
11400 if (done_something)
11405 if (done_something)
11406 (*htab->params->layout_sections_again) ();
11408 /* Set up for second pass over toc sections to recalculate elf_gp
11409 on input sections. */
11410 htab->toc_bfd = NULL;
11411 htab->toc_first_sec = NULL;
11412 htab->second_toc_pass = TRUE;
11413 return done_something;
11416 /* Called after second pass of multitoc partitioning. */
11419 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11423 /* After the second pass, toc_curr tracks the TOC offset used
11424 for code sections below in ppc64_elf_next_input_section. */
11425 htab->toc_curr = TOC_BASE_OFF;
11428 /* No toc references were found in ISEC. If the code in ISEC makes no
11429 calls, then there's no need to use toc adjusting stubs when branching
11430 into ISEC. Actually, indirect calls from ISEC are OK as they will
11431 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11432 needed, and 2 if a cyclical call-graph was found but no other reason
11433 for a stub was detected. If called from the top level, a return of
11434 2 means the same as a return of 0. */
11437 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11441 /* Mark this section as checked. */
11442 isec->call_check_done = 1;
11444 /* We know none of our code bearing sections will need toc stubs. */
11445 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11448 if (isec->size == 0)
11451 if (isec->output_section == NULL)
11455 if (isec->reloc_count != 0)
11457 Elf_Internal_Rela *relstart, *rel;
11458 Elf_Internal_Sym *local_syms;
11459 struct ppc_link_hash_table *htab;
11461 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11462 info->keep_memory);
11463 if (relstart == NULL)
11466 /* Look for branches to outside of this section. */
11468 htab = ppc_hash_table (info);
11472 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11474 enum elf_ppc64_reloc_type r_type;
11475 unsigned long r_symndx;
11476 struct elf_link_hash_entry *h;
11477 struct ppc_link_hash_entry *eh;
11478 Elf_Internal_Sym *sym;
11480 struct _opd_sec_data *opd;
11484 r_type = ELF64_R_TYPE (rel->r_info);
11485 if (r_type != R_PPC64_REL24
11486 && r_type != R_PPC64_REL14
11487 && r_type != R_PPC64_REL14_BRTAKEN
11488 && r_type != R_PPC64_REL14_BRNTAKEN)
11491 r_symndx = ELF64_R_SYM (rel->r_info);
11492 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11499 /* Calls to dynamic lib functions go through a plt call stub
11501 eh = (struct ppc_link_hash_entry *) h;
11503 && (eh->elf.plt.plist != NULL
11505 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11511 if (sym_sec == NULL)
11512 /* Ignore other undefined symbols. */
11515 /* Assume branches to other sections not included in the
11516 link need stubs too, to cover -R and absolute syms. */
11517 if (sym_sec->output_section == NULL)
11524 sym_value = sym->st_value;
11527 if (h->root.type != bfd_link_hash_defined
11528 && h->root.type != bfd_link_hash_defweak)
11530 sym_value = h->root.u.def.value;
11532 sym_value += rel->r_addend;
11534 /* If this branch reloc uses an opd sym, find the code section. */
11535 opd = get_opd_info (sym_sec);
11538 if (h == NULL && opd->adjust != NULL)
11542 adjust = opd->adjust[sym->st_value / 8];
11544 /* Assume deleted functions won't ever be called. */
11546 sym_value += adjust;
11549 dest = opd_entry_value (sym_sec, sym_value,
11550 &sym_sec, NULL, FALSE);
11551 if (dest == (bfd_vma) -1)
11556 + sym_sec->output_offset
11557 + sym_sec->output_section->vma);
11559 /* Ignore branch to self. */
11560 if (sym_sec == isec)
11563 /* If the called function uses the toc, we need a stub. */
11564 if (sym_sec->has_toc_reloc
11565 || sym_sec->makes_toc_func_call)
11571 /* Assume any branch that needs a long branch stub might in fact
11572 need a plt_branch stub. A plt_branch stub uses r2. */
11573 else if (dest - (isec->output_offset
11574 + isec->output_section->vma
11575 + rel->r_offset) + (1 << 25)
11576 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11584 /* If calling back to a section in the process of being
11585 tested, we can't say for sure that no toc adjusting stubs
11586 are needed, so don't return zero. */
11587 else if (sym_sec->call_check_in_progress)
11590 /* Branches to another section that itself doesn't have any TOC
11591 references are OK. Recursively call ourselves to check. */
11592 else if (!sym_sec->call_check_done)
11596 /* Mark current section as indeterminate, so that other
11597 sections that call back to current won't be marked as
11599 isec->call_check_in_progress = 1;
11600 recur = toc_adjusting_stub_needed (info, sym_sec);
11601 isec->call_check_in_progress = 0;
11612 if (local_syms != NULL
11613 && (elf_symtab_hdr (isec->owner).contents
11614 != (unsigned char *) local_syms))
11616 if (elf_section_data (isec)->relocs != relstart)
11621 && isec->map_head.s != NULL
11622 && (strcmp (isec->output_section->name, ".init") == 0
11623 || strcmp (isec->output_section->name, ".fini") == 0))
11625 if (isec->map_head.s->has_toc_reloc
11626 || isec->map_head.s->makes_toc_func_call)
11628 else if (!isec->map_head.s->call_check_done)
11631 isec->call_check_in_progress = 1;
11632 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11633 isec->call_check_in_progress = 0;
11640 isec->makes_toc_func_call = 1;
11645 /* The linker repeatedly calls this function for each input section,
11646 in the order that input sections are linked into output sections.
11647 Build lists of input sections to determine groupings between which
11648 we may insert linker stubs. */
11651 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11653 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11658 if ((isec->output_section->flags & SEC_CODE) != 0
11659 && isec->output_section->index <= htab->top_index)
11661 asection **list = htab->input_list + isec->output_section->index;
11662 /* Steal the link_sec pointer for our list. */
11663 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11664 /* This happens to make the list in reverse order,
11665 which is what we want. */
11666 PREV_SEC (isec) = *list;
11670 if (htab->multi_toc_needed)
11672 /* Analyse sections that aren't already flagged as needing a
11673 valid toc pointer. Exclude .fixup for the linux kernel.
11674 .fixup contains branches, but only back to the function that
11675 hit an exception. */
11676 if (!(isec->has_toc_reloc
11677 || (isec->flags & SEC_CODE) == 0
11678 || strcmp (isec->name, ".fixup") == 0
11679 || isec->call_check_done))
11681 if (toc_adjusting_stub_needed (info, isec) < 0)
11684 /* Make all sections use the TOC assigned for this object file.
11685 This will be wrong for pasted sections; We fix that in
11686 check_pasted_section(). */
11687 if (elf_gp (isec->owner) != 0)
11688 htab->toc_curr = elf_gp (isec->owner);
11691 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11695 /* Check that all .init and .fini sections use the same toc, if they
11696 have toc relocs. */
11699 check_pasted_section (struct bfd_link_info *info, const char *name)
11701 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11705 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11706 bfd_vma toc_off = 0;
11709 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11710 if (i->has_toc_reloc)
11713 toc_off = htab->stub_group[i->id].toc_off;
11714 else if (toc_off != htab->stub_group[i->id].toc_off)
11719 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11720 if (i->makes_toc_func_call)
11722 toc_off = htab->stub_group[i->id].toc_off;
11726 /* Make sure the whole pasted function uses the same toc offset. */
11728 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11729 htab->stub_group[i->id].toc_off = toc_off;
11735 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11737 return (check_pasted_section (info, ".init")
11738 & check_pasted_section (info, ".fini"));
11741 /* See whether we can group stub sections together. Grouping stub
11742 sections may result in fewer stubs. More importantly, we need to
11743 put all .init* and .fini* stubs at the beginning of the .init or
11744 .fini output sections respectively, because glibc splits the
11745 _init and _fini functions into multiple parts. Putting a stub in
11746 the middle of a function is not a good idea. */
11749 group_sections (struct ppc_link_hash_table *htab,
11750 bfd_size_type stub_group_size,
11751 bfd_boolean stubs_always_before_branch)
11754 bfd_size_type stub14_group_size;
11755 bfd_boolean suppress_size_errors;
11757 suppress_size_errors = FALSE;
11758 stub14_group_size = stub_group_size;
11759 if (stub_group_size == 1)
11761 /* Default values. */
11762 if (stubs_always_before_branch)
11764 stub_group_size = 0x1e00000;
11765 stub14_group_size = 0x7800;
11769 stub_group_size = 0x1c00000;
11770 stub14_group_size = 0x7000;
11772 suppress_size_errors = TRUE;
11775 list = htab->input_list + htab->top_index;
11778 asection *tail = *list;
11779 while (tail != NULL)
11783 bfd_size_type total;
11784 bfd_boolean big_sec;
11788 total = tail->size;
11789 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11790 && ppc64_elf_section_data (tail)->has_14bit_branch
11791 ? stub14_group_size : stub_group_size);
11792 if (big_sec && !suppress_size_errors)
11793 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11794 tail->owner, tail);
11795 curr_toc = htab->stub_group[tail->id].toc_off;
11797 while ((prev = PREV_SEC (curr)) != NULL
11798 && ((total += curr->output_offset - prev->output_offset)
11799 < (ppc64_elf_section_data (prev) != NULL
11800 && ppc64_elf_section_data (prev)->has_14bit_branch
11801 ? stub14_group_size : stub_group_size))
11802 && htab->stub_group[prev->id].toc_off == curr_toc)
11805 /* OK, the size from the start of CURR to the end is less
11806 than stub_group_size and thus can be handled by one stub
11807 section. (or the tail section is itself larger than
11808 stub_group_size, in which case we may be toast.) We
11809 should really be keeping track of the total size of stubs
11810 added here, as stubs contribute to the final output
11811 section size. That's a little tricky, and this way will
11812 only break if stubs added make the total size more than
11813 2^25, ie. for the default stub_group_size, if stubs total
11814 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11817 prev = PREV_SEC (tail);
11818 /* Set up this stub group. */
11819 htab->stub_group[tail->id].link_sec = curr;
11821 while (tail != curr && (tail = prev) != NULL);
11823 /* But wait, there's more! Input sections up to stub_group_size
11824 bytes before the stub section can be handled by it too.
11825 Don't do this if we have a really large section after the
11826 stubs, as adding more stubs increases the chance that
11827 branches may not reach into the stub section. */
11828 if (!stubs_always_before_branch && !big_sec)
11831 while (prev != NULL
11832 && ((total += tail->output_offset - prev->output_offset)
11833 < (ppc64_elf_section_data (prev) != NULL
11834 && ppc64_elf_section_data (prev)->has_14bit_branch
11835 ? stub14_group_size : stub_group_size))
11836 && htab->stub_group[prev->id].toc_off == curr_toc)
11839 prev = PREV_SEC (tail);
11840 htab->stub_group[tail->id].link_sec = curr;
11846 while (list-- != htab->input_list);
11847 free (htab->input_list);
11851 static const unsigned char glink_eh_frame_cie[] =
11853 0, 0, 0, 16, /* length. */
11854 0, 0, 0, 0, /* id. */
11855 1, /* CIE version. */
11856 'z', 'R', 0, /* Augmentation string. */
11857 4, /* Code alignment. */
11858 0x78, /* Data alignment. */
11860 1, /* Augmentation size. */
11861 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11862 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11865 /* Stripping output sections is normally done before dynamic section
11866 symbols have been allocated. This function is called later, and
11867 handles cases like htab->brlt which is mapped to its own output
11871 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11873 if (isec->size == 0
11874 && isec->output_section->size == 0
11875 && !(isec->output_section->flags & SEC_KEEP)
11876 && !bfd_section_removed_from_list (info->output_bfd,
11877 isec->output_section)
11878 && elf_section_data (isec->output_section)->dynindx == 0)
11880 isec->output_section->flags |= SEC_EXCLUDE;
11881 bfd_section_list_remove (info->output_bfd, isec->output_section);
11882 info->output_bfd->section_count--;
11886 /* Determine and set the size of the stub section for a final link.
11888 The basic idea here is to examine all the relocations looking for
11889 PC-relative calls to a target that is unreachable with a "bl"
11893 ppc64_elf_size_stubs (struct bfd_link_info *info)
11895 bfd_size_type stub_group_size;
11896 bfd_boolean stubs_always_before_branch;
11897 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11902 if (htab->params->plt_thread_safe == -1 && !info->executable)
11903 htab->params->plt_thread_safe = 1;
11904 if (!htab->opd_abi)
11905 htab->params->plt_thread_safe = 0;
11906 else if (htab->params->plt_thread_safe == -1)
11908 static const char *const thread_starter[] =
11912 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11914 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11915 "mq_notify", "create_timer",
11919 "GOMP_parallel_start",
11920 "GOMP_parallel_loop_static_start",
11921 "GOMP_parallel_loop_dynamic_start",
11922 "GOMP_parallel_loop_guided_start",
11923 "GOMP_parallel_loop_runtime_start",
11924 "GOMP_parallel_sections_start",
11928 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11930 struct elf_link_hash_entry *h;
11931 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11932 FALSE, FALSE, TRUE);
11933 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11934 if (htab->params->plt_thread_safe)
11938 stubs_always_before_branch = htab->params->group_size < 0;
11939 if (htab->params->group_size < 0)
11940 stub_group_size = -htab->params->group_size;
11942 stub_group_size = htab->params->group_size;
11944 group_sections (htab, stub_group_size, stubs_always_before_branch);
11949 unsigned int bfd_indx;
11950 asection *stub_sec;
11952 htab->stub_iteration += 1;
11954 for (input_bfd = info->input_bfds, bfd_indx = 0;
11956 input_bfd = input_bfd->link.next, bfd_indx++)
11958 Elf_Internal_Shdr *symtab_hdr;
11960 Elf_Internal_Sym *local_syms = NULL;
11962 if (!is_ppc64_elf (input_bfd))
11965 /* We'll need the symbol table in a second. */
11966 symtab_hdr = &elf_symtab_hdr (input_bfd);
11967 if (symtab_hdr->sh_info == 0)
11970 /* Walk over each section attached to the input bfd. */
11971 for (section = input_bfd->sections;
11973 section = section->next)
11975 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11977 /* If there aren't any relocs, then there's nothing more
11979 if ((section->flags & SEC_RELOC) == 0
11980 || (section->flags & SEC_ALLOC) == 0
11981 || (section->flags & SEC_LOAD) == 0
11982 || (section->flags & SEC_CODE) == 0
11983 || section->reloc_count == 0)
11986 /* If this section is a link-once section that will be
11987 discarded, then don't create any stubs. */
11988 if (section->output_section == NULL
11989 || section->output_section->owner != info->output_bfd)
11992 /* Get the relocs. */
11994 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11995 info->keep_memory);
11996 if (internal_relocs == NULL)
11997 goto error_ret_free_local;
11999 /* Now examine each relocation. */
12000 irela = internal_relocs;
12001 irelaend = irela + section->reloc_count;
12002 for (; irela < irelaend; irela++)
12004 enum elf_ppc64_reloc_type r_type;
12005 unsigned int r_indx;
12006 enum ppc_stub_type stub_type;
12007 struct ppc_stub_hash_entry *stub_entry;
12008 asection *sym_sec, *code_sec;
12009 bfd_vma sym_value, code_value;
12010 bfd_vma destination;
12011 unsigned long local_off;
12012 bfd_boolean ok_dest;
12013 struct ppc_link_hash_entry *hash;
12014 struct ppc_link_hash_entry *fdh;
12015 struct elf_link_hash_entry *h;
12016 Elf_Internal_Sym *sym;
12018 const asection *id_sec;
12019 struct _opd_sec_data *opd;
12020 struct plt_entry *plt_ent;
12022 r_type = ELF64_R_TYPE (irela->r_info);
12023 r_indx = ELF64_R_SYM (irela->r_info);
12025 if (r_type >= R_PPC64_max)
12027 bfd_set_error (bfd_error_bad_value);
12028 goto error_ret_free_internal;
12031 /* Only look for stubs on branch instructions. */
12032 if (r_type != R_PPC64_REL24
12033 && r_type != R_PPC64_REL14
12034 && r_type != R_PPC64_REL14_BRTAKEN
12035 && r_type != R_PPC64_REL14_BRNTAKEN)
12038 /* Now determine the call target, its name, value,
12040 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12041 r_indx, input_bfd))
12042 goto error_ret_free_internal;
12043 hash = (struct ppc_link_hash_entry *) h;
12050 sym_value = sym->st_value;
12053 else if (hash->elf.root.type == bfd_link_hash_defined
12054 || hash->elf.root.type == bfd_link_hash_defweak)
12056 sym_value = hash->elf.root.u.def.value;
12057 if (sym_sec->output_section != NULL)
12060 else if (hash->elf.root.type == bfd_link_hash_undefweak
12061 || hash->elf.root.type == bfd_link_hash_undefined)
12063 /* Recognise an old ABI func code entry sym, and
12064 use the func descriptor sym instead if it is
12066 if (hash->elf.root.root.string[0] == '.'
12067 && (fdh = lookup_fdh (hash, htab)) != NULL)
12069 if (fdh->elf.root.type == bfd_link_hash_defined
12070 || fdh->elf.root.type == bfd_link_hash_defweak)
12072 sym_sec = fdh->elf.root.u.def.section;
12073 sym_value = fdh->elf.root.u.def.value;
12074 if (sym_sec->output_section != NULL)
12083 bfd_set_error (bfd_error_bad_value);
12084 goto error_ret_free_internal;
12091 sym_value += irela->r_addend;
12092 destination = (sym_value
12093 + sym_sec->output_offset
12094 + sym_sec->output_section->vma);
12095 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12100 code_sec = sym_sec;
12101 code_value = sym_value;
12102 opd = get_opd_info (sym_sec);
12107 if (hash == NULL && opd->adjust != NULL)
12109 long adjust = opd->adjust[sym_value / 8];
12112 code_value += adjust;
12113 sym_value += adjust;
12115 dest = opd_entry_value (sym_sec, sym_value,
12116 &code_sec, &code_value, FALSE);
12117 if (dest != (bfd_vma) -1)
12119 destination = dest;
12122 /* Fixup old ABI sym to point at code
12124 hash->elf.root.type = bfd_link_hash_defweak;
12125 hash->elf.root.u.def.section = code_sec;
12126 hash->elf.root.u.def.value = code_value;
12131 /* Determine what (if any) linker stub is needed. */
12133 stub_type = ppc_type_of_stub (section, irela, &hash,
12134 &plt_ent, destination,
12137 if (stub_type != ppc_stub_plt_call)
12139 /* Check whether we need a TOC adjusting stub.
12140 Since the linker pastes together pieces from
12141 different object files when creating the
12142 _init and _fini functions, it may be that a
12143 call to what looks like a local sym is in
12144 fact a call needing a TOC adjustment. */
12145 if (code_sec != NULL
12146 && code_sec->output_section != NULL
12147 && (htab->stub_group[code_sec->id].toc_off
12148 != htab->stub_group[section->id].toc_off)
12149 && (code_sec->has_toc_reloc
12150 || code_sec->makes_toc_func_call))
12151 stub_type = ppc_stub_long_branch_r2off;
12154 if (stub_type == ppc_stub_none)
12157 /* __tls_get_addr calls might be eliminated. */
12158 if (stub_type != ppc_stub_plt_call
12160 && (hash == htab->tls_get_addr
12161 || hash == htab->tls_get_addr_fd)
12162 && section->has_tls_reloc
12163 && irela != internal_relocs)
12165 /* Get tls info. */
12166 unsigned char *tls_mask;
12168 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12169 irela - 1, input_bfd))
12170 goto error_ret_free_internal;
12171 if (*tls_mask != 0)
12175 if (stub_type == ppc_stub_plt_call
12176 && irela + 1 < irelaend
12177 && irela[1].r_offset == irela->r_offset + 4
12178 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12180 if (!tocsave_find (htab, INSERT,
12181 &local_syms, irela + 1, input_bfd))
12182 goto error_ret_free_internal;
12184 else if (stub_type == ppc_stub_plt_call)
12185 stub_type = ppc_stub_plt_call_r2save;
12187 /* Support for grouping stub sections. */
12188 id_sec = htab->stub_group[section->id].link_sec;
12190 /* Get the name of this stub. */
12191 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12193 goto error_ret_free_internal;
12195 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12196 stub_name, FALSE, FALSE);
12197 if (stub_entry != NULL)
12199 /* The proper stub has already been created. */
12201 if (stub_type == ppc_stub_plt_call_r2save)
12202 stub_entry->stub_type = stub_type;
12206 stub_entry = ppc_add_stub (stub_name, section, info);
12207 if (stub_entry == NULL)
12210 error_ret_free_internal:
12211 if (elf_section_data (section)->relocs == NULL)
12212 free (internal_relocs);
12213 error_ret_free_local:
12214 if (local_syms != NULL
12215 && (symtab_hdr->contents
12216 != (unsigned char *) local_syms))
12221 stub_entry->stub_type = stub_type;
12222 if (stub_type != ppc_stub_plt_call
12223 && stub_type != ppc_stub_plt_call_r2save)
12225 stub_entry->target_value = code_value;
12226 stub_entry->target_section = code_sec;
12230 stub_entry->target_value = sym_value;
12231 stub_entry->target_section = sym_sec;
12233 stub_entry->h = hash;
12234 stub_entry->plt_ent = plt_ent;
12235 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12237 if (stub_entry->h != NULL)
12238 htab->stub_globals += 1;
12241 /* We're done with the internal relocs, free them. */
12242 if (elf_section_data (section)->relocs != internal_relocs)
12243 free (internal_relocs);
12246 if (local_syms != NULL
12247 && symtab_hdr->contents != (unsigned char *) local_syms)
12249 if (!info->keep_memory)
12252 symtab_hdr->contents = (unsigned char *) local_syms;
12256 /* We may have added some stubs. Find out the new size of the
12258 for (stub_sec = htab->params->stub_bfd->sections;
12260 stub_sec = stub_sec->next)
12261 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12263 stub_sec->rawsize = stub_sec->size;
12264 stub_sec->size = 0;
12265 stub_sec->reloc_count = 0;
12266 stub_sec->flags &= ~SEC_RELOC;
12269 htab->brlt->size = 0;
12270 htab->brlt->reloc_count = 0;
12271 htab->brlt->flags &= ~SEC_RELOC;
12272 if (htab->relbrlt != NULL)
12273 htab->relbrlt->size = 0;
12275 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12277 if (info->emitrelocations
12278 && htab->glink != NULL && htab->glink->size != 0)
12280 htab->glink->reloc_count = 1;
12281 htab->glink->flags |= SEC_RELOC;
12284 if (htab->glink_eh_frame != NULL
12285 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12286 && htab->glink_eh_frame->output_section->size != 0)
12288 size_t size = 0, align;
12290 for (stub_sec = htab->params->stub_bfd->sections;
12292 stub_sec = stub_sec->next)
12293 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12295 if (htab->glink != NULL && htab->glink->size != 0)
12298 size += sizeof (glink_eh_frame_cie);
12300 align <<= htab->glink_eh_frame->output_section->alignment_power;
12302 size = (size + align) & ~align;
12303 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12304 htab->glink_eh_frame->size = size;
12307 if (htab->params->plt_stub_align != 0)
12308 for (stub_sec = htab->params->stub_bfd->sections;
12310 stub_sec = stub_sec->next)
12311 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12312 stub_sec->size = ((stub_sec->size
12313 + (1 << htab->params->plt_stub_align) - 1)
12314 & (-1 << htab->params->plt_stub_align));
12316 for (stub_sec = htab->params->stub_bfd->sections;
12318 stub_sec = stub_sec->next)
12319 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12320 && stub_sec->rawsize != stub_sec->size)
12323 /* Exit from this loop when no stubs have been added, and no stubs
12324 have changed size. */
12325 if (stub_sec == NULL
12326 && (htab->glink_eh_frame == NULL
12327 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12330 /* Ask the linker to do its stuff. */
12331 (*htab->params->layout_sections_again) ();
12334 maybe_strip_output (info, htab->brlt);
12335 if (htab->glink_eh_frame != NULL)
12336 maybe_strip_output (info, htab->glink_eh_frame);
12341 /* Called after we have determined section placement. If sections
12342 move, we'll be called again. Provide a value for TOCstart. */
12345 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12350 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12351 order. The TOC starts where the first of these sections starts. */
12352 s = bfd_get_section_by_name (obfd, ".got");
12353 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12354 s = bfd_get_section_by_name (obfd, ".toc");
12355 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12356 s = bfd_get_section_by_name (obfd, ".tocbss");
12357 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12358 s = bfd_get_section_by_name (obfd, ".plt");
12359 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12361 /* This may happen for
12362 o references to TOC base (SYM@toc / TOC[tc0]) without a
12364 o bad linker script
12365 o --gc-sections and empty TOC sections
12367 FIXME: Warn user? */
12369 /* Look for a likely section. We probably won't even be
12371 for (s = obfd->sections; s != NULL; s = s->next)
12372 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12374 == (SEC_ALLOC | SEC_SMALL_DATA))
12377 for (s = obfd->sections; s != NULL; s = s->next)
12378 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12379 == (SEC_ALLOC | SEC_SMALL_DATA))
12382 for (s = obfd->sections; s != NULL; s = s->next)
12383 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12387 for (s = obfd->sections; s != NULL; s = s->next)
12388 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12394 TOCstart = s->output_section->vma + s->output_offset;
12396 _bfd_set_gp_value (obfd, TOCstart);
12398 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12400 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12403 && htab->elf.hgot != NULL)
12405 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12406 htab->elf.hgot->root.u.def.section = s;
12412 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12413 write out any global entry stubs. */
12416 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12418 struct bfd_link_info *info;
12419 struct ppc_link_hash_table *htab;
12420 struct plt_entry *pent;
12423 if (h->root.type == bfd_link_hash_indirect)
12426 if (!h->pointer_equality_needed)
12429 if (h->def_regular)
12433 htab = ppc_hash_table (info);
12438 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12439 if (pent->plt.offset != (bfd_vma) -1
12440 && pent->addend == 0)
12446 p = s->contents + h->root.u.def.value;
12447 plt = htab->elf.splt;
12448 if (!htab->elf.dynamic_sections_created
12449 || h->dynindx == -1)
12450 plt = htab->elf.iplt;
12451 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12452 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12454 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12456 info->callbacks->einfo
12457 (_("%P: linkage table error against `%T'\n"),
12458 h->root.root.string);
12459 bfd_set_error (bfd_error_bad_value);
12460 htab->stub_error = TRUE;
12463 if (PPC_HA (off) != 0)
12465 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12468 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12470 bfd_put_32 (s->owner, MTCTR_R12, p);
12472 bfd_put_32 (s->owner, BCTR, p);
12478 /* Build all the stubs associated with the current output file.
12479 The stubs are kept in a hash table attached to the main linker
12480 hash table. This function is called via gldelf64ppc_finish. */
12483 ppc64_elf_build_stubs (struct bfd_link_info *info,
12486 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12487 asection *stub_sec;
12489 int stub_sec_count = 0;
12494 /* Allocate memory to hold the linker stubs. */
12495 for (stub_sec = htab->params->stub_bfd->sections;
12497 stub_sec = stub_sec->next)
12498 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12499 && stub_sec->size != 0)
12501 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12502 if (stub_sec->contents == NULL)
12504 /* We want to check that built size is the same as calculated
12505 size. rawsize is a convenient location to use. */
12506 stub_sec->rawsize = stub_sec->size;
12507 stub_sec->size = 0;
12510 if (htab->glink != NULL && htab->glink->size != 0)
12515 /* Build the .glink plt call stub. */
12516 if (htab->params->emit_stub_syms)
12518 struct elf_link_hash_entry *h;
12519 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12520 TRUE, FALSE, FALSE);
12523 if (h->root.type == bfd_link_hash_new)
12525 h->root.type = bfd_link_hash_defined;
12526 h->root.u.def.section = htab->glink;
12527 h->root.u.def.value = 8;
12528 h->ref_regular = 1;
12529 h->def_regular = 1;
12530 h->ref_regular_nonweak = 1;
12531 h->forced_local = 1;
12535 plt0 = (htab->elf.splt->output_section->vma
12536 + htab->elf.splt->output_offset
12538 if (info->emitrelocations)
12540 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12543 r->r_offset = (htab->glink->output_offset
12544 + htab->glink->output_section->vma);
12545 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12546 r->r_addend = plt0;
12548 p = htab->glink->contents;
12549 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12550 bfd_put_64 (htab->glink->owner, plt0, p);
12554 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12556 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12558 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12560 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12562 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12564 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12566 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12568 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12570 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12572 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12577 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12579 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12581 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12583 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12585 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12587 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12589 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12591 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12593 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12595 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12597 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12599 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12602 bfd_put_32 (htab->glink->owner, BCTR, p);
12604 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12606 bfd_put_32 (htab->glink->owner, NOP, p);
12610 /* Build the .glink lazy link call stubs. */
12612 while (p < htab->glink->contents + htab->glink->rawsize)
12618 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12623 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12625 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12630 bfd_put_32 (htab->glink->owner,
12631 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12636 /* Build .glink global entry stubs. */
12637 if (htab->glink->size > htab->glink->rawsize)
12638 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12641 if (htab->brlt->size != 0)
12643 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12645 if (htab->brlt->contents == NULL)
12648 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12650 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12651 htab->relbrlt->size);
12652 if (htab->relbrlt->contents == NULL)
12656 if (htab->glink_eh_frame != NULL
12657 && htab->glink_eh_frame->size != 0)
12660 bfd_byte *last_fde;
12661 size_t last_fde_len, size, align, pad;
12663 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12666 htab->glink_eh_frame->contents = p;
12669 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12671 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12672 /* CIE length (rewrite in case little-endian). */
12673 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12674 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12675 p += sizeof (glink_eh_frame_cie);
12677 for (stub_sec = htab->params->stub_bfd->sections;
12679 stub_sec = stub_sec->next)
12680 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12685 bfd_put_32 (htab->elf.dynobj, 16, p);
12688 val = p - htab->glink_eh_frame->contents;
12689 bfd_put_32 (htab->elf.dynobj, val, p);
12691 /* Offset to stub section. */
12692 val = (stub_sec->output_section->vma
12693 + stub_sec->output_offset);
12694 val -= (htab->glink_eh_frame->output_section->vma
12695 + htab->glink_eh_frame->output_offset);
12696 val -= p - htab->glink_eh_frame->contents;
12697 if (val + 0x80000000 > 0xffffffff)
12699 info->callbacks->einfo
12700 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12704 bfd_put_32 (htab->elf.dynobj, val, p);
12706 /* stub section size. */
12707 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12709 /* Augmentation. */
12714 if (htab->glink != NULL && htab->glink->size != 0)
12719 bfd_put_32 (htab->elf.dynobj, 20, p);
12722 val = p - htab->glink_eh_frame->contents;
12723 bfd_put_32 (htab->elf.dynobj, val, p);
12725 /* Offset to .glink. */
12726 val = (htab->glink->output_section->vma
12727 + htab->glink->output_offset
12729 val -= (htab->glink_eh_frame->output_section->vma
12730 + htab->glink_eh_frame->output_offset);
12731 val -= p - htab->glink_eh_frame->contents;
12732 if (val + 0x80000000 > 0xffffffff)
12734 info->callbacks->einfo
12735 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12736 htab->glink->name);
12739 bfd_put_32 (htab->elf.dynobj, val, p);
12742 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12744 /* Augmentation. */
12747 *p++ = DW_CFA_advance_loc + 1;
12748 *p++ = DW_CFA_register;
12751 *p++ = DW_CFA_advance_loc + 4;
12752 *p++ = DW_CFA_restore_extended;
12755 /* Subsume any padding into the last FDE if user .eh_frame
12756 sections are aligned more than glink_eh_frame. Otherwise any
12757 zero padding will be seen as a terminator. */
12758 size = p - htab->glink_eh_frame->contents;
12760 align <<= htab->glink_eh_frame->output_section->alignment_power;
12762 pad = ((size + align) & ~align) - size;
12763 htab->glink_eh_frame->size = size + pad;
12764 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12767 /* Build the stubs as directed by the stub hash table. */
12768 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12770 if (htab->relbrlt != NULL)
12771 htab->relbrlt->reloc_count = 0;
12773 if (htab->params->plt_stub_align != 0)
12774 for (stub_sec = htab->params->stub_bfd->sections;
12776 stub_sec = stub_sec->next)
12777 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12778 stub_sec->size = ((stub_sec->size
12779 + (1 << htab->params->plt_stub_align) - 1)
12780 & (-1 << htab->params->plt_stub_align));
12782 for (stub_sec = htab->params->stub_bfd->sections;
12784 stub_sec = stub_sec->next)
12785 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12787 stub_sec_count += 1;
12788 if (stub_sec->rawsize != stub_sec->size)
12792 if (stub_sec != NULL
12793 || (htab->glink_eh_frame != NULL
12794 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12796 htab->stub_error = TRUE;
12797 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12800 if (htab->stub_error)
12805 *stats = bfd_malloc (500);
12806 if (*stats == NULL)
12809 sprintf (*stats, _("linker stubs in %u group%s\n"
12811 " toc adjust %lu\n"
12812 " long branch %lu\n"
12813 " long toc adj %lu\n"
12815 " plt call toc %lu"),
12817 stub_sec_count == 1 ? "" : "s",
12818 htab->stub_count[ppc_stub_long_branch - 1],
12819 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12820 htab->stub_count[ppc_stub_plt_branch - 1],
12821 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12822 htab->stub_count[ppc_stub_plt_call - 1],
12823 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12828 /* This function undoes the changes made by add_symbol_adjust. */
12831 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12833 struct ppc_link_hash_entry *eh;
12835 if (h->root.type == bfd_link_hash_indirect)
12838 eh = (struct ppc_link_hash_entry *) h;
12839 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12842 eh->elf.root.type = bfd_link_hash_undefined;
12847 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12849 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12852 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12855 /* What to do when ld finds relocations against symbols defined in
12856 discarded sections. */
12858 static unsigned int
12859 ppc64_elf_action_discarded (asection *sec)
12861 if (strcmp (".opd", sec->name) == 0)
12864 if (strcmp (".toc", sec->name) == 0)
12867 if (strcmp (".toc1", sec->name) == 0)
12870 return _bfd_elf_default_action_discarded (sec);
12873 /* The RELOCATE_SECTION function is called by the ELF backend linker
12874 to handle the relocations for a section.
12876 The relocs are always passed as Rela structures; if the section
12877 actually uses Rel structures, the r_addend field will always be
12880 This function is responsible for adjust the section contents as
12881 necessary, and (if using Rela relocs and generating a
12882 relocatable output file) adjusting the reloc addend as
12885 This function does not have to worry about setting the reloc
12886 address or the reloc symbol index.
12888 LOCAL_SYMS is a pointer to the swapped in local symbols.
12890 LOCAL_SECTIONS is an array giving the section in the input file
12891 corresponding to the st_shndx field of each local symbol.
12893 The global hash table entry for the global symbols can be found
12894 via elf_sym_hashes (input_bfd).
12896 When generating relocatable output, this function must handle
12897 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12898 going to be the section symbol corresponding to the output
12899 section, which means that the addend must be adjusted
12903 ppc64_elf_relocate_section (bfd *output_bfd,
12904 struct bfd_link_info *info,
12906 asection *input_section,
12907 bfd_byte *contents,
12908 Elf_Internal_Rela *relocs,
12909 Elf_Internal_Sym *local_syms,
12910 asection **local_sections)
12912 struct ppc_link_hash_table *htab;
12913 Elf_Internal_Shdr *symtab_hdr;
12914 struct elf_link_hash_entry **sym_hashes;
12915 Elf_Internal_Rela *rel;
12916 Elf_Internal_Rela *relend;
12917 Elf_Internal_Rela outrel;
12919 struct got_entry **local_got_ents;
12921 bfd_boolean ret = TRUE;
12922 bfd_boolean is_opd;
12923 /* Assume 'at' branch hints. */
12924 bfd_boolean is_isa_v2 = TRUE;
12925 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12927 /* Initialize howto table if needed. */
12928 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12931 htab = ppc_hash_table (info);
12935 /* Don't relocate stub sections. */
12936 if (input_section->owner == htab->params->stub_bfd)
12939 BFD_ASSERT (is_ppc64_elf (input_bfd));
12941 local_got_ents = elf_local_got_ents (input_bfd);
12942 TOCstart = elf_gp (output_bfd);
12943 symtab_hdr = &elf_symtab_hdr (input_bfd);
12944 sym_hashes = elf_sym_hashes (input_bfd);
12945 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12948 relend = relocs + input_section->reloc_count;
12949 for (; rel < relend; rel++)
12951 enum elf_ppc64_reloc_type r_type;
12953 bfd_reloc_status_type r;
12954 Elf_Internal_Sym *sym;
12956 struct elf_link_hash_entry *h_elf;
12957 struct ppc_link_hash_entry *h;
12958 struct ppc_link_hash_entry *fdh;
12959 const char *sym_name;
12960 unsigned long r_symndx, toc_symndx;
12961 bfd_vma toc_addend;
12962 unsigned char tls_mask, tls_gd, tls_type;
12963 unsigned char sym_type;
12964 bfd_vma relocation;
12965 bfd_boolean unresolved_reloc;
12966 bfd_boolean warned;
12967 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12970 struct ppc_stub_hash_entry *stub_entry;
12971 bfd_vma max_br_offset;
12973 const Elf_Internal_Rela orig_rel = *rel;
12974 reloc_howto_type *howto;
12975 struct reloc_howto_struct alt_howto;
12977 r_type = ELF64_R_TYPE (rel->r_info);
12978 r_symndx = ELF64_R_SYM (rel->r_info);
12980 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12981 symbol of the previous ADDR64 reloc. The symbol gives us the
12982 proper TOC base to use. */
12983 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12985 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12987 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12993 unresolved_reloc = FALSE;
12996 if (r_symndx < symtab_hdr->sh_info)
12998 /* It's a local symbol. */
12999 struct _opd_sec_data *opd;
13001 sym = local_syms + r_symndx;
13002 sec = local_sections[r_symndx];
13003 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13004 sym_type = ELF64_ST_TYPE (sym->st_info);
13005 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13006 opd = get_opd_info (sec);
13007 if (opd != NULL && opd->adjust != NULL)
13009 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13014 /* If this is a relocation against the opd section sym
13015 and we have edited .opd, adjust the reloc addend so
13016 that ld -r and ld --emit-relocs output is correct.
13017 If it is a reloc against some other .opd symbol,
13018 then the symbol value will be adjusted later. */
13019 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13020 rel->r_addend += adjust;
13022 relocation += adjust;
13028 bfd_boolean ignored;
13030 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13031 r_symndx, symtab_hdr, sym_hashes,
13032 h_elf, sec, relocation,
13033 unresolved_reloc, warned, ignored);
13034 sym_name = h_elf->root.root.string;
13035 sym_type = h_elf->type;
13037 && sec->owner == output_bfd
13038 && strcmp (sec->name, ".opd") == 0)
13040 /* This is a symbol defined in a linker script. All
13041 such are defined in output sections, even those
13042 defined by simple assignment from a symbol defined in
13043 an input section. Transfer the symbol to an
13044 appropriate input .opd section, so that a branch to
13045 this symbol will be mapped to the location specified
13046 by the opd entry. */
13047 struct bfd_link_order *lo;
13048 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13049 if (lo->type == bfd_indirect_link_order)
13051 asection *isec = lo->u.indirect.section;
13052 if (h_elf->root.u.def.value >= isec->output_offset
13053 && h_elf->root.u.def.value < (isec->output_offset
13056 h_elf->root.u.def.value -= isec->output_offset;
13057 h_elf->root.u.def.section = isec;
13064 h = (struct ppc_link_hash_entry *) h_elf;
13066 if (sec != NULL && discarded_section (sec))
13067 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13069 ppc64_elf_howto_table[r_type], 0,
13072 if (info->relocatable)
13075 if (h != NULL && &h->elf == htab->elf.hgot)
13077 relocation = (TOCstart
13078 + htab->stub_group[input_section->id].toc_off);
13079 sec = bfd_abs_section_ptr;
13080 unresolved_reloc = FALSE;
13083 /* TLS optimizations. Replace instruction sequences and relocs
13084 based on information we collected in tls_optimize. We edit
13085 RELOCS so that --emit-relocs will output something sensible
13086 for the final instruction stream. */
13091 tls_mask = h->tls_mask;
13092 else if (local_got_ents != NULL)
13094 struct plt_entry **local_plt = (struct plt_entry **)
13095 (local_got_ents + symtab_hdr->sh_info);
13096 unsigned char *lgot_masks = (unsigned char *)
13097 (local_plt + symtab_hdr->sh_info);
13098 tls_mask = lgot_masks[r_symndx];
13101 && (r_type == R_PPC64_TLS
13102 || r_type == R_PPC64_TLSGD
13103 || r_type == R_PPC64_TLSLD))
13105 /* Check for toc tls entries. */
13106 unsigned char *toc_tls;
13108 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13109 &local_syms, rel, input_bfd))
13113 tls_mask = *toc_tls;
13116 /* Check that tls relocs are used with tls syms, and non-tls
13117 relocs are used with non-tls syms. */
13118 if (r_symndx != STN_UNDEF
13119 && r_type != R_PPC64_NONE
13121 || h->elf.root.type == bfd_link_hash_defined
13122 || h->elf.root.type == bfd_link_hash_defweak)
13123 && (IS_PPC64_TLS_RELOC (r_type)
13124 != (sym_type == STT_TLS
13125 || (sym_type == STT_SECTION
13126 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13129 && (r_type == R_PPC64_TLS
13130 || r_type == R_PPC64_TLSGD
13131 || r_type == R_PPC64_TLSLD))
13132 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13135 info->callbacks->einfo
13136 (!IS_PPC64_TLS_RELOC (r_type)
13137 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13138 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13139 input_bfd, input_section, rel->r_offset,
13140 ppc64_elf_howto_table[r_type]->name,
13144 /* Ensure reloc mapping code below stays sane. */
13145 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13146 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13147 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13148 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13149 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13150 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13151 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13152 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13153 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13154 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13162 case R_PPC64_LO_DS_OPT:
13163 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13164 if ((insn & (0x3f << 26)) != 58u << 26)
13166 insn += (14u << 26) - (58u << 26);
13167 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13168 r_type = R_PPC64_TOC16_LO;
13169 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13172 case R_PPC64_TOC16:
13173 case R_PPC64_TOC16_LO:
13174 case R_PPC64_TOC16_DS:
13175 case R_PPC64_TOC16_LO_DS:
13177 /* Check for toc tls entries. */
13178 unsigned char *toc_tls;
13181 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13182 &local_syms, rel, input_bfd);
13188 tls_mask = *toc_tls;
13189 if (r_type == R_PPC64_TOC16_DS
13190 || r_type == R_PPC64_TOC16_LO_DS)
13193 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13198 /* If we found a GD reloc pair, then we might be
13199 doing a GD->IE transition. */
13202 tls_gd = TLS_TPRELGD;
13203 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13206 else if (retval == 3)
13208 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13216 case R_PPC64_GOT_TPREL16_HI:
13217 case R_PPC64_GOT_TPREL16_HA:
13219 && (tls_mask & TLS_TPREL) == 0)
13221 rel->r_offset -= d_offset;
13222 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13223 r_type = R_PPC64_NONE;
13224 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13228 case R_PPC64_GOT_TPREL16_DS:
13229 case R_PPC64_GOT_TPREL16_LO_DS:
13231 && (tls_mask & TLS_TPREL) == 0)
13234 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13236 insn |= 0x3c0d0000; /* addis 0,13,0 */
13237 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13238 r_type = R_PPC64_TPREL16_HA;
13239 if (toc_symndx != 0)
13241 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13242 rel->r_addend = toc_addend;
13243 /* We changed the symbol. Start over in order to
13244 get h, sym, sec etc. right. */
13249 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13255 && (tls_mask & TLS_TPREL) == 0)
13257 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13258 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13261 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13262 /* Was PPC64_TLS which sits on insn boundary, now
13263 PPC64_TPREL16_LO which is at low-order half-word. */
13264 rel->r_offset += d_offset;
13265 r_type = R_PPC64_TPREL16_LO;
13266 if (toc_symndx != 0)
13268 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13269 rel->r_addend = toc_addend;
13270 /* We changed the symbol. Start over in order to
13271 get h, sym, sec etc. right. */
13276 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13280 case R_PPC64_GOT_TLSGD16_HI:
13281 case R_PPC64_GOT_TLSGD16_HA:
13282 tls_gd = TLS_TPRELGD;
13283 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13287 case R_PPC64_GOT_TLSLD16_HI:
13288 case R_PPC64_GOT_TLSLD16_HA:
13289 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13292 if ((tls_mask & tls_gd) != 0)
13293 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13294 + R_PPC64_GOT_TPREL16_DS);
13297 rel->r_offset -= d_offset;
13298 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13299 r_type = R_PPC64_NONE;
13301 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13305 case R_PPC64_GOT_TLSGD16:
13306 case R_PPC64_GOT_TLSGD16_LO:
13307 tls_gd = TLS_TPRELGD;
13308 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13312 case R_PPC64_GOT_TLSLD16:
13313 case R_PPC64_GOT_TLSLD16_LO:
13314 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13316 unsigned int insn1, insn2, insn3;
13320 offset = (bfd_vma) -1;
13321 /* If not using the newer R_PPC64_TLSGD/LD to mark
13322 __tls_get_addr calls, we must trust that the call
13323 stays with its arg setup insns, ie. that the next
13324 reloc is the __tls_get_addr call associated with
13325 the current reloc. Edit both insns. */
13326 if (input_section->has_tls_get_addr_call
13327 && rel + 1 < relend
13328 && branch_reloc_hash_match (input_bfd, rel + 1,
13329 htab->tls_get_addr,
13330 htab->tls_get_addr_fd))
13331 offset = rel[1].r_offset;
13332 if ((tls_mask & tls_gd) != 0)
13335 insn1 = bfd_get_32 (output_bfd,
13336 contents + rel->r_offset - d_offset);
13337 insn1 &= (1 << 26) - (1 << 2);
13338 insn1 |= 58 << 26; /* ld */
13339 insn2 = 0x7c636a14; /* add 3,3,13 */
13340 if (offset != (bfd_vma) -1)
13341 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13342 if ((tls_mask & TLS_EXPLICIT) == 0)
13343 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13344 + R_PPC64_GOT_TPREL16_DS);
13346 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13347 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13352 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13353 insn2 = 0x38630000; /* addi 3,3,0 */
13356 /* Was an LD reloc. */
13358 sec = local_sections[toc_symndx];
13360 r_symndx < symtab_hdr->sh_info;
13362 if (local_sections[r_symndx] == sec)
13364 if (r_symndx >= symtab_hdr->sh_info)
13365 r_symndx = STN_UNDEF;
13366 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13367 if (r_symndx != STN_UNDEF)
13368 rel->r_addend -= (local_syms[r_symndx].st_value
13369 + sec->output_offset
13370 + sec->output_section->vma);
13372 else if (toc_symndx != 0)
13374 r_symndx = toc_symndx;
13375 rel->r_addend = toc_addend;
13377 r_type = R_PPC64_TPREL16_HA;
13378 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379 if (offset != (bfd_vma) -1)
13381 rel[1].r_info = ELF64_R_INFO (r_symndx,
13382 R_PPC64_TPREL16_LO);
13383 rel[1].r_offset = offset + d_offset;
13384 rel[1].r_addend = rel->r_addend;
13387 bfd_put_32 (output_bfd, insn1,
13388 contents + rel->r_offset - d_offset);
13389 if (offset != (bfd_vma) -1)
13391 insn3 = bfd_get_32 (output_bfd,
13392 contents + offset + 4);
13394 || insn3 == CROR_151515 || insn3 == CROR_313131)
13396 rel[1].r_offset += 4;
13397 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13400 bfd_put_32 (output_bfd, insn2, contents + offset);
13402 if ((tls_mask & tls_gd) == 0
13403 && (tls_gd == 0 || toc_symndx != 0))
13405 /* We changed the symbol. Start over in order
13406 to get h, sym, sec etc. right. */
13413 case R_PPC64_TLSGD:
13414 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13416 unsigned int insn2, insn3;
13417 bfd_vma offset = rel->r_offset;
13419 if ((tls_mask & TLS_TPRELGD) != 0)
13422 r_type = R_PPC64_NONE;
13423 insn2 = 0x7c636a14; /* add 3,3,13 */
13428 if (toc_symndx != 0)
13430 r_symndx = toc_symndx;
13431 rel->r_addend = toc_addend;
13433 r_type = R_PPC64_TPREL16_LO;
13434 rel->r_offset = offset + d_offset;
13435 insn2 = 0x38630000; /* addi 3,3,0 */
13437 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13438 /* Zap the reloc on the _tls_get_addr call too. */
13439 BFD_ASSERT (offset == rel[1].r_offset);
13440 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13441 insn3 = bfd_get_32 (output_bfd,
13442 contents + offset + 4);
13444 || insn3 == CROR_151515 || insn3 == CROR_313131)
13446 rel->r_offset += 4;
13447 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13450 bfd_put_32 (output_bfd, insn2, contents + offset);
13451 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13459 case R_PPC64_TLSLD:
13460 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13462 unsigned int insn2, insn3;
13463 bfd_vma offset = rel->r_offset;
13466 sec = local_sections[toc_symndx];
13468 r_symndx < symtab_hdr->sh_info;
13470 if (local_sections[r_symndx] == sec)
13472 if (r_symndx >= symtab_hdr->sh_info)
13473 r_symndx = STN_UNDEF;
13474 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13475 if (r_symndx != STN_UNDEF)
13476 rel->r_addend -= (local_syms[r_symndx].st_value
13477 + sec->output_offset
13478 + sec->output_section->vma);
13480 r_type = R_PPC64_TPREL16_LO;
13481 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13482 rel->r_offset = offset + d_offset;
13483 /* Zap the reloc on the _tls_get_addr call too. */
13484 BFD_ASSERT (offset == rel[1].r_offset);
13485 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13486 insn2 = 0x38630000; /* addi 3,3,0 */
13487 insn3 = bfd_get_32 (output_bfd,
13488 contents + offset + 4);
13490 || insn3 == CROR_151515 || insn3 == CROR_313131)
13492 rel->r_offset += 4;
13493 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13496 bfd_put_32 (output_bfd, insn2, contents + offset);
13502 case R_PPC64_DTPMOD64:
13503 if (rel + 1 < relend
13504 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13505 && rel[1].r_offset == rel->r_offset + 8)
13507 if ((tls_mask & TLS_GD) == 0)
13509 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13510 if ((tls_mask & TLS_TPRELGD) != 0)
13511 r_type = R_PPC64_TPREL64;
13514 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13515 r_type = R_PPC64_NONE;
13517 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13522 if ((tls_mask & TLS_LD) == 0)
13524 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13525 r_type = R_PPC64_NONE;
13526 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13531 case R_PPC64_TPREL64:
13532 if ((tls_mask & TLS_TPREL) == 0)
13534 r_type = R_PPC64_NONE;
13535 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13539 case R_PPC64_REL16_HA:
13540 /* If we are generating a non-PIC executable, edit
13541 . 0: addis 2,12,.TOC.-0b@ha
13542 . addi 2,2,.TOC.-0b@l
13543 used by ELFv2 global entry points to set up r2, to
13546 if .TOC. is in range. */
13548 && h != NULL && &h->elf == htab->elf.hgot
13549 && rel + 1 < relend
13550 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13551 && rel[1].r_offset == rel->r_offset + 4
13552 && rel[1].r_addend == rel->r_addend + 4
13553 && relocation + 0x80008000 <= 0xffffffff)
13555 unsigned int insn1, insn2;
13556 bfd_vma offset = rel->r_offset - d_offset;
13557 insn1 = bfd_get_32 (output_bfd, contents + offset);
13558 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13559 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13560 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13562 r_type = R_PPC64_ADDR16_HA;
13563 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13564 rel->r_addend -= d_offset;
13565 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13566 rel[1].r_addend -= d_offset + 4;
13567 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13573 /* Handle other relocations that tweak non-addend part of insn. */
13575 max_br_offset = 1 << 25;
13576 addend = rel->r_addend;
13577 reloc_dest = DEST_NORMAL;
13583 case R_PPC64_TOCSAVE:
13584 if (relocation + addend == (rel->r_offset
13585 + input_section->output_offset
13586 + input_section->output_section->vma)
13587 && tocsave_find (htab, NO_INSERT,
13588 &local_syms, rel, input_bfd))
13590 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13592 || insn == CROR_151515 || insn == CROR_313131)
13593 bfd_put_32 (input_bfd,
13594 STD_R2_0R1 + STK_TOC (htab),
13595 contents + rel->r_offset);
13599 /* Branch taken prediction relocations. */
13600 case R_PPC64_ADDR14_BRTAKEN:
13601 case R_PPC64_REL14_BRTAKEN:
13602 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13605 /* Branch not taken prediction relocations. */
13606 case R_PPC64_ADDR14_BRNTAKEN:
13607 case R_PPC64_REL14_BRNTAKEN:
13608 insn |= bfd_get_32 (output_bfd,
13609 contents + rel->r_offset) & ~(0x01 << 21);
13612 case R_PPC64_REL14:
13613 max_br_offset = 1 << 15;
13616 case R_PPC64_REL24:
13617 /* Calls to functions with a different TOC, such as calls to
13618 shared objects, need to alter the TOC pointer. This is
13619 done using a linkage stub. A REL24 branching to these
13620 linkage stubs needs to be followed by a nop, as the nop
13621 will be replaced with an instruction to restore the TOC
13626 && h->oh->is_func_descriptor)
13627 fdh = ppc_follow_link (h->oh);
13628 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13630 if (stub_entry != NULL
13631 && (stub_entry->stub_type == ppc_stub_plt_call
13632 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13633 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13634 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13636 bfd_boolean can_plt_call = FALSE;
13638 /* All of these stubs will modify r2, so there must be a
13639 branch and link followed by a nop. The nop is
13640 replaced by an insn to restore r2. */
13641 if (rel->r_offset + 8 <= input_section->size)
13645 br = bfd_get_32 (input_bfd,
13646 contents + rel->r_offset);
13651 nop = bfd_get_32 (input_bfd,
13652 contents + rel->r_offset + 4);
13654 || nop == CROR_151515 || nop == CROR_313131)
13657 && (h == htab->tls_get_addr_fd
13658 || h == htab->tls_get_addr)
13659 && !htab->params->no_tls_get_addr_opt)
13661 /* Special stub used, leave nop alone. */
13664 bfd_put_32 (input_bfd,
13665 LD_R2_0R1 + STK_TOC (htab),
13666 contents + rel->r_offset + 4);
13667 can_plt_call = TRUE;
13672 if (!can_plt_call && h != NULL)
13674 const char *name = h->elf.root.root.string;
13679 if (strncmp (name, "__libc_start_main", 17) == 0
13680 && (name[17] == 0 || name[17] == '@'))
13682 /* Allow crt1 branch to go via a toc adjusting
13683 stub. Other calls that never return could do
13684 the same, if we could detect such. */
13685 can_plt_call = TRUE;
13691 /* g++ as of 20130507 emits self-calls without a
13692 following nop. This is arguably wrong since we
13693 have conflicting information. On the one hand a
13694 global symbol and on the other a local call
13695 sequence, but don't error for this special case.
13696 It isn't possible to cheaply verify we have
13697 exactly such a call. Allow all calls to the same
13699 asection *code_sec = sec;
13701 if (get_opd_info (sec) != NULL)
13703 bfd_vma off = (relocation + addend
13704 - sec->output_section->vma
13705 - sec->output_offset);
13707 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13709 if (code_sec == input_section)
13710 can_plt_call = TRUE;
13715 info->callbacks->einfo
13716 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13717 "recompile with -fPIC\n"),
13718 input_bfd, input_section, rel->r_offset, sym_name);
13720 bfd_set_error (bfd_error_bad_value);
13725 && (stub_entry->stub_type == ppc_stub_plt_call
13726 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13727 unresolved_reloc = FALSE;
13730 if ((stub_entry == NULL
13731 || stub_entry->stub_type == ppc_stub_long_branch
13732 || stub_entry->stub_type == ppc_stub_plt_branch)
13733 && get_opd_info (sec) != NULL)
13735 /* The branch destination is the value of the opd entry. */
13736 bfd_vma off = (relocation + addend
13737 - sec->output_section->vma
13738 - sec->output_offset);
13739 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13740 if (dest != (bfd_vma) -1)
13744 reloc_dest = DEST_OPD;
13748 /* If the branch is out of reach we ought to have a long
13750 from = (rel->r_offset
13751 + input_section->output_offset
13752 + input_section->output_section->vma);
13754 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13758 if (stub_entry != NULL
13759 && (stub_entry->stub_type == ppc_stub_long_branch
13760 || stub_entry->stub_type == ppc_stub_plt_branch)
13761 && (r_type == R_PPC64_ADDR14_BRTAKEN
13762 || r_type == R_PPC64_ADDR14_BRNTAKEN
13763 || (relocation + addend - from + max_br_offset
13764 < 2 * max_br_offset)))
13765 /* Don't use the stub if this branch is in range. */
13768 if (stub_entry != NULL)
13770 /* Munge up the value and addend so that we call the stub
13771 rather than the procedure directly. */
13772 relocation = (stub_entry->stub_offset
13773 + stub_entry->stub_sec->output_offset
13774 + stub_entry->stub_sec->output_section->vma);
13776 reloc_dest = DEST_STUB;
13778 if ((stub_entry->stub_type == ppc_stub_plt_call
13779 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13780 && (ALWAYS_EMIT_R2SAVE
13781 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13782 && rel + 1 < relend
13783 && rel[1].r_offset == rel->r_offset + 4
13784 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13792 /* Set 'a' bit. This is 0b00010 in BO field for branch
13793 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13794 for branch on CTR insns (BO == 1a00t or 1a01t). */
13795 if ((insn & (0x14 << 21)) == (0x04 << 21))
13796 insn |= 0x02 << 21;
13797 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13798 insn |= 0x08 << 21;
13804 /* Invert 'y' bit if not the default. */
13805 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13806 insn ^= 0x01 << 21;
13809 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13812 /* NOP out calls to undefined weak functions.
13813 We can thus call a weak function without first
13814 checking whether the function is defined. */
13816 && h->elf.root.type == bfd_link_hash_undefweak
13817 && h->elf.dynindx == -1
13818 && r_type == R_PPC64_REL24
13822 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13828 /* Set `addend'. */
13833 info->callbacks->einfo
13834 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13835 input_bfd, (int) r_type, sym_name);
13837 bfd_set_error (bfd_error_bad_value);
13843 case R_PPC64_TLSGD:
13844 case R_PPC64_TLSLD:
13845 case R_PPC64_TOCSAVE:
13846 case R_PPC64_GNU_VTINHERIT:
13847 case R_PPC64_GNU_VTENTRY:
13850 /* GOT16 relocations. Like an ADDR16 using the symbol's
13851 address in the GOT as relocation value instead of the
13852 symbol's value itself. Also, create a GOT entry for the
13853 symbol and put the symbol value there. */
13854 case R_PPC64_GOT_TLSGD16:
13855 case R_PPC64_GOT_TLSGD16_LO:
13856 case R_PPC64_GOT_TLSGD16_HI:
13857 case R_PPC64_GOT_TLSGD16_HA:
13858 tls_type = TLS_TLS | TLS_GD;
13861 case R_PPC64_GOT_TLSLD16:
13862 case R_PPC64_GOT_TLSLD16_LO:
13863 case R_PPC64_GOT_TLSLD16_HI:
13864 case R_PPC64_GOT_TLSLD16_HA:
13865 tls_type = TLS_TLS | TLS_LD;
13868 case R_PPC64_GOT_TPREL16_DS:
13869 case R_PPC64_GOT_TPREL16_LO_DS:
13870 case R_PPC64_GOT_TPREL16_HI:
13871 case R_PPC64_GOT_TPREL16_HA:
13872 tls_type = TLS_TLS | TLS_TPREL;
13875 case R_PPC64_GOT_DTPREL16_DS:
13876 case R_PPC64_GOT_DTPREL16_LO_DS:
13877 case R_PPC64_GOT_DTPREL16_HI:
13878 case R_PPC64_GOT_DTPREL16_HA:
13879 tls_type = TLS_TLS | TLS_DTPREL;
13882 case R_PPC64_GOT16:
13883 case R_PPC64_GOT16_LO:
13884 case R_PPC64_GOT16_HI:
13885 case R_PPC64_GOT16_HA:
13886 case R_PPC64_GOT16_DS:
13887 case R_PPC64_GOT16_LO_DS:
13890 /* Relocation is to the entry for this symbol in the global
13895 unsigned long indx = 0;
13896 struct got_entry *ent;
13898 if (tls_type == (TLS_TLS | TLS_LD)
13900 || !h->elf.def_dynamic))
13901 ent = ppc64_tlsld_got (input_bfd);
13907 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13908 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13911 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13912 /* This is actually a static link, or it is a
13913 -Bsymbolic link and the symbol is defined
13914 locally, or the symbol was forced to be local
13915 because of a version file. */
13919 BFD_ASSERT (h->elf.dynindx != -1);
13920 indx = h->elf.dynindx;
13921 unresolved_reloc = FALSE;
13923 ent = h->elf.got.glist;
13927 if (local_got_ents == NULL)
13929 ent = local_got_ents[r_symndx];
13932 for (; ent != NULL; ent = ent->next)
13933 if (ent->addend == orig_rel.r_addend
13934 && ent->owner == input_bfd
13935 && ent->tls_type == tls_type)
13941 if (ent->is_indirect)
13942 ent = ent->got.ent;
13943 offp = &ent->got.offset;
13944 got = ppc64_elf_tdata (ent->owner)->got;
13948 /* The offset must always be a multiple of 8. We use the
13949 least significant bit to record whether we have already
13950 processed this entry. */
13952 if ((off & 1) != 0)
13956 /* Generate relocs for the dynamic linker, except in
13957 the case of TLSLD where we'll use one entry per
13965 ? h->elf.type == STT_GNU_IFUNC
13966 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13968 relgot = htab->elf.irelplt;
13969 else if ((info->shared || indx != 0)
13971 || (tls_type == (TLS_TLS | TLS_LD)
13972 && !h->elf.def_dynamic)
13973 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13974 || h->elf.root.type != bfd_link_hash_undefweak))
13975 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13976 if (relgot != NULL)
13978 outrel.r_offset = (got->output_section->vma
13979 + got->output_offset
13981 outrel.r_addend = addend;
13982 if (tls_type & (TLS_LD | TLS_GD))
13984 outrel.r_addend = 0;
13985 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13986 if (tls_type == (TLS_TLS | TLS_GD))
13988 loc = relgot->contents;
13989 loc += (relgot->reloc_count++
13990 * sizeof (Elf64_External_Rela));
13991 bfd_elf64_swap_reloca_out (output_bfd,
13993 outrel.r_offset += 8;
13994 outrel.r_addend = addend;
13996 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13999 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14000 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14001 else if (tls_type == (TLS_TLS | TLS_TPREL))
14002 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14003 else if (indx != 0)
14004 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14008 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14010 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14012 /* Write the .got section contents for the sake
14014 loc = got->contents + off;
14015 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14019 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14021 outrel.r_addend += relocation;
14022 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14023 outrel.r_addend -= htab->elf.tls_sec->vma;
14025 loc = relgot->contents;
14026 loc += (relgot->reloc_count++
14027 * sizeof (Elf64_External_Rela));
14028 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14031 /* Init the .got section contents here if we're not
14032 emitting a reloc. */
14035 relocation += addend;
14036 if (tls_type == (TLS_TLS | TLS_LD))
14038 else if (tls_type != 0)
14040 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14041 if (tls_type == (TLS_TLS | TLS_TPREL))
14042 relocation += DTP_OFFSET - TP_OFFSET;
14044 if (tls_type == (TLS_TLS | TLS_GD))
14046 bfd_put_64 (output_bfd, relocation,
14047 got->contents + off + 8);
14052 bfd_put_64 (output_bfd, relocation,
14053 got->contents + off);
14057 if (off >= (bfd_vma) -2)
14060 relocation = got->output_section->vma + got->output_offset + off;
14061 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14065 case R_PPC64_PLT16_HA:
14066 case R_PPC64_PLT16_HI:
14067 case R_PPC64_PLT16_LO:
14068 case R_PPC64_PLT32:
14069 case R_PPC64_PLT64:
14070 /* Relocation is to the entry for this symbol in the
14071 procedure linkage table. */
14073 /* Resolve a PLT reloc against a local symbol directly,
14074 without using the procedure linkage table. */
14078 /* It's possible that we didn't make a PLT entry for this
14079 symbol. This happens when statically linking PIC code,
14080 or when using -Bsymbolic. Go find a match if there is a
14082 if (htab->elf.splt != NULL)
14084 struct plt_entry *ent;
14085 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14086 if (ent->plt.offset != (bfd_vma) -1
14087 && ent->addend == orig_rel.r_addend)
14089 relocation = (htab->elf.splt->output_section->vma
14090 + htab->elf.splt->output_offset
14091 + ent->plt.offset);
14092 unresolved_reloc = FALSE;
14099 /* Relocation value is TOC base. */
14100 relocation = TOCstart;
14101 if (r_symndx == STN_UNDEF)
14102 relocation += htab->stub_group[input_section->id].toc_off;
14103 else if (unresolved_reloc)
14105 else if (sec != NULL && sec->id <= htab->top_id)
14106 relocation += htab->stub_group[sec->id].toc_off;
14108 unresolved_reloc = TRUE;
14111 /* TOC16 relocs. We want the offset relative to the TOC base,
14112 which is the address of the start of the TOC plus 0x8000.
14113 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14115 case R_PPC64_TOC16:
14116 case R_PPC64_TOC16_LO:
14117 case R_PPC64_TOC16_HI:
14118 case R_PPC64_TOC16_DS:
14119 case R_PPC64_TOC16_LO_DS:
14120 case R_PPC64_TOC16_HA:
14121 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14124 /* Relocate against the beginning of the section. */
14125 case R_PPC64_SECTOFF:
14126 case R_PPC64_SECTOFF_LO:
14127 case R_PPC64_SECTOFF_HI:
14128 case R_PPC64_SECTOFF_DS:
14129 case R_PPC64_SECTOFF_LO_DS:
14130 case R_PPC64_SECTOFF_HA:
14132 addend -= sec->output_section->vma;
14135 case R_PPC64_REL16:
14136 case R_PPC64_REL16_LO:
14137 case R_PPC64_REL16_HI:
14138 case R_PPC64_REL16_HA:
14141 case R_PPC64_REL14:
14142 case R_PPC64_REL14_BRNTAKEN:
14143 case R_PPC64_REL14_BRTAKEN:
14144 case R_PPC64_REL24:
14147 case R_PPC64_TPREL16:
14148 case R_PPC64_TPREL16_LO:
14149 case R_PPC64_TPREL16_HI:
14150 case R_PPC64_TPREL16_HA:
14151 case R_PPC64_TPREL16_DS:
14152 case R_PPC64_TPREL16_LO_DS:
14153 case R_PPC64_TPREL16_HIGH:
14154 case R_PPC64_TPREL16_HIGHA:
14155 case R_PPC64_TPREL16_HIGHER:
14156 case R_PPC64_TPREL16_HIGHERA:
14157 case R_PPC64_TPREL16_HIGHEST:
14158 case R_PPC64_TPREL16_HIGHESTA:
14160 && h->elf.root.type == bfd_link_hash_undefweak
14161 && h->elf.dynindx == -1)
14163 /* Make this relocation against an undefined weak symbol
14164 resolve to zero. This is really just a tweak, since
14165 code using weak externs ought to check that they are
14166 defined before using them. */
14167 bfd_byte *p = contents + rel->r_offset - d_offset;
14169 insn = bfd_get_32 (output_bfd, p);
14170 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14172 bfd_put_32 (output_bfd, insn, p);
14175 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14177 /* The TPREL16 relocs shouldn't really be used in shared
14178 libs as they will result in DT_TEXTREL being set, but
14179 support them anyway. */
14183 case R_PPC64_DTPREL16:
14184 case R_PPC64_DTPREL16_LO:
14185 case R_PPC64_DTPREL16_HI:
14186 case R_PPC64_DTPREL16_HA:
14187 case R_PPC64_DTPREL16_DS:
14188 case R_PPC64_DTPREL16_LO_DS:
14189 case R_PPC64_DTPREL16_HIGH:
14190 case R_PPC64_DTPREL16_HIGHA:
14191 case R_PPC64_DTPREL16_HIGHER:
14192 case R_PPC64_DTPREL16_HIGHERA:
14193 case R_PPC64_DTPREL16_HIGHEST:
14194 case R_PPC64_DTPREL16_HIGHESTA:
14195 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14198 case R_PPC64_ADDR64_LOCAL:
14199 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14204 case R_PPC64_DTPMOD64:
14209 case R_PPC64_TPREL64:
14210 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14213 case R_PPC64_DTPREL64:
14214 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14217 /* Relocations that may need to be propagated if this is a
14219 case R_PPC64_REL30:
14220 case R_PPC64_REL32:
14221 case R_PPC64_REL64:
14222 case R_PPC64_ADDR14:
14223 case R_PPC64_ADDR14_BRNTAKEN:
14224 case R_PPC64_ADDR14_BRTAKEN:
14225 case R_PPC64_ADDR16:
14226 case R_PPC64_ADDR16_DS:
14227 case R_PPC64_ADDR16_HA:
14228 case R_PPC64_ADDR16_HI:
14229 case R_PPC64_ADDR16_HIGH:
14230 case R_PPC64_ADDR16_HIGHA:
14231 case R_PPC64_ADDR16_HIGHER:
14232 case R_PPC64_ADDR16_HIGHERA:
14233 case R_PPC64_ADDR16_HIGHEST:
14234 case R_PPC64_ADDR16_HIGHESTA:
14235 case R_PPC64_ADDR16_LO:
14236 case R_PPC64_ADDR16_LO_DS:
14237 case R_PPC64_ADDR24:
14238 case R_PPC64_ADDR32:
14239 case R_PPC64_ADDR64:
14240 case R_PPC64_UADDR16:
14241 case R_PPC64_UADDR32:
14242 case R_PPC64_UADDR64:
14244 if ((input_section->flags & SEC_ALLOC) == 0)
14247 if (NO_OPD_RELOCS && is_opd)
14252 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14253 || h->elf.root.type != bfd_link_hash_undefweak)
14254 && (must_be_dyn_reloc (info, r_type)
14255 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14256 || (ELIMINATE_COPY_RELOCS
14259 && h->elf.dynindx != -1
14260 && !h->elf.non_got_ref
14261 && !h->elf.def_regular)
14264 ? h->elf.type == STT_GNU_IFUNC
14265 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14267 bfd_boolean skip, relocate;
14271 /* When generating a dynamic object, these relocations
14272 are copied into the output file to be resolved at run
14278 out_off = _bfd_elf_section_offset (output_bfd, info,
14279 input_section, rel->r_offset);
14280 if (out_off == (bfd_vma) -1)
14282 else if (out_off == (bfd_vma) -2)
14283 skip = TRUE, relocate = TRUE;
14284 out_off += (input_section->output_section->vma
14285 + input_section->output_offset);
14286 outrel.r_offset = out_off;
14287 outrel.r_addend = rel->r_addend;
14289 /* Optimize unaligned reloc use. */
14290 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14291 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14292 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14293 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14294 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14295 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14296 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14297 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14298 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14301 memset (&outrel, 0, sizeof outrel);
14302 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14304 && r_type != R_PPC64_TOC)
14306 BFD_ASSERT (h->elf.dynindx != -1);
14307 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14311 /* This symbol is local, or marked to become local,
14312 or this is an opd section reloc which must point
14313 at a local function. */
14314 outrel.r_addend += relocation;
14315 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14317 if (is_opd && h != NULL)
14319 /* Lie about opd entries. This case occurs
14320 when building shared libraries and we
14321 reference a function in another shared
14322 lib. The same thing happens for a weak
14323 definition in an application that's
14324 overridden by a strong definition in a
14325 shared lib. (I believe this is a generic
14326 bug in binutils handling of weak syms.)
14327 In these cases we won't use the opd
14328 entry in this lib. */
14329 unresolved_reloc = FALSE;
14332 && r_type == R_PPC64_ADDR64
14334 ? h->elf.type == STT_GNU_IFUNC
14335 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14336 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14339 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14341 /* We need to relocate .opd contents for ld.so.
14342 Prelink also wants simple and consistent rules
14343 for relocs. This make all RELATIVE relocs have
14344 *r_offset equal to r_addend. */
14353 ? h->elf.type == STT_GNU_IFUNC
14354 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14356 info->callbacks->einfo
14357 (_("%P: %H: %s for indirect "
14358 "function `%T' unsupported\n"),
14359 input_bfd, input_section, rel->r_offset,
14360 ppc64_elf_howto_table[r_type]->name,
14364 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14366 else if (sec == NULL || sec->owner == NULL)
14368 bfd_set_error (bfd_error_bad_value);
14375 osec = sec->output_section;
14376 indx = elf_section_data (osec)->dynindx;
14380 if ((osec->flags & SEC_READONLY) == 0
14381 && htab->elf.data_index_section != NULL)
14382 osec = htab->elf.data_index_section;
14384 osec = htab->elf.text_index_section;
14385 indx = elf_section_data (osec)->dynindx;
14387 BFD_ASSERT (indx != 0);
14389 /* We are turning this relocation into one
14390 against a section symbol, so subtract out
14391 the output section's address but not the
14392 offset of the input section in the output
14394 outrel.r_addend -= osec->vma;
14397 outrel.r_info = ELF64_R_INFO (indx, r_type);
14401 sreloc = elf_section_data (input_section)->sreloc;
14403 ? h->elf.type == STT_GNU_IFUNC
14404 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14405 sreloc = htab->elf.irelplt;
14406 if (sreloc == NULL)
14409 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14412 loc = sreloc->contents;
14413 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14414 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14416 /* If this reloc is against an external symbol, it will
14417 be computed at runtime, so there's no need to do
14418 anything now. However, for the sake of prelink ensure
14419 that the section contents are a known value. */
14422 unresolved_reloc = FALSE;
14423 /* The value chosen here is quite arbitrary as ld.so
14424 ignores section contents except for the special
14425 case of .opd where the contents might be accessed
14426 before relocation. Choose zero, as that won't
14427 cause reloc overflow. */
14430 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14431 to improve backward compatibility with older
14433 if (r_type == R_PPC64_ADDR64)
14434 addend = outrel.r_addend;
14435 /* Adjust pc_relative relocs to have zero in *r_offset. */
14436 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14437 addend = (input_section->output_section->vma
14438 + input_section->output_offset
14445 case R_PPC64_GLOB_DAT:
14446 case R_PPC64_JMP_SLOT:
14447 case R_PPC64_JMP_IREL:
14448 case R_PPC64_RELATIVE:
14449 /* We shouldn't ever see these dynamic relocs in relocatable
14451 /* Fall through. */
14453 case R_PPC64_PLTGOT16:
14454 case R_PPC64_PLTGOT16_DS:
14455 case R_PPC64_PLTGOT16_HA:
14456 case R_PPC64_PLTGOT16_HI:
14457 case R_PPC64_PLTGOT16_LO:
14458 case R_PPC64_PLTGOT16_LO_DS:
14459 case R_PPC64_PLTREL32:
14460 case R_PPC64_PLTREL64:
14461 /* These ones haven't been implemented yet. */
14463 info->callbacks->einfo
14464 (_("%P: %B: %s is not supported for `%T'\n"),
14466 ppc64_elf_howto_table[r_type]->name, sym_name);
14468 bfd_set_error (bfd_error_invalid_operation);
14473 /* Multi-instruction sequences that access the TOC can be
14474 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14475 to nop; addi rb,r2,x; */
14481 case R_PPC64_GOT_TLSLD16_HI:
14482 case R_PPC64_GOT_TLSGD16_HI:
14483 case R_PPC64_GOT_TPREL16_HI:
14484 case R_PPC64_GOT_DTPREL16_HI:
14485 case R_PPC64_GOT16_HI:
14486 case R_PPC64_TOC16_HI:
14487 /* These relocs would only be useful if building up an
14488 offset to later add to r2, perhaps in an indexed
14489 addressing mode instruction. Don't try to optimize.
14490 Unfortunately, the possibility of someone building up an
14491 offset like this or even with the HA relocs, means that
14492 we need to check the high insn when optimizing the low
14496 case R_PPC64_GOT_TLSLD16_HA:
14497 case R_PPC64_GOT_TLSGD16_HA:
14498 case R_PPC64_GOT_TPREL16_HA:
14499 case R_PPC64_GOT_DTPREL16_HA:
14500 case R_PPC64_GOT16_HA:
14501 case R_PPC64_TOC16_HA:
14502 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14503 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14505 bfd_byte *p = contents + (rel->r_offset & ~3);
14506 bfd_put_32 (input_bfd, NOP, p);
14510 case R_PPC64_GOT_TLSLD16_LO:
14511 case R_PPC64_GOT_TLSGD16_LO:
14512 case R_PPC64_GOT_TPREL16_LO_DS:
14513 case R_PPC64_GOT_DTPREL16_LO_DS:
14514 case R_PPC64_GOT16_LO:
14515 case R_PPC64_GOT16_LO_DS:
14516 case R_PPC64_TOC16_LO:
14517 case R_PPC64_TOC16_LO_DS:
14518 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14519 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14521 bfd_byte *p = contents + (rel->r_offset & ~3);
14522 insn = bfd_get_32 (input_bfd, p);
14523 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14525 /* Transform addic to addi when we change reg. */
14526 insn &= ~((0x3f << 26) | (0x1f << 16));
14527 insn |= (14u << 26) | (2 << 16);
14531 insn &= ~(0x1f << 16);
14534 bfd_put_32 (input_bfd, insn, p);
14539 /* Do any further special processing. */
14540 howto = ppc64_elf_howto_table[(int) r_type];
14546 case R_PPC64_REL16_HA:
14547 case R_PPC64_ADDR16_HA:
14548 case R_PPC64_ADDR16_HIGHA:
14549 case R_PPC64_ADDR16_HIGHERA:
14550 case R_PPC64_ADDR16_HIGHESTA:
14551 case R_PPC64_TOC16_HA:
14552 case R_PPC64_SECTOFF_HA:
14553 case R_PPC64_TPREL16_HA:
14554 case R_PPC64_TPREL16_HIGHA:
14555 case R_PPC64_TPREL16_HIGHERA:
14556 case R_PPC64_TPREL16_HIGHESTA:
14557 case R_PPC64_DTPREL16_HA:
14558 case R_PPC64_DTPREL16_HIGHA:
14559 case R_PPC64_DTPREL16_HIGHERA:
14560 case R_PPC64_DTPREL16_HIGHESTA:
14561 /* It's just possible that this symbol is a weak symbol
14562 that's not actually defined anywhere. In that case,
14563 'sec' would be NULL, and we should leave the symbol
14564 alone (it will be set to zero elsewhere in the link). */
14569 case R_PPC64_GOT16_HA:
14570 case R_PPC64_PLTGOT16_HA:
14571 case R_PPC64_PLT16_HA:
14572 case R_PPC64_GOT_TLSGD16_HA:
14573 case R_PPC64_GOT_TLSLD16_HA:
14574 case R_PPC64_GOT_TPREL16_HA:
14575 case R_PPC64_GOT_DTPREL16_HA:
14576 /* Add 0x10000 if sign bit in 0:15 is set.
14577 Bits 0:15 are not used. */
14581 case R_PPC64_ADDR16_DS:
14582 case R_PPC64_ADDR16_LO_DS:
14583 case R_PPC64_GOT16_DS:
14584 case R_PPC64_GOT16_LO_DS:
14585 case R_PPC64_PLT16_LO_DS:
14586 case R_PPC64_SECTOFF_DS:
14587 case R_PPC64_SECTOFF_LO_DS:
14588 case R_PPC64_TOC16_DS:
14589 case R_PPC64_TOC16_LO_DS:
14590 case R_PPC64_PLTGOT16_DS:
14591 case R_PPC64_PLTGOT16_LO_DS:
14592 case R_PPC64_GOT_TPREL16_DS:
14593 case R_PPC64_GOT_TPREL16_LO_DS:
14594 case R_PPC64_GOT_DTPREL16_DS:
14595 case R_PPC64_GOT_DTPREL16_LO_DS:
14596 case R_PPC64_TPREL16_DS:
14597 case R_PPC64_TPREL16_LO_DS:
14598 case R_PPC64_DTPREL16_DS:
14599 case R_PPC64_DTPREL16_LO_DS:
14600 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14602 /* If this reloc is against an lq insn, then the value must be
14603 a multiple of 16. This is somewhat of a hack, but the
14604 "correct" way to do this by defining _DQ forms of all the
14605 _DS relocs bloats all reloc switches in this file. It
14606 doesn't seem to make much sense to use any of these relocs
14607 in data, so testing the insn should be safe. */
14608 if ((insn & (0x3f << 26)) == (56u << 26))
14610 if (((relocation + addend) & mask) != 0)
14612 info->callbacks->einfo
14613 (_("%P: %H: error: %s not a multiple of %u\n"),
14614 input_bfd, input_section, rel->r_offset,
14617 bfd_set_error (bfd_error_bad_value);
14624 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14625 because such sections are not SEC_ALLOC and thus ld.so will
14626 not process them. */
14627 if (unresolved_reloc
14628 && !((input_section->flags & SEC_DEBUGGING) != 0
14629 && h->elf.def_dynamic)
14630 && _bfd_elf_section_offset (output_bfd, info, input_section,
14631 rel->r_offset) != (bfd_vma) -1)
14633 info->callbacks->einfo
14634 (_("%P: %H: unresolvable %s against `%T'\n"),
14635 input_bfd, input_section, rel->r_offset,
14637 h->elf.root.root.string);
14641 /* 16-bit fields in insns mostly have signed values, but a
14642 few insns have 16-bit unsigned values. Really, we should
14643 have different reloc types. */
14644 if (howto->complain_on_overflow != complain_overflow_dont
14645 && howto->dst_mask == 0xffff
14646 && (input_section->flags & SEC_CODE) != 0)
14648 enum complain_overflow complain = complain_overflow_signed;
14650 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14651 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14652 complain = complain_overflow_bitfield;
14653 else if (howto->rightshift == 0
14654 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14655 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14656 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14657 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14658 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14659 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14660 complain = complain_overflow_unsigned;
14661 if (howto->complain_on_overflow != complain)
14663 alt_howto = *howto;
14664 alt_howto.complain_on_overflow = complain;
14665 howto = &alt_howto;
14669 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14670 rel->r_offset, relocation, addend);
14672 if (r != bfd_reloc_ok)
14674 char *more_info = NULL;
14675 const char *reloc_name = howto->name;
14677 if (reloc_dest != DEST_NORMAL)
14679 more_info = bfd_malloc (strlen (reloc_name) + 8);
14680 if (more_info != NULL)
14682 strcpy (more_info, reloc_name);
14683 strcat (more_info, (reloc_dest == DEST_OPD
14684 ? " (OPD)" : " (stub)"));
14685 reloc_name = more_info;
14689 if (r == bfd_reloc_overflow)
14694 && h->elf.root.type == bfd_link_hash_undefweak
14695 && howto->pc_relative)
14697 /* Assume this is a call protected by other code that
14698 detects the symbol is undefined. If this is the case,
14699 we can safely ignore the overflow. If not, the
14700 program is hosed anyway, and a little warning isn't
14706 if (!((*info->callbacks->reloc_overflow)
14707 (info, &h->elf.root, sym_name,
14708 reloc_name, orig_rel.r_addend,
14709 input_bfd, input_section, rel->r_offset)))
14714 info->callbacks->einfo
14715 (_("%P: %H: %s against `%T': error %d\n"),
14716 input_bfd, input_section, rel->r_offset,
14717 reloc_name, sym_name, (int) r);
14720 if (more_info != NULL)
14725 /* If we're emitting relocations, then shortly after this function
14726 returns, reloc offsets and addends for this section will be
14727 adjusted. Worse, reloc symbol indices will be for the output
14728 file rather than the input. Save a copy of the relocs for
14729 opd_entry_value. */
14730 if (is_opd && (info->emitrelocations || info->relocatable))
14733 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14734 rel = bfd_alloc (input_bfd, amt);
14735 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14736 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14739 memcpy (rel, relocs, amt);
14744 /* Adjust the value of any local symbols in opd sections. */
14747 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14748 const char *name ATTRIBUTE_UNUSED,
14749 Elf_Internal_Sym *elfsym,
14750 asection *input_sec,
14751 struct elf_link_hash_entry *h)
14753 struct _opd_sec_data *opd;
14760 opd = get_opd_info (input_sec);
14761 if (opd == NULL || opd->adjust == NULL)
14764 value = elfsym->st_value - input_sec->output_offset;
14765 if (!info->relocatable)
14766 value -= input_sec->output_section->vma;
14768 adjust = opd->adjust[value / 8];
14772 elfsym->st_value += adjust;
14776 /* Finish up dynamic symbol handling. We set the contents of various
14777 dynamic sections here. */
14780 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14781 struct bfd_link_info *info,
14782 struct elf_link_hash_entry *h,
14783 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14785 struct ppc_link_hash_table *htab;
14786 struct plt_entry *ent;
14787 Elf_Internal_Rela rela;
14790 htab = ppc_hash_table (info);
14794 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14795 if (ent->plt.offset != (bfd_vma) -1)
14797 /* This symbol has an entry in the procedure linkage
14798 table. Set it up. */
14799 if (!htab->elf.dynamic_sections_created
14800 || h->dynindx == -1)
14802 BFD_ASSERT (h->type == STT_GNU_IFUNC
14804 && (h->root.type == bfd_link_hash_defined
14805 || h->root.type == bfd_link_hash_defweak));
14806 rela.r_offset = (htab->elf.iplt->output_section->vma
14807 + htab->elf.iplt->output_offset
14808 + ent->plt.offset);
14810 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14812 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14813 rela.r_addend = (h->root.u.def.value
14814 + h->root.u.def.section->output_offset
14815 + h->root.u.def.section->output_section->vma
14817 loc = (htab->elf.irelplt->contents
14818 + (htab->elf.irelplt->reloc_count++
14819 * sizeof (Elf64_External_Rela)));
14823 rela.r_offset = (htab->elf.splt->output_section->vma
14824 + htab->elf.splt->output_offset
14825 + ent->plt.offset);
14826 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14827 rela.r_addend = ent->addend;
14828 loc = (htab->elf.srelplt->contents
14829 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14830 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14832 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14834 if (!htab->opd_abi)
14836 if (!h->def_regular)
14838 /* Mark the symbol as undefined, rather than as
14839 defined in glink. Leave the value if there were
14840 any relocations where pointer equality matters
14841 (this is a clue for the dynamic linker, to make
14842 function pointer comparisons work between an
14843 application and shared library), otherwise set it
14845 sym->st_shndx = SHN_UNDEF;
14846 if (!h->pointer_equality_needed)
14848 else if (!h->ref_regular_nonweak)
14850 /* This breaks function pointer comparisons, but
14851 that is better than breaking tests for a NULL
14852 function pointer. */
14861 /* This symbol needs a copy reloc. Set it up. */
14863 if (h->dynindx == -1
14864 || (h->root.type != bfd_link_hash_defined
14865 && h->root.type != bfd_link_hash_defweak)
14866 || htab->relbss == NULL)
14869 rela.r_offset = (h->root.u.def.value
14870 + h->root.u.def.section->output_section->vma
14871 + h->root.u.def.section->output_offset);
14872 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14874 loc = htab->relbss->contents;
14875 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14876 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14882 /* Used to decide how to sort relocs in an optimal manner for the
14883 dynamic linker, before writing them out. */
14885 static enum elf_reloc_type_class
14886 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14887 const asection *rel_sec,
14888 const Elf_Internal_Rela *rela)
14890 enum elf_ppc64_reloc_type r_type;
14891 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14893 if (rel_sec == htab->elf.irelplt)
14894 return reloc_class_ifunc;
14896 r_type = ELF64_R_TYPE (rela->r_info);
14899 case R_PPC64_RELATIVE:
14900 return reloc_class_relative;
14901 case R_PPC64_JMP_SLOT:
14902 return reloc_class_plt;
14904 return reloc_class_copy;
14906 return reloc_class_normal;
14910 /* Finish up the dynamic sections. */
14913 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14914 struct bfd_link_info *info)
14916 struct ppc_link_hash_table *htab;
14920 htab = ppc_hash_table (info);
14924 dynobj = htab->elf.dynobj;
14925 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14927 if (htab->elf.dynamic_sections_created)
14929 Elf64_External_Dyn *dyncon, *dynconend;
14931 if (sdyn == NULL || htab->elf.sgot == NULL)
14934 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14935 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14936 for (; dyncon < dynconend; dyncon++)
14938 Elf_Internal_Dyn dyn;
14941 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14948 case DT_PPC64_GLINK:
14950 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14951 /* We stupidly defined DT_PPC64_GLINK to be the start
14952 of glink rather than the first entry point, which is
14953 what ld.so needs, and now have a bigger stub to
14954 support automatic multiple TOCs. */
14955 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14959 s = bfd_get_section_by_name (output_bfd, ".opd");
14962 dyn.d_un.d_ptr = s->vma;
14966 if (htab->do_multi_toc && htab->multi_toc_needed)
14967 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14970 case DT_PPC64_OPDSZ:
14971 s = bfd_get_section_by_name (output_bfd, ".opd");
14974 dyn.d_un.d_val = s->size;
14978 s = htab->elf.splt;
14979 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14983 s = htab->elf.srelplt;
14984 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14988 dyn.d_un.d_val = htab->elf.srelplt->size;
14992 /* Don't count procedure linkage table relocs in the
14993 overall reloc count. */
14994 s = htab->elf.srelplt;
14997 dyn.d_un.d_val -= s->size;
15001 /* We may not be using the standard ELF linker script.
15002 If .rela.plt is the first .rela section, we adjust
15003 DT_RELA to not include it. */
15004 s = htab->elf.srelplt;
15007 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15009 dyn.d_un.d_ptr += s->size;
15013 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15017 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15019 /* Fill in the first entry in the global offset table.
15020 We use it to hold the link-time TOCbase. */
15021 bfd_put_64 (output_bfd,
15022 elf_gp (output_bfd) + TOC_BASE_OFF,
15023 htab->elf.sgot->contents);
15025 /* Set .got entry size. */
15026 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15029 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15031 /* Set .plt entry size. */
15032 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15033 = PLT_ENTRY_SIZE (htab);
15036 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15037 brlt ourselves if emitrelocations. */
15038 if (htab->brlt != NULL
15039 && htab->brlt->reloc_count != 0
15040 && !_bfd_elf_link_output_relocs (output_bfd,
15042 elf_section_data (htab->brlt)->rela.hdr,
15043 elf_section_data (htab->brlt)->relocs,
15047 if (htab->glink != NULL
15048 && htab->glink->reloc_count != 0
15049 && !_bfd_elf_link_output_relocs (output_bfd,
15051 elf_section_data (htab->glink)->rela.hdr,
15052 elf_section_data (htab->glink)->relocs,
15057 if (htab->glink_eh_frame != NULL
15058 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15059 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15060 htab->glink_eh_frame,
15061 htab->glink_eh_frame->contents))
15064 /* We need to handle writing out multiple GOT sections ourselves,
15065 since we didn't add them to DYNOBJ. We know dynobj is the first
15067 while ((dynobj = dynobj->link.next) != NULL)
15071 if (!is_ppc64_elf (dynobj))
15074 s = ppc64_elf_tdata (dynobj)->got;
15077 && s->output_section != bfd_abs_section_ptr
15078 && !bfd_set_section_contents (output_bfd, s->output_section,
15079 s->contents, s->output_offset,
15082 s = ppc64_elf_tdata (dynobj)->relgot;
15085 && s->output_section != bfd_abs_section_ptr
15086 && !bfd_set_section_contents (output_bfd, s->output_section,
15087 s->contents, s->output_offset,
15095 #include "elf64-target.h"
15097 /* FreeBSD support */
15099 #undef TARGET_LITTLE_SYM
15100 #undef TARGET_LITTLE_NAME
15102 #undef TARGET_BIG_SYM
15103 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15104 #undef TARGET_BIG_NAME
15105 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15108 #define ELF_OSABI ELFOSABI_FREEBSD
15111 #define elf64_bed elf64_powerpc_fbsd_bed
15113 #include "elf64-target.h"