1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
60 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME "elf64-powerpcle"
62 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME "elf64-powerpc"
64 #define ELF_ARCH bfd_arch_powerpc
65 #define ELF_TARGET_ID PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE EM_PPC64
67 #define ELF_MAXPAGESIZE 0x10000
68 #define ELF_COMMONPAGESIZE 0x1000
69 #define elf_info_to_howto ppc64_elf_info_to_howto
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_default_execstack 0
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded ppc64_elf_action_discarded
115 #define elf_backend_relocate_section ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections ppc64_elf_special_sections
121 #define elf_backend_post_process_headers _bfd_elf_set_osabi
122 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
124 /* The name of the dynamic interpreter. This is put in the .interp
126 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
128 /* The size in bytes of an entry in the procedure linkage table. */
129 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
131 /* The initial size of the plt reserved for the dynamic linker. */
132 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
134 /* Offsets to some stack save slots. */
136 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
137 /* This one is dodgy. ABIv2 does not have a linker word, so use the
138 CR save slot. Used only by optimised __tls_get_addr call stub,
139 relying on __tls_get_addr_opt not saving CR.. */
140 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
142 /* TOC base pointers offset from start of TOC. */
143 #define TOC_BASE_OFF 0x8000
145 /* Offset of tp and dtp pointers from start of TLS block. */
146 #define TP_OFFSET 0x7000
147 #define DTP_OFFSET 0x8000
149 /* .plt call stub instructions. The normal stub is like this, but
150 sometimes the .plt entry crosses a 64k boundary and we need to
151 insert an addi to adjust r11. */
152 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
153 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
154 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
155 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
156 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
157 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
158 #define BCTR 0x4e800420 /* bctr */
160 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
161 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
162 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
164 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
165 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
166 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
167 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
168 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
169 #define BNECTR 0x4ca20420 /* bnectr+ */
170 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
172 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
173 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
174 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
176 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
178 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
179 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
181 /* glink call stub instructions. We enter with the index in R0. */
182 #define GLINK_CALL_STUB_SIZE (16*4)
186 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
187 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
189 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
190 /* ld %2,(0b-1b)(%11) */
191 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
192 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
198 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
199 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
200 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
201 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
202 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
205 #define NOP 0x60000000
207 /* Some other nops. */
208 #define CROR_151515 0x4def7b82
209 #define CROR_313131 0x4ffffb82
211 /* .glink entries for the first 32k functions are two instructions. */
212 #define LI_R0_0 0x38000000 /* li %r0,0 */
213 #define B_DOT 0x48000000 /* b . */
215 /* After that, we need two instructions to load the index, followed by
217 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
218 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
220 /* Instructions used by the save and restore reg functions. */
221 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
222 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
223 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
224 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
225 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
226 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
227 #define LI_R12_0 0x39800000 /* li %r12,0 */
228 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
229 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
230 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
231 #define BLR 0x4e800020 /* blr */
233 /* Since .opd is an array of descriptors and each entry will end up
234 with identical R_PPC64_RELATIVE relocs, there is really no need to
235 propagate .opd relocs; The dynamic linker should be taught to
236 relocate .opd without reloc entries. */
237 #ifndef NO_OPD_RELOCS
238 #define NO_OPD_RELOCS 0
241 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
243 /* Relocation HOWTO's. */
244 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
246 static reloc_howto_type ppc64_elf_howto_raw[] = {
247 /* This reloc does nothing. */
248 HOWTO (R_PPC64_NONE, /* type */
250 2, /* size (0 = byte, 1 = short, 2 = long) */
252 FALSE, /* pc_relative */
254 complain_overflow_dont, /* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_PPC64_NONE", /* name */
257 FALSE, /* partial_inplace */
260 FALSE), /* pcrel_offset */
262 /* A standard 32 bit relocation. */
263 HOWTO (R_PPC64_ADDR32, /* type */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
267 FALSE, /* pc_relative */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_PPC64_ADDR32", /* name */
272 FALSE, /* partial_inplace */
274 0xffffffff, /* dst_mask */
275 FALSE), /* pcrel_offset */
277 /* An absolute 26 bit branch; the lower two bits must be zero.
278 FIXME: we don't check that, we just clear them. */
279 HOWTO (R_PPC64_ADDR24, /* type */
281 2, /* size (0 = byte, 1 = short, 2 = long) */
283 FALSE, /* pc_relative */
285 complain_overflow_bitfield, /* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_PPC64_ADDR24", /* name */
288 FALSE, /* partial_inplace */
290 0x03fffffc, /* dst_mask */
291 FALSE), /* pcrel_offset */
293 /* A standard 16 bit relocation. */
294 HOWTO (R_PPC64_ADDR16, /* type */
296 1, /* size (0 = byte, 1 = short, 2 = long) */
298 FALSE, /* pc_relative */
300 complain_overflow_bitfield, /* complain_on_overflow */
301 bfd_elf_generic_reloc, /* special_function */
302 "R_PPC64_ADDR16", /* name */
303 FALSE, /* partial_inplace */
305 0xffff, /* dst_mask */
306 FALSE), /* pcrel_offset */
308 /* A 16 bit relocation without overflow. */
309 HOWTO (R_PPC64_ADDR16_LO, /* type */
311 1, /* size (0 = byte, 1 = short, 2 = long) */
313 FALSE, /* pc_relative */
315 complain_overflow_dont,/* complain_on_overflow */
316 bfd_elf_generic_reloc, /* special_function */
317 "R_PPC64_ADDR16_LO", /* name */
318 FALSE, /* partial_inplace */
320 0xffff, /* dst_mask */
321 FALSE), /* pcrel_offset */
323 /* Bits 16-31 of an address. */
324 HOWTO (R_PPC64_ADDR16_HI, /* type */
326 1, /* size (0 = byte, 1 = short, 2 = long) */
328 FALSE, /* pc_relative */
330 complain_overflow_signed, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* special_function */
332 "R_PPC64_ADDR16_HI", /* name */
333 FALSE, /* partial_inplace */
335 0xffff, /* dst_mask */
336 FALSE), /* pcrel_offset */
338 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
339 bits, treated as a signed number, is negative. */
340 HOWTO (R_PPC64_ADDR16_HA, /* type */
342 1, /* size (0 = byte, 1 = short, 2 = long) */
344 FALSE, /* pc_relative */
346 complain_overflow_signed, /* complain_on_overflow */
347 ppc64_elf_ha_reloc, /* special_function */
348 "R_PPC64_ADDR16_HA", /* name */
349 FALSE, /* partial_inplace */
351 0xffff, /* dst_mask */
352 FALSE), /* pcrel_offset */
354 /* An absolute 16 bit branch; the lower two bits must be zero.
355 FIXME: we don't check that, we just clear them. */
356 HOWTO (R_PPC64_ADDR14, /* type */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
360 FALSE, /* pc_relative */
362 complain_overflow_bitfield, /* complain_on_overflow */
363 ppc64_elf_branch_reloc, /* special_function */
364 "R_PPC64_ADDR14", /* name */
365 FALSE, /* partial_inplace */
367 0x0000fffc, /* dst_mask */
368 FALSE), /* pcrel_offset */
370 /* An absolute 16 bit branch, for which bit 10 should be set to
371 indicate that the branch is expected to be taken. The lower two
372 bits must be zero. */
373 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
377 FALSE, /* pc_relative */
379 complain_overflow_bitfield, /* complain_on_overflow */
380 ppc64_elf_brtaken_reloc, /* special_function */
381 "R_PPC64_ADDR14_BRTAKEN",/* name */
382 FALSE, /* partial_inplace */
384 0x0000fffc, /* dst_mask */
385 FALSE), /* pcrel_offset */
387 /* An absolute 16 bit branch, for which bit 10 should be set to
388 indicate that the branch is not expected to be taken. The lower
389 two bits must be zero. */
390 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
394 FALSE, /* pc_relative */
396 complain_overflow_bitfield, /* complain_on_overflow */
397 ppc64_elf_brtaken_reloc, /* special_function */
398 "R_PPC64_ADDR14_BRNTAKEN",/* name */
399 FALSE, /* partial_inplace */
401 0x0000fffc, /* dst_mask */
402 FALSE), /* pcrel_offset */
404 /* A relative 26 bit branch; the lower two bits must be zero. */
405 HOWTO (R_PPC64_REL24, /* type */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
409 TRUE, /* pc_relative */
411 complain_overflow_signed, /* complain_on_overflow */
412 ppc64_elf_branch_reloc, /* special_function */
413 "R_PPC64_REL24", /* name */
414 FALSE, /* partial_inplace */
416 0x03fffffc, /* dst_mask */
417 TRUE), /* pcrel_offset */
419 /* A relative 16 bit branch; the lower two bits must be zero. */
420 HOWTO (R_PPC64_REL14, /* type */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
424 TRUE, /* pc_relative */
426 complain_overflow_signed, /* complain_on_overflow */
427 ppc64_elf_branch_reloc, /* special_function */
428 "R_PPC64_REL14", /* name */
429 FALSE, /* partial_inplace */
431 0x0000fffc, /* dst_mask */
432 TRUE), /* pcrel_offset */
434 /* A relative 16 bit branch. Bit 10 should be set to indicate that
435 the branch is expected to be taken. The lower two bits must be
437 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
441 TRUE, /* pc_relative */
443 complain_overflow_signed, /* complain_on_overflow */
444 ppc64_elf_brtaken_reloc, /* special_function */
445 "R_PPC64_REL14_BRTAKEN", /* name */
446 FALSE, /* partial_inplace */
448 0x0000fffc, /* dst_mask */
449 TRUE), /* pcrel_offset */
451 /* A relative 16 bit branch. Bit 10 should be set to indicate that
452 the branch is not expected to be taken. The lower two bits must
454 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 TRUE, /* pc_relative */
460 complain_overflow_signed, /* complain_on_overflow */
461 ppc64_elf_brtaken_reloc, /* special_function */
462 "R_PPC64_REL14_BRNTAKEN",/* name */
463 FALSE, /* partial_inplace */
465 0x0000fffc, /* dst_mask */
466 TRUE), /* pcrel_offset */
468 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
470 HOWTO (R_PPC64_GOT16, /* type */
472 1, /* size (0 = byte, 1 = short, 2 = long) */
474 FALSE, /* pc_relative */
476 complain_overflow_signed, /* complain_on_overflow */
477 ppc64_elf_unhandled_reloc, /* special_function */
478 "R_PPC64_GOT16", /* name */
479 FALSE, /* partial_inplace */
481 0xffff, /* dst_mask */
482 FALSE), /* pcrel_offset */
484 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
486 HOWTO (R_PPC64_GOT16_LO, /* type */
488 1, /* size (0 = byte, 1 = short, 2 = long) */
490 FALSE, /* pc_relative */
492 complain_overflow_dont, /* complain_on_overflow */
493 ppc64_elf_unhandled_reloc, /* special_function */
494 "R_PPC64_GOT16_LO", /* name */
495 FALSE, /* partial_inplace */
497 0xffff, /* dst_mask */
498 FALSE), /* pcrel_offset */
500 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
502 HOWTO (R_PPC64_GOT16_HI, /* type */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
506 FALSE, /* pc_relative */
508 complain_overflow_signed,/* complain_on_overflow */
509 ppc64_elf_unhandled_reloc, /* special_function */
510 "R_PPC64_GOT16_HI", /* name */
511 FALSE, /* partial_inplace */
513 0xffff, /* dst_mask */
514 FALSE), /* pcrel_offset */
516 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
518 HOWTO (R_PPC64_GOT16_HA, /* type */
520 1, /* size (0 = byte, 1 = short, 2 = long) */
522 FALSE, /* pc_relative */
524 complain_overflow_signed,/* complain_on_overflow */
525 ppc64_elf_unhandled_reloc, /* special_function */
526 "R_PPC64_GOT16_HA", /* name */
527 FALSE, /* partial_inplace */
529 0xffff, /* dst_mask */
530 FALSE), /* pcrel_offset */
532 /* This is used only by the dynamic linker. The symbol should exist
533 both in the object being run and in some shared library. The
534 dynamic linker copies the data addressed by the symbol from the
535 shared library into the object, because the object being
536 run has to have the data at some particular address. */
537 HOWTO (R_PPC64_COPY, /* type */
539 0, /* this one is variable size */
541 FALSE, /* pc_relative */
543 complain_overflow_dont, /* complain_on_overflow */
544 ppc64_elf_unhandled_reloc, /* special_function */
545 "R_PPC64_COPY", /* name */
546 FALSE, /* partial_inplace */
549 FALSE), /* pcrel_offset */
551 /* Like R_PPC64_ADDR64, but used when setting global offset table
553 HOWTO (R_PPC64_GLOB_DAT, /* type */
555 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
557 FALSE, /* pc_relative */
559 complain_overflow_dont, /* complain_on_overflow */
560 ppc64_elf_unhandled_reloc, /* special_function */
561 "R_PPC64_GLOB_DAT", /* name */
562 FALSE, /* partial_inplace */
564 ONES (64), /* dst_mask */
565 FALSE), /* pcrel_offset */
567 /* Created by the link editor. Marks a procedure linkage table
568 entry for a symbol. */
569 HOWTO (R_PPC64_JMP_SLOT, /* type */
571 0, /* size (0 = byte, 1 = short, 2 = long) */
573 FALSE, /* pc_relative */
575 complain_overflow_dont, /* complain_on_overflow */
576 ppc64_elf_unhandled_reloc, /* special_function */
577 "R_PPC64_JMP_SLOT", /* name */
578 FALSE, /* partial_inplace */
581 FALSE), /* pcrel_offset */
583 /* Used only by the dynamic linker. When the object is run, this
584 doubleword64 is set to the load address of the object, plus the
586 HOWTO (R_PPC64_RELATIVE, /* type */
588 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
590 FALSE, /* pc_relative */
592 complain_overflow_dont, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_PPC64_RELATIVE", /* name */
595 FALSE, /* partial_inplace */
597 ONES (64), /* dst_mask */
598 FALSE), /* pcrel_offset */
600 /* Like R_PPC64_ADDR32, but may be unaligned. */
601 HOWTO (R_PPC64_UADDR32, /* type */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
605 FALSE, /* pc_relative */
607 complain_overflow_bitfield, /* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_PPC64_UADDR32", /* name */
610 FALSE, /* partial_inplace */
612 0xffffffff, /* dst_mask */
613 FALSE), /* pcrel_offset */
615 /* Like R_PPC64_ADDR16, but may be unaligned. */
616 HOWTO (R_PPC64_UADDR16, /* type */
618 1, /* size (0 = byte, 1 = short, 2 = long) */
620 FALSE, /* pc_relative */
622 complain_overflow_bitfield, /* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_PPC64_UADDR16", /* name */
625 FALSE, /* partial_inplace */
627 0xffff, /* dst_mask */
628 FALSE), /* pcrel_offset */
630 /* 32-bit PC relative. */
631 HOWTO (R_PPC64_REL32, /* type */
633 2, /* size (0 = byte, 1 = short, 2 = long) */
635 TRUE, /* pc_relative */
637 /* FIXME: Verify. Was complain_overflow_bitfield. */
638 complain_overflow_signed, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_PPC64_REL32", /* name */
641 FALSE, /* partial_inplace */
643 0xffffffff, /* dst_mask */
644 TRUE), /* pcrel_offset */
646 /* 32-bit relocation to the symbol's procedure linkage table. */
647 HOWTO (R_PPC64_PLT32, /* type */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
651 FALSE, /* pc_relative */
653 complain_overflow_bitfield, /* complain_on_overflow */
654 ppc64_elf_unhandled_reloc, /* special_function */
655 "R_PPC64_PLT32", /* name */
656 FALSE, /* partial_inplace */
658 0xffffffff, /* dst_mask */
659 FALSE), /* pcrel_offset */
661 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
662 FIXME: R_PPC64_PLTREL32 not supported. */
663 HOWTO (R_PPC64_PLTREL32, /* type */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
667 TRUE, /* pc_relative */
669 complain_overflow_signed, /* complain_on_overflow */
670 bfd_elf_generic_reloc, /* special_function */
671 "R_PPC64_PLTREL32", /* name */
672 FALSE, /* partial_inplace */
674 0xffffffff, /* dst_mask */
675 TRUE), /* pcrel_offset */
677 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
679 HOWTO (R_PPC64_PLT16_LO, /* type */
681 1, /* size (0 = byte, 1 = short, 2 = long) */
683 FALSE, /* pc_relative */
685 complain_overflow_dont, /* complain_on_overflow */
686 ppc64_elf_unhandled_reloc, /* special_function */
687 "R_PPC64_PLT16_LO", /* name */
688 FALSE, /* partial_inplace */
690 0xffff, /* dst_mask */
691 FALSE), /* pcrel_offset */
693 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
695 HOWTO (R_PPC64_PLT16_HI, /* type */
697 1, /* size (0 = byte, 1 = short, 2 = long) */
699 FALSE, /* pc_relative */
701 complain_overflow_signed, /* complain_on_overflow */
702 ppc64_elf_unhandled_reloc, /* special_function */
703 "R_PPC64_PLT16_HI", /* name */
704 FALSE, /* partial_inplace */
706 0xffff, /* dst_mask */
707 FALSE), /* pcrel_offset */
709 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
711 HOWTO (R_PPC64_PLT16_HA, /* type */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
715 FALSE, /* pc_relative */
717 complain_overflow_signed, /* complain_on_overflow */
718 ppc64_elf_unhandled_reloc, /* special_function */
719 "R_PPC64_PLT16_HA", /* name */
720 FALSE, /* partial_inplace */
722 0xffff, /* dst_mask */
723 FALSE), /* pcrel_offset */
725 /* 16-bit section relative relocation. */
726 HOWTO (R_PPC64_SECTOFF, /* type */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
730 FALSE, /* pc_relative */
732 complain_overflow_bitfield, /* complain_on_overflow */
733 ppc64_elf_sectoff_reloc, /* special_function */
734 "R_PPC64_SECTOFF", /* name */
735 FALSE, /* partial_inplace */
737 0xffff, /* dst_mask */
738 FALSE), /* pcrel_offset */
740 /* Like R_PPC64_SECTOFF, but no overflow warning. */
741 HOWTO (R_PPC64_SECTOFF_LO, /* type */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
745 FALSE, /* pc_relative */
747 complain_overflow_dont, /* complain_on_overflow */
748 ppc64_elf_sectoff_reloc, /* special_function */
749 "R_PPC64_SECTOFF_LO", /* name */
750 FALSE, /* partial_inplace */
752 0xffff, /* dst_mask */
753 FALSE), /* pcrel_offset */
755 /* 16-bit upper half section relative relocation. */
756 HOWTO (R_PPC64_SECTOFF_HI, /* type */
758 1, /* size (0 = byte, 1 = short, 2 = long) */
760 FALSE, /* pc_relative */
762 complain_overflow_signed, /* complain_on_overflow */
763 ppc64_elf_sectoff_reloc, /* special_function */
764 "R_PPC64_SECTOFF_HI", /* name */
765 FALSE, /* partial_inplace */
767 0xffff, /* dst_mask */
768 FALSE), /* pcrel_offset */
770 /* 16-bit upper half adjusted section relative relocation. */
771 HOWTO (R_PPC64_SECTOFF_HA, /* type */
773 1, /* size (0 = byte, 1 = short, 2 = long) */
775 FALSE, /* pc_relative */
777 complain_overflow_signed, /* complain_on_overflow */
778 ppc64_elf_sectoff_ha_reloc, /* special_function */
779 "R_PPC64_SECTOFF_HA", /* name */
780 FALSE, /* partial_inplace */
782 0xffff, /* dst_mask */
783 FALSE), /* pcrel_offset */
785 /* Like R_PPC64_REL24 without touching the two least significant bits. */
786 HOWTO (R_PPC64_REL30, /* type */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
790 TRUE, /* pc_relative */
792 complain_overflow_dont, /* complain_on_overflow */
793 bfd_elf_generic_reloc, /* special_function */
794 "R_PPC64_REL30", /* name */
795 FALSE, /* partial_inplace */
797 0xfffffffc, /* dst_mask */
798 TRUE), /* pcrel_offset */
800 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
802 /* A standard 64-bit relocation. */
803 HOWTO (R_PPC64_ADDR64, /* type */
805 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
807 FALSE, /* pc_relative */
809 complain_overflow_dont, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* special_function */
811 "R_PPC64_ADDR64", /* name */
812 FALSE, /* partial_inplace */
814 ONES (64), /* dst_mask */
815 FALSE), /* pcrel_offset */
817 /* The bits 32-47 of an address. */
818 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
820 1, /* size (0 = byte, 1 = short, 2 = long) */
822 FALSE, /* pc_relative */
824 complain_overflow_dont, /* complain_on_overflow */
825 bfd_elf_generic_reloc, /* special_function */
826 "R_PPC64_ADDR16_HIGHER", /* name */
827 FALSE, /* partial_inplace */
829 0xffff, /* dst_mask */
830 FALSE), /* pcrel_offset */
832 /* The bits 32-47 of an address, plus 1 if the contents of the low
833 16 bits, treated as a signed number, is negative. */
834 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
836 1, /* size (0 = byte, 1 = short, 2 = long) */
838 FALSE, /* pc_relative */
840 complain_overflow_dont, /* complain_on_overflow */
841 ppc64_elf_ha_reloc, /* special_function */
842 "R_PPC64_ADDR16_HIGHERA", /* name */
843 FALSE, /* partial_inplace */
845 0xffff, /* dst_mask */
846 FALSE), /* pcrel_offset */
848 /* The bits 48-63 of an address. */
849 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
851 1, /* size (0 = byte, 1 = short, 2 = long) */
853 FALSE, /* pc_relative */
855 complain_overflow_dont, /* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_PPC64_ADDR16_HIGHEST", /* name */
858 FALSE, /* partial_inplace */
860 0xffff, /* dst_mask */
861 FALSE), /* pcrel_offset */
863 /* The bits 48-63 of an address, plus 1 if the contents of the low
864 16 bits, treated as a signed number, is negative. */
865 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
869 FALSE, /* pc_relative */
871 complain_overflow_dont, /* complain_on_overflow */
872 ppc64_elf_ha_reloc, /* special_function */
873 "R_PPC64_ADDR16_HIGHESTA", /* name */
874 FALSE, /* partial_inplace */
876 0xffff, /* dst_mask */
877 FALSE), /* pcrel_offset */
879 /* Like ADDR64, but may be unaligned. */
880 HOWTO (R_PPC64_UADDR64, /* type */
882 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
884 FALSE, /* pc_relative */
886 complain_overflow_dont, /* complain_on_overflow */
887 bfd_elf_generic_reloc, /* special_function */
888 "R_PPC64_UADDR64", /* name */
889 FALSE, /* partial_inplace */
891 ONES (64), /* dst_mask */
892 FALSE), /* pcrel_offset */
894 /* 64-bit relative relocation. */
895 HOWTO (R_PPC64_REL64, /* type */
897 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
899 TRUE, /* pc_relative */
901 complain_overflow_dont, /* complain_on_overflow */
902 bfd_elf_generic_reloc, /* special_function */
903 "R_PPC64_REL64", /* name */
904 FALSE, /* partial_inplace */
906 ONES (64), /* dst_mask */
907 TRUE), /* pcrel_offset */
909 /* 64-bit relocation to the symbol's procedure linkage table. */
910 HOWTO (R_PPC64_PLT64, /* type */
912 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
914 FALSE, /* pc_relative */
916 complain_overflow_dont, /* complain_on_overflow */
917 ppc64_elf_unhandled_reloc, /* special_function */
918 "R_PPC64_PLT64", /* name */
919 FALSE, /* partial_inplace */
921 ONES (64), /* dst_mask */
922 FALSE), /* pcrel_offset */
924 /* 64-bit PC relative relocation to the symbol's procedure linkage
926 /* FIXME: R_PPC64_PLTREL64 not supported. */
927 HOWTO (R_PPC64_PLTREL64, /* type */
929 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
931 TRUE, /* pc_relative */
933 complain_overflow_dont, /* complain_on_overflow */
934 ppc64_elf_unhandled_reloc, /* special_function */
935 "R_PPC64_PLTREL64", /* name */
936 FALSE, /* partial_inplace */
938 ONES (64), /* dst_mask */
939 TRUE), /* pcrel_offset */
941 /* 16 bit TOC-relative relocation. */
943 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
944 HOWTO (R_PPC64_TOC16, /* type */
946 1, /* size (0 = byte, 1 = short, 2 = long) */
948 FALSE, /* pc_relative */
950 complain_overflow_signed, /* complain_on_overflow */
951 ppc64_elf_toc_reloc, /* special_function */
952 "R_PPC64_TOC16", /* name */
953 FALSE, /* partial_inplace */
955 0xffff, /* dst_mask */
956 FALSE), /* pcrel_offset */
958 /* 16 bit TOC-relative relocation without overflow. */
960 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
961 HOWTO (R_PPC64_TOC16_LO, /* type */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
965 FALSE, /* pc_relative */
967 complain_overflow_dont, /* complain_on_overflow */
968 ppc64_elf_toc_reloc, /* special_function */
969 "R_PPC64_TOC16_LO", /* name */
970 FALSE, /* partial_inplace */
972 0xffff, /* dst_mask */
973 FALSE), /* pcrel_offset */
975 /* 16 bit TOC-relative relocation, high 16 bits. */
977 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
978 HOWTO (R_PPC64_TOC16_HI, /* type */
980 1, /* size (0 = byte, 1 = short, 2 = long) */
982 FALSE, /* pc_relative */
984 complain_overflow_signed, /* complain_on_overflow */
985 ppc64_elf_toc_reloc, /* special_function */
986 "R_PPC64_TOC16_HI", /* name */
987 FALSE, /* partial_inplace */
989 0xffff, /* dst_mask */
990 FALSE), /* pcrel_offset */
992 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
993 contents of the low 16 bits, treated as a signed number, is
996 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
997 HOWTO (R_PPC64_TOC16_HA, /* type */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 FALSE, /* pc_relative */
1003 complain_overflow_signed, /* complain_on_overflow */
1004 ppc64_elf_toc_ha_reloc, /* special_function */
1005 "R_PPC64_TOC16_HA", /* name */
1006 FALSE, /* partial_inplace */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1011 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1013 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1014 HOWTO (R_PPC64_TOC, /* type */
1016 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1018 FALSE, /* pc_relative */
1020 complain_overflow_bitfield, /* complain_on_overflow */
1021 ppc64_elf_toc64_reloc, /* special_function */
1022 "R_PPC64_TOC", /* name */
1023 FALSE, /* partial_inplace */
1025 ONES (64), /* dst_mask */
1026 FALSE), /* pcrel_offset */
1028 /* Like R_PPC64_GOT16, but also informs the link editor that the
1029 value to relocate may (!) refer to a PLT entry which the link
1030 editor (a) may replace with the symbol value. If the link editor
1031 is unable to fully resolve the symbol, it may (b) create a PLT
1032 entry and store the address to the new PLT entry in the GOT.
1033 This permits lazy resolution of function symbols at run time.
1034 The link editor may also skip all of this and just (c) emit a
1035 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1036 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1037 HOWTO (R_PPC64_PLTGOT16, /* type */
1039 1, /* size (0 = byte, 1 = short, 2 = long) */
1041 FALSE, /* pc_relative */
1043 complain_overflow_signed, /* complain_on_overflow */
1044 ppc64_elf_unhandled_reloc, /* special_function */
1045 "R_PPC64_PLTGOT16", /* name */
1046 FALSE, /* partial_inplace */
1048 0xffff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1051 /* Like R_PPC64_PLTGOT16, but without overflow. */
1052 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1053 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1055 1, /* size (0 = byte, 1 = short, 2 = long) */
1057 FALSE, /* pc_relative */
1059 complain_overflow_dont, /* complain_on_overflow */
1060 ppc64_elf_unhandled_reloc, /* special_function */
1061 "R_PPC64_PLTGOT16_LO", /* name */
1062 FALSE, /* partial_inplace */
1064 0xffff, /* dst_mask */
1065 FALSE), /* pcrel_offset */
1067 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1068 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1069 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1070 16, /* rightshift */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1073 FALSE, /* pc_relative */
1075 complain_overflow_signed, /* complain_on_overflow */
1076 ppc64_elf_unhandled_reloc, /* special_function */
1077 "R_PPC64_PLTGOT16_HI", /* name */
1078 FALSE, /* partial_inplace */
1080 0xffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1083 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1084 1 if the contents of the low 16 bits, treated as a signed number,
1086 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1087 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1088 16, /* rightshift */
1089 1, /* size (0 = byte, 1 = short, 2 = long) */
1091 FALSE, /* pc_relative */
1093 complain_overflow_signed, /* complain_on_overflow */
1094 ppc64_elf_unhandled_reloc, /* special_function */
1095 "R_PPC64_PLTGOT16_HA", /* name */
1096 FALSE, /* partial_inplace */
1098 0xffff, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1101 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1102 HOWTO (R_PPC64_ADDR16_DS, /* type */
1104 1, /* size (0 = byte, 1 = short, 2 = long) */
1106 FALSE, /* pc_relative */
1108 complain_overflow_bitfield, /* complain_on_overflow */
1109 bfd_elf_generic_reloc, /* special_function */
1110 "R_PPC64_ADDR16_DS", /* name */
1111 FALSE, /* partial_inplace */
1113 0xfffc, /* dst_mask */
1114 FALSE), /* pcrel_offset */
1116 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1117 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1119 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 FALSE, /* pc_relative */
1123 complain_overflow_dont,/* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_PPC64_ADDR16_LO_DS",/* name */
1126 FALSE, /* partial_inplace */
1128 0xfffc, /* dst_mask */
1129 FALSE), /* pcrel_offset */
1131 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1132 HOWTO (R_PPC64_GOT16_DS, /* type */
1134 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 FALSE, /* pc_relative */
1138 complain_overflow_signed, /* complain_on_overflow */
1139 ppc64_elf_unhandled_reloc, /* special_function */
1140 "R_PPC64_GOT16_DS", /* name */
1141 FALSE, /* partial_inplace */
1143 0xfffc, /* dst_mask */
1144 FALSE), /* pcrel_offset */
1146 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1147 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1149 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 FALSE, /* pc_relative */
1153 complain_overflow_dont, /* complain_on_overflow */
1154 ppc64_elf_unhandled_reloc, /* special_function */
1155 "R_PPC64_GOT16_LO_DS", /* name */
1156 FALSE, /* partial_inplace */
1158 0xfffc, /* dst_mask */
1159 FALSE), /* pcrel_offset */
1161 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1162 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1164 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 FALSE, /* pc_relative */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 ppc64_elf_unhandled_reloc, /* special_function */
1170 "R_PPC64_PLT16_LO_DS", /* name */
1171 FALSE, /* partial_inplace */
1173 0xfffc, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1176 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1177 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1179 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 FALSE, /* pc_relative */
1183 complain_overflow_bitfield, /* complain_on_overflow */
1184 ppc64_elf_sectoff_reloc, /* special_function */
1185 "R_PPC64_SECTOFF_DS", /* name */
1186 FALSE, /* partial_inplace */
1188 0xfffc, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1191 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1192 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1194 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 FALSE, /* pc_relative */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 ppc64_elf_sectoff_reloc, /* special_function */
1200 "R_PPC64_SECTOFF_LO_DS",/* name */
1201 FALSE, /* partial_inplace */
1203 0xfffc, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1206 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1207 HOWTO (R_PPC64_TOC16_DS, /* type */
1209 1, /* size (0 = byte, 1 = short, 2 = long) */
1211 FALSE, /* pc_relative */
1213 complain_overflow_signed, /* complain_on_overflow */
1214 ppc64_elf_toc_reloc, /* special_function */
1215 "R_PPC64_TOC16_DS", /* name */
1216 FALSE, /* partial_inplace */
1218 0xfffc, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1221 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1222 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1224 1, /* size (0 = byte, 1 = short, 2 = long) */
1226 FALSE, /* pc_relative */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 ppc64_elf_toc_reloc, /* special_function */
1230 "R_PPC64_TOC16_LO_DS", /* name */
1231 FALSE, /* partial_inplace */
1233 0xfffc, /* dst_mask */
1234 FALSE), /* pcrel_offset */
1236 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1237 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1238 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1240 1, /* size (0 = byte, 1 = short, 2 = long) */
1242 FALSE, /* pc_relative */
1244 complain_overflow_signed, /* complain_on_overflow */
1245 ppc64_elf_unhandled_reloc, /* special_function */
1246 "R_PPC64_PLTGOT16_DS", /* name */
1247 FALSE, /* partial_inplace */
1249 0xfffc, /* dst_mask */
1250 FALSE), /* pcrel_offset */
1252 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1253 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1254 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1256 1, /* size (0 = byte, 1 = short, 2 = long) */
1258 FALSE, /* pc_relative */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 ppc64_elf_unhandled_reloc, /* special_function */
1262 "R_PPC64_PLTGOT16_LO_DS",/* name */
1263 FALSE, /* partial_inplace */
1265 0xfffc, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1268 /* Marker relocs for TLS. */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1273 FALSE, /* pc_relative */
1275 complain_overflow_dont, /* complain_on_overflow */
1276 bfd_elf_generic_reloc, /* special_function */
1277 "R_PPC64_TLS", /* name */
1278 FALSE, /* partial_inplace */
1281 FALSE), /* pcrel_offset */
1283 HOWTO (R_PPC64_TLSGD,
1285 2, /* size (0 = byte, 1 = short, 2 = long) */
1287 FALSE, /* pc_relative */
1289 complain_overflow_dont, /* complain_on_overflow */
1290 bfd_elf_generic_reloc, /* special_function */
1291 "R_PPC64_TLSGD", /* name */
1292 FALSE, /* partial_inplace */
1295 FALSE), /* pcrel_offset */
1297 HOWTO (R_PPC64_TLSLD,
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1301 FALSE, /* pc_relative */
1303 complain_overflow_dont, /* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_PPC64_TLSLD", /* name */
1306 FALSE, /* partial_inplace */
1309 FALSE), /* pcrel_offset */
1311 HOWTO (R_PPC64_TOCSAVE,
1313 2, /* size (0 = byte, 1 = short, 2 = long) */
1315 FALSE, /* pc_relative */
1317 complain_overflow_dont, /* complain_on_overflow */
1318 bfd_elf_generic_reloc, /* special_function */
1319 "R_PPC64_TOCSAVE", /* name */
1320 FALSE, /* partial_inplace */
1323 FALSE), /* pcrel_offset */
1325 /* Computes the load module index of the load module that contains the
1326 definition of its TLS sym. */
1327 HOWTO (R_PPC64_DTPMOD64,
1329 4, /* size (0 = byte, 1 = short, 2 = long) */
1331 FALSE, /* pc_relative */
1333 complain_overflow_dont, /* complain_on_overflow */
1334 ppc64_elf_unhandled_reloc, /* special_function */
1335 "R_PPC64_DTPMOD64", /* name */
1336 FALSE, /* partial_inplace */
1338 ONES (64), /* dst_mask */
1339 FALSE), /* pcrel_offset */
1341 /* Computes a dtv-relative displacement, the difference between the value
1342 of sym+add and the base address of the thread-local storage block that
1343 contains the definition of sym, minus 0x8000. */
1344 HOWTO (R_PPC64_DTPREL64,
1346 4, /* size (0 = byte, 1 = short, 2 = long) */
1348 FALSE, /* pc_relative */
1350 complain_overflow_dont, /* complain_on_overflow */
1351 ppc64_elf_unhandled_reloc, /* special_function */
1352 "R_PPC64_DTPREL64", /* name */
1353 FALSE, /* partial_inplace */
1355 ONES (64), /* dst_mask */
1356 FALSE), /* pcrel_offset */
1358 /* A 16 bit dtprel reloc. */
1359 HOWTO (R_PPC64_DTPREL16,
1361 1, /* size (0 = byte, 1 = short, 2 = long) */
1363 FALSE, /* pc_relative */
1365 complain_overflow_signed, /* complain_on_overflow */
1366 ppc64_elf_unhandled_reloc, /* special_function */
1367 "R_PPC64_DTPREL16", /* name */
1368 FALSE, /* partial_inplace */
1370 0xffff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1373 /* Like DTPREL16, but no overflow. */
1374 HOWTO (R_PPC64_DTPREL16_LO,
1376 1, /* size (0 = byte, 1 = short, 2 = long) */
1378 FALSE, /* pc_relative */
1380 complain_overflow_dont, /* complain_on_overflow */
1381 ppc64_elf_unhandled_reloc, /* special_function */
1382 "R_PPC64_DTPREL16_LO", /* name */
1383 FALSE, /* partial_inplace */
1385 0xffff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1388 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1389 HOWTO (R_PPC64_DTPREL16_HI,
1390 16, /* rightshift */
1391 1, /* size (0 = byte, 1 = short, 2 = long) */
1393 FALSE, /* pc_relative */
1395 complain_overflow_signed, /* complain_on_overflow */
1396 ppc64_elf_unhandled_reloc, /* special_function */
1397 "R_PPC64_DTPREL16_HI", /* name */
1398 FALSE, /* partial_inplace */
1400 0xffff, /* dst_mask */
1401 FALSE), /* pcrel_offset */
1403 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1404 HOWTO (R_PPC64_DTPREL16_HA,
1405 16, /* rightshift */
1406 1, /* size (0 = byte, 1 = short, 2 = long) */
1408 FALSE, /* pc_relative */
1410 complain_overflow_signed, /* complain_on_overflow */
1411 ppc64_elf_unhandled_reloc, /* special_function */
1412 "R_PPC64_DTPREL16_HA", /* name */
1413 FALSE, /* partial_inplace */
1415 0xffff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1418 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1419 HOWTO (R_PPC64_DTPREL16_HIGHER,
1420 32, /* rightshift */
1421 1, /* size (0 = byte, 1 = short, 2 = long) */
1423 FALSE, /* pc_relative */
1425 complain_overflow_dont, /* complain_on_overflow */
1426 ppc64_elf_unhandled_reloc, /* special_function */
1427 "R_PPC64_DTPREL16_HIGHER", /* name */
1428 FALSE, /* partial_inplace */
1430 0xffff, /* dst_mask */
1431 FALSE), /* pcrel_offset */
1433 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1434 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1435 32, /* rightshift */
1436 1, /* size (0 = byte, 1 = short, 2 = long) */
1438 FALSE, /* pc_relative */
1440 complain_overflow_dont, /* complain_on_overflow */
1441 ppc64_elf_unhandled_reloc, /* special_function */
1442 "R_PPC64_DTPREL16_HIGHERA", /* name */
1443 FALSE, /* partial_inplace */
1445 0xffff, /* dst_mask */
1446 FALSE), /* pcrel_offset */
1448 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1449 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1450 48, /* rightshift */
1451 1, /* size (0 = byte, 1 = short, 2 = long) */
1453 FALSE, /* pc_relative */
1455 complain_overflow_dont, /* complain_on_overflow */
1456 ppc64_elf_unhandled_reloc, /* special_function */
1457 "R_PPC64_DTPREL16_HIGHEST", /* name */
1458 FALSE, /* partial_inplace */
1460 0xffff, /* dst_mask */
1461 FALSE), /* pcrel_offset */
1463 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1464 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1465 48, /* rightshift */
1466 1, /* size (0 = byte, 1 = short, 2 = long) */
1468 FALSE, /* pc_relative */
1470 complain_overflow_dont, /* complain_on_overflow */
1471 ppc64_elf_unhandled_reloc, /* special_function */
1472 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1473 FALSE, /* partial_inplace */
1475 0xffff, /* dst_mask */
1476 FALSE), /* pcrel_offset */
1478 /* Like DTPREL16, but for insns with a DS field. */
1479 HOWTO (R_PPC64_DTPREL16_DS,
1481 1, /* size (0 = byte, 1 = short, 2 = long) */
1483 FALSE, /* pc_relative */
1485 complain_overflow_signed, /* complain_on_overflow */
1486 ppc64_elf_unhandled_reloc, /* special_function */
1487 "R_PPC64_DTPREL16_DS", /* name */
1488 FALSE, /* partial_inplace */
1490 0xfffc, /* dst_mask */
1491 FALSE), /* pcrel_offset */
1493 /* Like DTPREL16_DS, but no overflow. */
1494 HOWTO (R_PPC64_DTPREL16_LO_DS,
1496 1, /* size (0 = byte, 1 = short, 2 = long) */
1498 FALSE, /* pc_relative */
1500 complain_overflow_dont, /* complain_on_overflow */
1501 ppc64_elf_unhandled_reloc, /* special_function */
1502 "R_PPC64_DTPREL16_LO_DS", /* name */
1503 FALSE, /* partial_inplace */
1505 0xfffc, /* dst_mask */
1506 FALSE), /* pcrel_offset */
1508 /* Computes a tp-relative displacement, the difference between the value of
1509 sym+add and the value of the thread pointer (r13). */
1510 HOWTO (R_PPC64_TPREL64,
1512 4, /* size (0 = byte, 1 = short, 2 = long) */
1514 FALSE, /* pc_relative */
1516 complain_overflow_dont, /* complain_on_overflow */
1517 ppc64_elf_unhandled_reloc, /* special_function */
1518 "R_PPC64_TPREL64", /* name */
1519 FALSE, /* partial_inplace */
1521 ONES (64), /* dst_mask */
1522 FALSE), /* pcrel_offset */
1524 /* A 16 bit tprel reloc. */
1525 HOWTO (R_PPC64_TPREL16,
1527 1, /* size (0 = byte, 1 = short, 2 = long) */
1529 FALSE, /* pc_relative */
1531 complain_overflow_signed, /* complain_on_overflow */
1532 ppc64_elf_unhandled_reloc, /* special_function */
1533 "R_PPC64_TPREL16", /* name */
1534 FALSE, /* partial_inplace */
1536 0xffff, /* dst_mask */
1537 FALSE), /* pcrel_offset */
1539 /* Like TPREL16, but no overflow. */
1540 HOWTO (R_PPC64_TPREL16_LO,
1542 1, /* size (0 = byte, 1 = short, 2 = long) */
1544 FALSE, /* pc_relative */
1546 complain_overflow_dont, /* complain_on_overflow */
1547 ppc64_elf_unhandled_reloc, /* special_function */
1548 "R_PPC64_TPREL16_LO", /* name */
1549 FALSE, /* partial_inplace */
1551 0xffff, /* dst_mask */
1552 FALSE), /* pcrel_offset */
1554 /* Like TPREL16_LO, but next higher group of 16 bits. */
1555 HOWTO (R_PPC64_TPREL16_HI,
1556 16, /* rightshift */
1557 1, /* size (0 = byte, 1 = short, 2 = long) */
1559 FALSE, /* pc_relative */
1561 complain_overflow_signed, /* complain_on_overflow */
1562 ppc64_elf_unhandled_reloc, /* special_function */
1563 "R_PPC64_TPREL16_HI", /* name */
1564 FALSE, /* partial_inplace */
1566 0xffff, /* dst_mask */
1567 FALSE), /* pcrel_offset */
1569 /* Like TPREL16_HI, but adjust for low 16 bits. */
1570 HOWTO (R_PPC64_TPREL16_HA,
1571 16, /* rightshift */
1572 1, /* size (0 = byte, 1 = short, 2 = long) */
1574 FALSE, /* pc_relative */
1576 complain_overflow_signed, /* complain_on_overflow */
1577 ppc64_elf_unhandled_reloc, /* special_function */
1578 "R_PPC64_TPREL16_HA", /* name */
1579 FALSE, /* partial_inplace */
1581 0xffff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1584 /* Like TPREL16_HI, but next higher group of 16 bits. */
1585 HOWTO (R_PPC64_TPREL16_HIGHER,
1586 32, /* rightshift */
1587 1, /* size (0 = byte, 1 = short, 2 = long) */
1589 FALSE, /* pc_relative */
1591 complain_overflow_dont, /* complain_on_overflow */
1592 ppc64_elf_unhandled_reloc, /* special_function */
1593 "R_PPC64_TPREL16_HIGHER", /* name */
1594 FALSE, /* partial_inplace */
1596 0xffff, /* dst_mask */
1597 FALSE), /* pcrel_offset */
1599 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1600 HOWTO (R_PPC64_TPREL16_HIGHERA,
1601 32, /* rightshift */
1602 1, /* size (0 = byte, 1 = short, 2 = long) */
1604 FALSE, /* pc_relative */
1606 complain_overflow_dont, /* complain_on_overflow */
1607 ppc64_elf_unhandled_reloc, /* special_function */
1608 "R_PPC64_TPREL16_HIGHERA", /* name */
1609 FALSE, /* partial_inplace */
1611 0xffff, /* dst_mask */
1612 FALSE), /* pcrel_offset */
1614 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1615 HOWTO (R_PPC64_TPREL16_HIGHEST,
1616 48, /* rightshift */
1617 1, /* size (0 = byte, 1 = short, 2 = long) */
1619 FALSE, /* pc_relative */
1621 complain_overflow_dont, /* complain_on_overflow */
1622 ppc64_elf_unhandled_reloc, /* special_function */
1623 "R_PPC64_TPREL16_HIGHEST", /* name */
1624 FALSE, /* partial_inplace */
1626 0xffff, /* dst_mask */
1627 FALSE), /* pcrel_offset */
1629 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1630 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1631 48, /* rightshift */
1632 1, /* size (0 = byte, 1 = short, 2 = long) */
1634 FALSE, /* pc_relative */
1636 complain_overflow_dont, /* complain_on_overflow */
1637 ppc64_elf_unhandled_reloc, /* special_function */
1638 "R_PPC64_TPREL16_HIGHESTA", /* name */
1639 FALSE, /* partial_inplace */
1641 0xffff, /* dst_mask */
1642 FALSE), /* pcrel_offset */
1644 /* Like TPREL16, but for insns with a DS field. */
1645 HOWTO (R_PPC64_TPREL16_DS,
1647 1, /* size (0 = byte, 1 = short, 2 = long) */
1649 FALSE, /* pc_relative */
1651 complain_overflow_signed, /* complain_on_overflow */
1652 ppc64_elf_unhandled_reloc, /* special_function */
1653 "R_PPC64_TPREL16_DS", /* name */
1654 FALSE, /* partial_inplace */
1656 0xfffc, /* dst_mask */
1657 FALSE), /* pcrel_offset */
1659 /* Like TPREL16_DS, but no overflow. */
1660 HOWTO (R_PPC64_TPREL16_LO_DS,
1662 1, /* size (0 = byte, 1 = short, 2 = long) */
1664 FALSE, /* pc_relative */
1666 complain_overflow_dont, /* complain_on_overflow */
1667 ppc64_elf_unhandled_reloc, /* special_function */
1668 "R_PPC64_TPREL16_LO_DS", /* name */
1669 FALSE, /* partial_inplace */
1671 0xfffc, /* dst_mask */
1672 FALSE), /* pcrel_offset */
1674 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1675 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1676 to the first entry relative to the TOC base (r2). */
1677 HOWTO (R_PPC64_GOT_TLSGD16,
1679 1, /* size (0 = byte, 1 = short, 2 = long) */
1681 FALSE, /* pc_relative */
1683 complain_overflow_signed, /* complain_on_overflow */
1684 ppc64_elf_unhandled_reloc, /* special_function */
1685 "R_PPC64_GOT_TLSGD16", /* name */
1686 FALSE, /* partial_inplace */
1688 0xffff, /* dst_mask */
1689 FALSE), /* pcrel_offset */
1691 /* Like GOT_TLSGD16, but no overflow. */
1692 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1694 1, /* size (0 = byte, 1 = short, 2 = long) */
1696 FALSE, /* pc_relative */
1698 complain_overflow_dont, /* complain_on_overflow */
1699 ppc64_elf_unhandled_reloc, /* special_function */
1700 "R_PPC64_GOT_TLSGD16_LO", /* name */
1701 FALSE, /* partial_inplace */
1703 0xffff, /* dst_mask */
1704 FALSE), /* pcrel_offset */
1706 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1707 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1708 16, /* rightshift */
1709 1, /* size (0 = byte, 1 = short, 2 = long) */
1711 FALSE, /* pc_relative */
1713 complain_overflow_signed, /* complain_on_overflow */
1714 ppc64_elf_unhandled_reloc, /* special_function */
1715 "R_PPC64_GOT_TLSGD16_HI", /* name */
1716 FALSE, /* partial_inplace */
1718 0xffff, /* dst_mask */
1719 FALSE), /* pcrel_offset */
1721 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1722 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1723 16, /* rightshift */
1724 1, /* size (0 = byte, 1 = short, 2 = long) */
1726 FALSE, /* pc_relative */
1728 complain_overflow_signed, /* complain_on_overflow */
1729 ppc64_elf_unhandled_reloc, /* special_function */
1730 "R_PPC64_GOT_TLSGD16_HA", /* name */
1731 FALSE, /* partial_inplace */
1733 0xffff, /* dst_mask */
1734 FALSE), /* pcrel_offset */
1736 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1737 with values (sym+add)@dtpmod and zero, and computes the offset to the
1738 first entry relative to the TOC base (r2). */
1739 HOWTO (R_PPC64_GOT_TLSLD16,
1741 1, /* size (0 = byte, 1 = short, 2 = long) */
1743 FALSE, /* pc_relative */
1745 complain_overflow_signed, /* complain_on_overflow */
1746 ppc64_elf_unhandled_reloc, /* special_function */
1747 "R_PPC64_GOT_TLSLD16", /* name */
1748 FALSE, /* partial_inplace */
1750 0xffff, /* dst_mask */
1751 FALSE), /* pcrel_offset */
1753 /* Like GOT_TLSLD16, but no overflow. */
1754 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1756 1, /* size (0 = byte, 1 = short, 2 = long) */
1758 FALSE, /* pc_relative */
1760 complain_overflow_dont, /* complain_on_overflow */
1761 ppc64_elf_unhandled_reloc, /* special_function */
1762 "R_PPC64_GOT_TLSLD16_LO", /* name */
1763 FALSE, /* partial_inplace */
1765 0xffff, /* dst_mask */
1766 FALSE), /* pcrel_offset */
1768 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1769 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1770 16, /* rightshift */
1771 1, /* size (0 = byte, 1 = short, 2 = long) */
1773 FALSE, /* pc_relative */
1775 complain_overflow_signed, /* complain_on_overflow */
1776 ppc64_elf_unhandled_reloc, /* special_function */
1777 "R_PPC64_GOT_TLSLD16_HI", /* name */
1778 FALSE, /* partial_inplace */
1780 0xffff, /* dst_mask */
1781 FALSE), /* pcrel_offset */
1783 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1784 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1785 16, /* rightshift */
1786 1, /* size (0 = byte, 1 = short, 2 = long) */
1788 FALSE, /* pc_relative */
1790 complain_overflow_signed, /* complain_on_overflow */
1791 ppc64_elf_unhandled_reloc, /* special_function */
1792 "R_PPC64_GOT_TLSLD16_HA", /* name */
1793 FALSE, /* partial_inplace */
1795 0xffff, /* dst_mask */
1796 FALSE), /* pcrel_offset */
1798 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1799 the offset to the entry relative to the TOC base (r2). */
1800 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1802 1, /* size (0 = byte, 1 = short, 2 = long) */
1804 FALSE, /* pc_relative */
1806 complain_overflow_signed, /* complain_on_overflow */
1807 ppc64_elf_unhandled_reloc, /* special_function */
1808 "R_PPC64_GOT_DTPREL16_DS", /* name */
1809 FALSE, /* partial_inplace */
1811 0xfffc, /* dst_mask */
1812 FALSE), /* pcrel_offset */
1814 /* Like GOT_DTPREL16_DS, but no overflow. */
1815 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1817 1, /* size (0 = byte, 1 = short, 2 = long) */
1819 FALSE, /* pc_relative */
1821 complain_overflow_dont, /* complain_on_overflow */
1822 ppc64_elf_unhandled_reloc, /* special_function */
1823 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1824 FALSE, /* partial_inplace */
1826 0xfffc, /* dst_mask */
1827 FALSE), /* pcrel_offset */
1829 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1830 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1831 16, /* rightshift */
1832 1, /* size (0 = byte, 1 = short, 2 = long) */
1834 FALSE, /* pc_relative */
1836 complain_overflow_signed, /* complain_on_overflow */
1837 ppc64_elf_unhandled_reloc, /* special_function */
1838 "R_PPC64_GOT_DTPREL16_HI", /* name */
1839 FALSE, /* partial_inplace */
1841 0xffff, /* dst_mask */
1842 FALSE), /* pcrel_offset */
1844 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1845 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1846 16, /* rightshift */
1847 1, /* size (0 = byte, 1 = short, 2 = long) */
1849 FALSE, /* pc_relative */
1851 complain_overflow_signed, /* complain_on_overflow */
1852 ppc64_elf_unhandled_reloc, /* special_function */
1853 "R_PPC64_GOT_DTPREL16_HA", /* name */
1854 FALSE, /* partial_inplace */
1856 0xffff, /* dst_mask */
1857 FALSE), /* pcrel_offset */
1859 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1860 offset to the entry relative to the TOC base (r2). */
1861 HOWTO (R_PPC64_GOT_TPREL16_DS,
1863 1, /* size (0 = byte, 1 = short, 2 = long) */
1865 FALSE, /* pc_relative */
1867 complain_overflow_signed, /* complain_on_overflow */
1868 ppc64_elf_unhandled_reloc, /* special_function */
1869 "R_PPC64_GOT_TPREL16_DS", /* name */
1870 FALSE, /* partial_inplace */
1872 0xfffc, /* dst_mask */
1873 FALSE), /* pcrel_offset */
1875 /* Like GOT_TPREL16_DS, but no overflow. */
1876 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1878 1, /* size (0 = byte, 1 = short, 2 = long) */
1880 FALSE, /* pc_relative */
1882 complain_overflow_dont, /* complain_on_overflow */
1883 ppc64_elf_unhandled_reloc, /* special_function */
1884 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1885 FALSE, /* partial_inplace */
1887 0xfffc, /* dst_mask */
1888 FALSE), /* pcrel_offset */
1890 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1891 HOWTO (R_PPC64_GOT_TPREL16_HI,
1892 16, /* rightshift */
1893 1, /* size (0 = byte, 1 = short, 2 = long) */
1895 FALSE, /* pc_relative */
1897 complain_overflow_signed, /* complain_on_overflow */
1898 ppc64_elf_unhandled_reloc, /* special_function */
1899 "R_PPC64_GOT_TPREL16_HI", /* name */
1900 FALSE, /* partial_inplace */
1902 0xffff, /* dst_mask */
1903 FALSE), /* pcrel_offset */
1905 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1906 HOWTO (R_PPC64_GOT_TPREL16_HA,
1907 16, /* rightshift */
1908 1, /* size (0 = byte, 1 = short, 2 = long) */
1910 FALSE, /* pc_relative */
1912 complain_overflow_signed, /* complain_on_overflow */
1913 ppc64_elf_unhandled_reloc, /* special_function */
1914 "R_PPC64_GOT_TPREL16_HA", /* name */
1915 FALSE, /* partial_inplace */
1917 0xffff, /* dst_mask */
1918 FALSE), /* pcrel_offset */
1920 HOWTO (R_PPC64_JMP_IREL, /* type */
1922 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1924 FALSE, /* pc_relative */
1926 complain_overflow_dont, /* complain_on_overflow */
1927 ppc64_elf_unhandled_reloc, /* special_function */
1928 "R_PPC64_JMP_IREL", /* name */
1929 FALSE, /* partial_inplace */
1932 FALSE), /* pcrel_offset */
1934 HOWTO (R_PPC64_IRELATIVE, /* type */
1936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1938 FALSE, /* pc_relative */
1940 complain_overflow_dont, /* complain_on_overflow */
1941 bfd_elf_generic_reloc, /* special_function */
1942 "R_PPC64_IRELATIVE", /* name */
1943 FALSE, /* partial_inplace */
1945 ONES (64), /* dst_mask */
1946 FALSE), /* pcrel_offset */
1948 /* A 16 bit relative relocation. */
1949 HOWTO (R_PPC64_REL16, /* type */
1951 1, /* size (0 = byte, 1 = short, 2 = long) */
1953 TRUE, /* pc_relative */
1955 complain_overflow_bitfield, /* complain_on_overflow */
1956 bfd_elf_generic_reloc, /* special_function */
1957 "R_PPC64_REL16", /* name */
1958 FALSE, /* partial_inplace */
1960 0xffff, /* dst_mask */
1961 TRUE), /* pcrel_offset */
1963 /* A 16 bit relative relocation without overflow. */
1964 HOWTO (R_PPC64_REL16_LO, /* type */
1966 1, /* size (0 = byte, 1 = short, 2 = long) */
1968 TRUE, /* pc_relative */
1970 complain_overflow_dont,/* complain_on_overflow */
1971 bfd_elf_generic_reloc, /* special_function */
1972 "R_PPC64_REL16_LO", /* name */
1973 FALSE, /* partial_inplace */
1975 0xffff, /* dst_mask */
1976 TRUE), /* pcrel_offset */
1978 /* The high order 16 bits of a relative address. */
1979 HOWTO (R_PPC64_REL16_HI, /* type */
1980 16, /* rightshift */
1981 1, /* size (0 = byte, 1 = short, 2 = long) */
1983 TRUE, /* pc_relative */
1985 complain_overflow_signed, /* complain_on_overflow */
1986 bfd_elf_generic_reloc, /* special_function */
1987 "R_PPC64_REL16_HI", /* name */
1988 FALSE, /* partial_inplace */
1990 0xffff, /* dst_mask */
1991 TRUE), /* pcrel_offset */
1993 /* The high order 16 bits of a relative address, plus 1 if the contents of
1994 the low 16 bits, treated as a signed number, is negative. */
1995 HOWTO (R_PPC64_REL16_HA, /* type */
1996 16, /* rightshift */
1997 1, /* size (0 = byte, 1 = short, 2 = long) */
1999 TRUE, /* pc_relative */
2001 complain_overflow_signed, /* complain_on_overflow */
2002 ppc64_elf_ha_reloc, /* special_function */
2003 "R_PPC64_REL16_HA", /* name */
2004 FALSE, /* partial_inplace */
2006 0xffff, /* dst_mask */
2007 TRUE), /* pcrel_offset */
2009 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2010 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2011 16, /* rightshift */
2012 1, /* size (0 = byte, 1 = short, 2 = long) */
2014 FALSE, /* pc_relative */
2016 complain_overflow_dont, /* complain_on_overflow */
2017 bfd_elf_generic_reloc, /* special_function */
2018 "R_PPC64_ADDR16_HIGH", /* name */
2019 FALSE, /* partial_inplace */
2021 0xffff, /* dst_mask */
2022 FALSE), /* pcrel_offset */
2024 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2025 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2026 16, /* rightshift */
2027 1, /* size (0 = byte, 1 = short, 2 = long) */
2029 FALSE, /* pc_relative */
2031 complain_overflow_dont, /* complain_on_overflow */
2032 ppc64_elf_ha_reloc, /* special_function */
2033 "R_PPC64_ADDR16_HIGHA", /* name */
2034 FALSE, /* partial_inplace */
2036 0xffff, /* dst_mask */
2037 FALSE), /* pcrel_offset */
2039 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2040 HOWTO (R_PPC64_DTPREL16_HIGH,
2041 16, /* rightshift */
2042 1, /* size (0 = byte, 1 = short, 2 = long) */
2044 FALSE, /* pc_relative */
2046 complain_overflow_dont, /* complain_on_overflow */
2047 ppc64_elf_unhandled_reloc, /* special_function */
2048 "R_PPC64_DTPREL16_HIGH", /* name */
2049 FALSE, /* partial_inplace */
2051 0xffff, /* dst_mask */
2052 FALSE), /* pcrel_offset */
2054 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2055 HOWTO (R_PPC64_DTPREL16_HIGHA,
2056 16, /* rightshift */
2057 1, /* size (0 = byte, 1 = short, 2 = long) */
2059 FALSE, /* pc_relative */
2061 complain_overflow_dont, /* complain_on_overflow */
2062 ppc64_elf_unhandled_reloc, /* special_function */
2063 "R_PPC64_DTPREL16_HIGHA", /* name */
2064 FALSE, /* partial_inplace */
2066 0xffff, /* dst_mask */
2067 FALSE), /* pcrel_offset */
2069 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2070 HOWTO (R_PPC64_TPREL16_HIGH,
2071 16, /* rightshift */
2072 1, /* size (0 = byte, 1 = short, 2 = long) */
2074 FALSE, /* pc_relative */
2076 complain_overflow_dont, /* complain_on_overflow */
2077 ppc64_elf_unhandled_reloc, /* special_function */
2078 "R_PPC64_TPREL16_HIGH", /* name */
2079 FALSE, /* partial_inplace */
2081 0xffff, /* dst_mask */
2082 FALSE), /* pcrel_offset */
2084 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2085 HOWTO (R_PPC64_TPREL16_HIGHA,
2086 16, /* rightshift */
2087 1, /* size (0 = byte, 1 = short, 2 = long) */
2089 FALSE, /* pc_relative */
2091 complain_overflow_dont, /* complain_on_overflow */
2092 ppc64_elf_unhandled_reloc, /* special_function */
2093 "R_PPC64_TPREL16_HIGHA", /* name */
2094 FALSE, /* partial_inplace */
2096 0xffff, /* dst_mask */
2097 FALSE), /* pcrel_offset */
2099 /* GNU extension to record C++ vtable hierarchy. */
2100 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2102 0, /* size (0 = byte, 1 = short, 2 = long) */
2104 FALSE, /* pc_relative */
2106 complain_overflow_dont, /* complain_on_overflow */
2107 NULL, /* special_function */
2108 "R_PPC64_GNU_VTINHERIT", /* name */
2109 FALSE, /* partial_inplace */
2112 FALSE), /* pcrel_offset */
2114 /* GNU extension to record C++ vtable member usage. */
2115 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2117 0, /* size (0 = byte, 1 = short, 2 = long) */
2119 FALSE, /* pc_relative */
2121 complain_overflow_dont, /* complain_on_overflow */
2122 NULL, /* special_function */
2123 "R_PPC64_GNU_VTENTRY", /* name */
2124 FALSE, /* partial_inplace */
2127 FALSE), /* pcrel_offset */
2131 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2135 ppc_howto_init (void)
2137 unsigned int i, type;
2140 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2143 type = ppc64_elf_howto_raw[i].type;
2144 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2145 / sizeof (ppc64_elf_howto_table[0])));
2146 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2150 static reloc_howto_type *
2151 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2152 bfd_reloc_code_real_type code)
2154 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2156 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2157 /* Initialize howto table if needed. */
2165 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2167 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2169 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2171 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2173 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2175 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2177 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2179 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2181 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2183 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2185 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2187 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2189 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2191 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2193 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2195 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2197 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2199 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2201 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2203 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2205 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2207 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2209 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2211 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2213 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2215 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2217 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2219 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2221 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2223 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2225 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2227 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2229 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2231 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2233 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2235 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2237 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2239 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2241 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2243 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2245 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2247 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2249 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2251 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2253 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2255 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2257 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2259 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2261 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2263 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2265 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2267 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2269 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2271 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2273 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2275 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2277 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2279 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2281 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2283 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2285 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2287 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2289 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2291 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2293 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2295 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2297 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2299 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2301 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2303 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2305 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2307 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2309 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2311 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2313 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2315 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2317 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2319 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2321 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2323 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2325 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2327 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2329 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2331 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2333 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2335 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2337 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2339 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2341 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2343 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2345 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2347 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2349 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2351 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2353 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2355 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2357 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2359 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2361 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2363 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2365 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2367 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2369 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2371 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2373 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2375 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2379 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2381 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2383 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2385 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2387 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2389 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2393 return ppc64_elf_howto_table[r];
2396 static reloc_howto_type *
2397 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2403 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2405 if (ppc64_elf_howto_raw[i].name != NULL
2406 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2407 return &ppc64_elf_howto_raw[i];
2412 /* Set the howto pointer for a PowerPC ELF reloc. */
2415 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2416 Elf_Internal_Rela *dst)
2420 /* Initialize howto table if needed. */
2421 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2424 type = ELF64_R_TYPE (dst->r_info);
2425 if (type >= (sizeof (ppc64_elf_howto_table)
2426 / sizeof (ppc64_elf_howto_table[0])))
2428 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2430 type = R_PPC64_NONE;
2432 cache_ptr->howto = ppc64_elf_howto_table[type];
2435 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2437 static bfd_reloc_status_type
2438 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2439 void *data, asection *input_section,
2440 bfd *output_bfd, char **error_message)
2442 /* If this is a relocatable link (output_bfd test tells us), just
2443 call the generic function. Any adjustment will be done at final
2445 if (output_bfd != NULL)
2446 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2447 input_section, output_bfd, error_message);
2449 /* Adjust the addend for sign extension of the low 16 bits.
2450 We won't actually be using the low 16 bits, so trashing them
2452 reloc_entry->addend += 0x8000;
2453 return bfd_reloc_continue;
2456 static bfd_reloc_status_type
2457 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2458 void *data, asection *input_section,
2459 bfd *output_bfd, char **error_message)
2461 if (output_bfd != NULL)
2462 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2463 input_section, output_bfd, error_message);
2465 if (strcmp (symbol->section->name, ".opd") == 0
2466 && (symbol->section->owner->flags & DYNAMIC) == 0)
2468 bfd_vma dest = opd_entry_value (symbol->section,
2469 symbol->value + reloc_entry->addend,
2471 if (dest != (bfd_vma) -1)
2472 reloc_entry->addend = dest - (symbol->value
2473 + symbol->section->output_section->vma
2474 + symbol->section->output_offset);
2476 return bfd_reloc_continue;
2479 static bfd_reloc_status_type
2480 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2481 void *data, asection *input_section,
2482 bfd *output_bfd, char **error_message)
2485 enum elf_ppc64_reloc_type r_type;
2486 bfd_size_type octets;
2487 /* Assume 'at' branch hints. */
2488 bfd_boolean is_isa_v2 = TRUE;
2490 /* If this is a relocatable link (output_bfd test tells us), just
2491 call the generic function. Any adjustment will be done at final
2493 if (output_bfd != NULL)
2494 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2495 input_section, output_bfd, error_message);
2497 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2498 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2499 insn &= ~(0x01 << 21);
2500 r_type = reloc_entry->howto->type;
2501 if (r_type == R_PPC64_ADDR14_BRTAKEN
2502 || r_type == R_PPC64_REL14_BRTAKEN)
2503 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2507 /* Set 'a' bit. This is 0b00010 in BO field for branch
2508 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2509 for branch on CTR insns (BO == 1a00t or 1a01t). */
2510 if ((insn & (0x14 << 21)) == (0x04 << 21))
2512 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2522 if (!bfd_is_com_section (symbol->section))
2523 target = symbol->value;
2524 target += symbol->section->output_section->vma;
2525 target += symbol->section->output_offset;
2526 target += reloc_entry->addend;
2528 from = (reloc_entry->address
2529 + input_section->output_offset
2530 + input_section->output_section->vma);
2532 /* Invert 'y' bit if not the default. */
2533 if ((bfd_signed_vma) (target - from) < 0)
2536 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2538 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2539 input_section, output_bfd, error_message);
2542 static bfd_reloc_status_type
2543 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544 void *data, asection *input_section,
2545 bfd *output_bfd, char **error_message)
2547 /* If this is a relocatable link (output_bfd test tells us), just
2548 call the generic function. Any adjustment will be done at final
2550 if (output_bfd != NULL)
2551 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2552 input_section, output_bfd, error_message);
2554 /* Subtract the symbol section base address. */
2555 reloc_entry->addend -= symbol->section->output_section->vma;
2556 return bfd_reloc_continue;
2559 static bfd_reloc_status_type
2560 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2561 void *data, asection *input_section,
2562 bfd *output_bfd, char **error_message)
2564 /* If this is a relocatable link (output_bfd test tells us), just
2565 call the generic function. Any adjustment will be done at final
2567 if (output_bfd != NULL)
2568 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2569 input_section, output_bfd, error_message);
2571 /* Subtract the symbol section base address. */
2572 reloc_entry->addend -= symbol->section->output_section->vma;
2574 /* Adjust the addend for sign extension of the low 16 bits. */
2575 reloc_entry->addend += 0x8000;
2576 return bfd_reloc_continue;
2579 static bfd_reloc_status_type
2580 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2581 void *data, asection *input_section,
2582 bfd *output_bfd, char **error_message)
2586 /* If this is a relocatable link (output_bfd test tells us), just
2587 call the generic function. Any adjustment will be done at final
2589 if (output_bfd != NULL)
2590 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2591 input_section, output_bfd, error_message);
2593 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2595 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2597 /* Subtract the TOC base address. */
2598 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2599 return bfd_reloc_continue;
2602 static bfd_reloc_status_type
2603 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2604 void *data, asection *input_section,
2605 bfd *output_bfd, char **error_message)
2609 /* If this is a relocatable link (output_bfd test tells us), just
2610 call the generic function. Any adjustment will be done at final
2612 if (output_bfd != NULL)
2613 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2614 input_section, output_bfd, error_message);
2616 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2618 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2620 /* Subtract the TOC base address. */
2621 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2623 /* Adjust the addend for sign extension of the low 16 bits. */
2624 reloc_entry->addend += 0x8000;
2625 return bfd_reloc_continue;
2628 static bfd_reloc_status_type
2629 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2630 void *data, asection *input_section,
2631 bfd *output_bfd, char **error_message)
2634 bfd_size_type octets;
2636 /* If this is a relocatable link (output_bfd test tells us), just
2637 call the generic function. Any adjustment will be done at final
2639 if (output_bfd != NULL)
2640 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2641 input_section, output_bfd, error_message);
2643 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2645 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2647 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2648 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2649 return bfd_reloc_ok;
2652 static bfd_reloc_status_type
2653 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654 void *data, asection *input_section,
2655 bfd *output_bfd, char **error_message)
2657 /* If this is a relocatable link (output_bfd test tells us), just
2658 call the generic function. Any adjustment will be done at final
2660 if (output_bfd != NULL)
2661 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2662 input_section, output_bfd, error_message);
2664 if (error_message != NULL)
2666 static char buf[60];
2667 sprintf (buf, "generic linker can't handle %s",
2668 reloc_entry->howto->name);
2669 *error_message = buf;
2671 return bfd_reloc_dangerous;
2674 /* Track GOT entries needed for a given symbol. We might need more
2675 than one got entry per symbol. */
2678 struct got_entry *next;
2680 /* The symbol addend that we'll be placing in the GOT. */
2683 /* Unlike other ELF targets, we use separate GOT entries for the same
2684 symbol referenced from different input files. This is to support
2685 automatic multiple TOC/GOT sections, where the TOC base can vary
2686 from one input file to another. After partitioning into TOC groups
2687 we merge entries within the group.
2689 Point to the BFD owning this GOT entry. */
2692 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2693 TLS_TPREL or TLS_DTPREL for tls entries. */
2694 unsigned char tls_type;
2696 /* Non-zero if got.ent points to real entry. */
2697 unsigned char is_indirect;
2699 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2702 bfd_signed_vma refcount;
2704 struct got_entry *ent;
2708 /* The same for PLT. */
2711 struct plt_entry *next;
2717 bfd_signed_vma refcount;
2722 struct ppc64_elf_obj_tdata
2724 struct elf_obj_tdata elf;
2726 /* Shortcuts to dynamic linker sections. */
2730 /* Used during garbage collection. We attach global symbols defined
2731 on removed .opd entries to this section so that the sym is removed. */
2732 asection *deleted_section;
2734 /* TLS local dynamic got entry handling. Support for multiple GOT
2735 sections means we potentially need one of these for each input bfd. */
2736 struct got_entry tlsld_got;
2739 /* A copy of relocs before they are modified for --emit-relocs. */
2740 Elf_Internal_Rela *relocs;
2742 /* Section contents. */
2746 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2747 the reloc to be in the range -32768 to 32767. */
2748 unsigned int has_small_toc_reloc : 1;
2750 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2751 instruction not one we handle. */
2752 unsigned int unexpected_toc_insn : 1;
2755 #define ppc64_elf_tdata(bfd) \
2756 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2758 #define ppc64_tlsld_got(bfd) \
2759 (&ppc64_elf_tdata (bfd)->tlsld_got)
2761 #define is_ppc64_elf(bfd) \
2762 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2763 && elf_object_id (bfd) == PPC64_ELF_DATA)
2765 /* Override the generic function because we store some extras. */
2768 ppc64_elf_mkobject (bfd *abfd)
2770 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2774 /* Fix bad default arch selected for a 64 bit input bfd when the
2775 default is 32 bit. */
2778 ppc64_elf_object_p (bfd *abfd)
2780 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2782 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2784 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2786 /* Relies on arch after 32 bit default being 64 bit default. */
2787 abfd->arch_info = abfd->arch_info->next;
2788 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2794 /* Support for core dump NOTE sections. */
2797 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2799 size_t offset, size;
2801 if (note->descsz != 504)
2805 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2808 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2814 /* Make a ".reg/999" section. */
2815 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2816 size, note->descpos + offset);
2820 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2822 if (note->descsz != 136)
2825 elf_tdata (abfd)->core->pid
2826 = bfd_get_32 (abfd, note->descdata + 24);
2827 elf_tdata (abfd)->core->program
2828 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2829 elf_tdata (abfd)->core->command
2830 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2836 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2849 va_start (ap, note_type);
2850 memset (data, 0, sizeof (data));
2851 strncpy (data + 40, va_arg (ap, const char *), 16);
2852 strncpy (data + 56, va_arg (ap, const char *), 80);
2854 return elfcore_write_note (abfd, buf, bufsiz,
2855 "CORE", note_type, data, sizeof (data));
2866 va_start (ap, note_type);
2867 memset (data, 0, 112);
2868 pid = va_arg (ap, long);
2869 bfd_put_32 (abfd, pid, data + 32);
2870 cursig = va_arg (ap, int);
2871 bfd_put_16 (abfd, cursig, data + 12);
2872 greg = va_arg (ap, const void *);
2873 memcpy (data + 112, greg, 384);
2874 memset (data + 496, 0, 8);
2876 return elfcore_write_note (abfd, buf, bufsiz,
2877 "CORE", note_type, data, sizeof (data));
2882 /* Add extra PPC sections. */
2884 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2886 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2887 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2888 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2891 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2892 { NULL, 0, 0, 0, 0 }
2895 enum _ppc64_sec_type {
2901 struct _ppc64_elf_section_data
2903 struct bfd_elf_section_data elf;
2907 /* An array with one entry for each opd function descriptor. */
2908 struct _opd_sec_data
2910 /* Points to the function code section for local opd entries. */
2911 asection **func_sec;
2913 /* After editing .opd, adjust references to opd local syms. */
2917 /* An array for toc sections, indexed by offset/8. */
2918 struct _toc_sec_data
2920 /* Specifies the relocation symbol index used at a given toc offset. */
2923 /* And the relocation addend. */
2928 enum _ppc64_sec_type sec_type:2;
2930 /* Flag set when small branches are detected. Used to
2931 select suitable defaults for the stub group size. */
2932 unsigned int has_14bit_branch:1;
2935 #define ppc64_elf_section_data(sec) \
2936 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2939 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2941 if (!sec->used_by_bfd)
2943 struct _ppc64_elf_section_data *sdata;
2944 bfd_size_type amt = sizeof (*sdata);
2946 sdata = bfd_zalloc (abfd, amt);
2949 sec->used_by_bfd = sdata;
2952 return _bfd_elf_new_section_hook (abfd, sec);
2955 static struct _opd_sec_data *
2956 get_opd_info (asection * sec)
2959 && ppc64_elf_section_data (sec) != NULL
2960 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2961 return &ppc64_elf_section_data (sec)->u.opd;
2966 abiversion (bfd *abfd)
2968 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2972 set_abiversion (bfd *abfd, int ver)
2974 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2975 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2978 /* Parameters for the qsort hook. */
2979 static bfd_boolean synthetic_relocatable;
2981 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2984 compare_symbols (const void *ap, const void *bp)
2986 const asymbol *a = * (const asymbol **) ap;
2987 const asymbol *b = * (const asymbol **) bp;
2989 /* Section symbols first. */
2990 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2992 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2995 /* then .opd symbols. */
2996 if (strcmp (a->section->name, ".opd") == 0
2997 && strcmp (b->section->name, ".opd") != 0)
2999 if (strcmp (a->section->name, ".opd") != 0
3000 && strcmp (b->section->name, ".opd") == 0)
3003 /* then other code symbols. */
3004 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3005 == (SEC_CODE | SEC_ALLOC)
3006 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3007 != (SEC_CODE | SEC_ALLOC))
3010 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3011 != (SEC_CODE | SEC_ALLOC)
3012 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3013 == (SEC_CODE | SEC_ALLOC))
3016 if (synthetic_relocatable)
3018 if (a->section->id < b->section->id)
3021 if (a->section->id > b->section->id)
3025 if (a->value + a->section->vma < b->value + b->section->vma)
3028 if (a->value + a->section->vma > b->value + b->section->vma)
3031 /* For syms with the same value, prefer strong dynamic global function
3032 syms over other syms. */
3033 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3036 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3039 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3042 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3045 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3048 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3051 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3054 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3060 /* Search SYMS for a symbol of the given VALUE. */
3063 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3071 mid = (lo + hi) >> 1;
3072 if (syms[mid]->value + syms[mid]->section->vma < value)
3074 else if (syms[mid]->value + syms[mid]->section->vma > value)
3084 mid = (lo + hi) >> 1;
3085 if (syms[mid]->section->id < id)
3087 else if (syms[mid]->section->id > id)
3089 else if (syms[mid]->value < value)
3091 else if (syms[mid]->value > value)
3101 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3103 bfd_vma vma = *(bfd_vma *) ptr;
3104 return ((section->flags & SEC_ALLOC) != 0
3105 && section->vma <= vma
3106 && vma < section->vma + section->size);
3109 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3110 entry syms. Also generate @plt symbols for the glink branch table. */
3113 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3114 long static_count, asymbol **static_syms,
3115 long dyn_count, asymbol **dyn_syms,
3122 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3123 asection *opd = NULL;
3124 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3126 int abi = abiversion (abfd);
3132 opd = bfd_get_section_by_name (abfd, ".opd");
3133 if (opd == NULL && abi == 1)
3137 symcount = static_count;
3139 symcount += dyn_count;
3143 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3147 if (!relocatable && static_count != 0 && dyn_count != 0)
3149 /* Use both symbol tables. */
3150 memcpy (syms, static_syms, static_count * sizeof (*syms));
3151 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3153 else if (!relocatable && static_count == 0)
3154 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3156 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3158 synthetic_relocatable = relocatable;
3159 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3161 if (!relocatable && symcount > 1)
3164 /* Trim duplicate syms, since we may have merged the normal and
3165 dynamic symbols. Actually, we only care about syms that have
3166 different values, so trim any with the same value. */
3167 for (i = 1, j = 1; i < symcount; ++i)
3168 if (syms[i - 1]->value + syms[i - 1]->section->vma
3169 != syms[i]->value + syms[i]->section->vma)
3170 syms[j++] = syms[i];
3175 if (strcmp (syms[i]->section->name, ".opd") == 0)
3179 for (; i < symcount; ++i)
3180 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3181 != (SEC_CODE | SEC_ALLOC))
3182 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3186 for (; i < symcount; ++i)
3187 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3191 for (; i < symcount; ++i)
3192 if (strcmp (syms[i]->section->name, ".opd") != 0)
3196 for (; i < symcount; ++i)
3197 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3198 != (SEC_CODE | SEC_ALLOC))
3206 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3211 if (opdsymend == secsymend)
3214 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3215 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3219 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3226 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3230 while (r < opd->relocation + relcount
3231 && r->address < syms[i]->value + opd->vma)
3234 if (r == opd->relocation + relcount)
3237 if (r->address != syms[i]->value + opd->vma)
3240 if (r->howto->type != R_PPC64_ADDR64)
3243 sym = *r->sym_ptr_ptr;
3244 if (!sym_exists_at (syms, opdsymend, symcount,
3245 sym->section->id, sym->value + r->addend))
3248 size += sizeof (asymbol);
3249 size += strlen (syms[i]->name) + 2;
3253 s = *ret = bfd_malloc (size);
3260 names = (char *) (s + count);
3262 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3266 while (r < opd->relocation + relcount
3267 && r->address < syms[i]->value + opd->vma)
3270 if (r == opd->relocation + relcount)
3273 if (r->address != syms[i]->value + opd->vma)
3276 if (r->howto->type != R_PPC64_ADDR64)
3279 sym = *r->sym_ptr_ptr;
3280 if (!sym_exists_at (syms, opdsymend, symcount,
3281 sym->section->id, sym->value + r->addend))
3286 s->flags |= BSF_SYNTHETIC;
3287 s->section = sym->section;
3288 s->value = sym->value + r->addend;
3291 len = strlen (syms[i]->name);
3292 memcpy (names, syms[i]->name, len + 1);
3294 /* Have udata.p point back to the original symbol this
3295 synthetic symbol was derived from. */
3296 s->udata.p = syms[i];
3303 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3304 bfd_byte *contents = NULL;
3307 bfd_vma glink_vma = 0, resolv_vma = 0;
3308 asection *dynamic, *glink = NULL, *relplt = NULL;
3311 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3313 free_contents_and_exit:
3321 for (i = secsymend; i < opdsymend; ++i)
3325 /* Ignore bogus symbols. */
3326 if (syms[i]->value > opd->size - 8)
3329 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3330 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3333 size += sizeof (asymbol);
3334 size += strlen (syms[i]->name) + 2;
3338 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3340 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3342 bfd_byte *dynbuf, *extdyn, *extdynend;
3344 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3346 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3347 goto free_contents_and_exit;
3349 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3350 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3353 extdynend = extdyn + dynamic->size;
3354 for (; extdyn < extdynend; extdyn += extdynsize)
3356 Elf_Internal_Dyn dyn;
3357 (*swap_dyn_in) (abfd, extdyn, &dyn);
3359 if (dyn.d_tag == DT_NULL)
3362 if (dyn.d_tag == DT_PPC64_GLINK)
3364 /* The first glink stub starts at offset 32; see
3365 comment in ppc64_elf_finish_dynamic_sections. */
3366 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3367 /* The .glink section usually does not survive the final
3368 link; search for the section (usually .text) where the
3369 glink stubs now reside. */
3370 glink = bfd_sections_find_if (abfd, section_covers_vma,
3381 /* Determine __glink trampoline by reading the relative branch
3382 from the first glink stub. */
3384 unsigned int off = 0;
3386 while (bfd_get_section_contents (abfd, glink, buf,
3387 glink_vma + off - glink->vma, 4))
3389 unsigned int insn = bfd_get_32 (abfd, buf);
3391 if ((insn & ~0x3fffffc) == 0)
3393 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3402 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3404 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3407 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3408 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3409 goto free_contents_and_exit;
3411 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3412 size += plt_count * sizeof (asymbol);
3414 p = relplt->relocation;
3415 for (i = 0; i < plt_count; i++, p++)
3417 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3419 size += sizeof ("+0x") - 1 + 16;
3424 s = *ret = bfd_malloc (size);
3426 goto free_contents_and_exit;
3428 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3430 for (i = secsymend; i < opdsymend; ++i)
3434 if (syms[i]->value > opd->size - 8)
3437 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3442 asection *sec = abfd->sections;
3449 long mid = (lo + hi) >> 1;
3450 if (syms[mid]->section->vma < ent)
3452 else if (syms[mid]->section->vma > ent)
3456 sec = syms[mid]->section;
3461 if (lo >= hi && lo > codesecsym)
3462 sec = syms[lo - 1]->section;
3464 for (; sec != NULL; sec = sec->next)
3468 /* SEC_LOAD may not be set if SEC is from a separate debug
3470 if ((sec->flags & SEC_ALLOC) == 0)
3472 if ((sec->flags & SEC_CODE) != 0)
3475 s->flags |= BSF_SYNTHETIC;
3476 s->value = ent - s->section->vma;
3479 len = strlen (syms[i]->name);
3480 memcpy (names, syms[i]->name, len + 1);
3482 /* Have udata.p point back to the original symbol this
3483 synthetic symbol was derived from. */
3484 s->udata.p = syms[i];
3490 if (glink != NULL && relplt != NULL)
3494 /* Add a symbol for the main glink trampoline. */
3495 memset (s, 0, sizeof *s);
3497 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3499 s->value = resolv_vma - glink->vma;
3501 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3502 names += sizeof ("__glink_PLTresolve");
3507 /* FIXME: It would be very much nicer to put sym@plt on the
3508 stub rather than on the glink branch table entry. The
3509 objdump disassembler would then use a sensible symbol
3510 name on plt calls. The difficulty in doing so is
3511 a) finding the stubs, and,
3512 b) matching stubs against plt entries, and,
3513 c) there can be multiple stubs for a given plt entry.
3515 Solving (a) could be done by code scanning, but older
3516 ppc64 binaries used different stubs to current code.
3517 (b) is the tricky one since you need to known the toc
3518 pointer for at least one function that uses a pic stub to
3519 be able to calculate the plt address referenced.
3520 (c) means gdb would need to set multiple breakpoints (or
3521 find the glink branch itself) when setting breakpoints
3522 for pending shared library loads. */
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3528 *s = **p->sym_ptr_ptr;
3529 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3530 we are defining a symbol, ensure one of them is set. */
3531 if ((s->flags & BSF_LOCAL) == 0)
3532 s->flags |= BSF_GLOBAL;
3533 s->flags |= BSF_SYNTHETIC;
3535 s->value = glink_vma - glink->vma;
3538 len = strlen ((*p->sym_ptr_ptr)->name);
3539 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3543 memcpy (names, "+0x", sizeof ("+0x") - 1);
3544 names += sizeof ("+0x") - 1;
3545 bfd_sprintf_vma (abfd, names, p->addend);
3546 names += strlen (names);
3548 memcpy (names, "@plt", sizeof ("@plt"));
3549 names += sizeof ("@plt");
3569 /* The following functions are specific to the ELF linker, while
3570 functions above are used generally. Those named ppc64_elf_* are
3571 called by the main ELF linker code. They appear in this file more
3572 or less in the order in which they are called. eg.
3573 ppc64_elf_check_relocs is called early in the link process,
3574 ppc64_elf_finish_dynamic_sections is one of the last functions
3577 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3578 functions have both a function code symbol and a function descriptor
3579 symbol. A call to foo in a relocatable object file looks like:
3586 The function definition in another object file might be:
3590 . .quad .TOC.@tocbase
3596 When the linker resolves the call during a static link, the branch
3597 unsurprisingly just goes to .foo and the .opd information is unused.
3598 If the function definition is in a shared library, things are a little
3599 different: The call goes via a plt call stub, the opd information gets
3600 copied to the plt, and the linker patches the nop.
3608 . std 2,40(1) # in practice, the call stub
3609 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3610 . addi 11,11,Lfoo@toc@l # this is the general idea
3618 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3620 The "reloc ()" notation is supposed to indicate that the linker emits
3621 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3624 What are the difficulties here? Well, firstly, the relocations
3625 examined by the linker in check_relocs are against the function code
3626 sym .foo, while the dynamic relocation in the plt is emitted against
3627 the function descriptor symbol, foo. Somewhere along the line, we need
3628 to carefully copy dynamic link information from one symbol to the other.
3629 Secondly, the generic part of the elf linker will make .foo a dynamic
3630 symbol as is normal for most other backends. We need foo dynamic
3631 instead, at least for an application final link. However, when
3632 creating a shared library containing foo, we need to have both symbols
3633 dynamic so that references to .foo are satisfied during the early
3634 stages of linking. Otherwise the linker might decide to pull in a
3635 definition from some other object, eg. a static library.
3637 Update: As of August 2004, we support a new convention. Function
3638 calls may use the function descriptor symbol, ie. "bl foo". This
3639 behaves exactly as "bl .foo". */
3641 /* Of those relocs that might be copied as dynamic relocs, this function
3642 selects those that must be copied when linking a shared library,
3643 even when the symbol is local. */
3646 must_be_dyn_reloc (struct bfd_link_info *info,
3647 enum elf_ppc64_reloc_type r_type)
3659 case R_PPC64_TPREL16:
3660 case R_PPC64_TPREL16_LO:
3661 case R_PPC64_TPREL16_HI:
3662 case R_PPC64_TPREL16_HA:
3663 case R_PPC64_TPREL16_DS:
3664 case R_PPC64_TPREL16_LO_DS:
3665 case R_PPC64_TPREL16_HIGH:
3666 case R_PPC64_TPREL16_HIGHA:
3667 case R_PPC64_TPREL16_HIGHER:
3668 case R_PPC64_TPREL16_HIGHERA:
3669 case R_PPC64_TPREL16_HIGHEST:
3670 case R_PPC64_TPREL16_HIGHESTA:
3671 case R_PPC64_TPREL64:
3672 return !info->executable;
3676 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3677 copying dynamic variables from a shared lib into an app's dynbss
3678 section, and instead use a dynamic relocation to point into the
3679 shared lib. With code that gcc generates, it's vital that this be
3680 enabled; In the PowerPC64 ABI, the address of a function is actually
3681 the address of a function descriptor, which resides in the .opd
3682 section. gcc uses the descriptor directly rather than going via the
3683 GOT as some other ABI's do, which means that initialized function
3684 pointers must reference the descriptor. Thus, a function pointer
3685 initialized to the address of a function in a shared library will
3686 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3687 redefines the function descriptor symbol to point to the copy. This
3688 presents a problem as a plt entry for that function is also
3689 initialized from the function descriptor symbol and the copy reloc
3690 may not be initialized first. */
3691 #define ELIMINATE_COPY_RELOCS 1
3693 /* Section name for stubs is the associated section name plus this
3695 #define STUB_SUFFIX ".stub"
3698 ppc_stub_long_branch:
3699 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3700 destination, but a 24 bit branch in a stub section will reach.
3703 ppc_stub_plt_branch:
3704 Similar to the above, but a 24 bit branch in the stub section won't
3705 reach its destination.
3706 . addis %r11,%r2,xxx@toc@ha
3707 . ld %r12,xxx@toc@l(%r11)
3712 Used to call a function in a shared library. If it so happens that
3713 the plt entry referenced crosses a 64k boundary, then an extra
3714 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3716 . addis %r11,%r2,xxx@toc@ha
3717 . ld %r12,xxx+0@toc@l(%r11)
3719 . ld %r2,xxx+8@toc@l(%r11)
3720 . ld %r11,xxx+16@toc@l(%r11)
3723 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3724 code to adjust the value and save r2 to support multiple toc sections.
3725 A ppc_stub_long_branch with an r2 offset looks like:
3727 . addis %r2,%r2,off@ha
3728 . addi %r2,%r2,off@l
3731 A ppc_stub_plt_branch with an r2 offset looks like:
3733 . addis %r11,%r2,xxx@toc@ha
3734 . ld %r12,xxx@toc@l(%r11)
3735 . addis %r2,%r2,off@ha
3736 . addi %r2,%r2,off@l
3740 In cases where the "addis" instruction would add zero, the "addis" is
3741 omitted and following instructions modified slightly in some cases.
3744 enum ppc_stub_type {
3746 ppc_stub_long_branch,
3747 ppc_stub_long_branch_r2off,
3748 ppc_stub_plt_branch,
3749 ppc_stub_plt_branch_r2off,
3751 ppc_stub_plt_call_r2save
3754 struct ppc_stub_hash_entry {
3756 /* Base hash table entry structure. */
3757 struct bfd_hash_entry root;
3759 enum ppc_stub_type stub_type;
3761 /* The stub section. */
3764 /* Offset within stub_sec of the beginning of this stub. */
3765 bfd_vma stub_offset;
3767 /* Given the symbol's value and its section we can determine its final
3768 value when building the stubs (so the stub knows where to jump. */
3769 bfd_vma target_value;
3770 asection *target_section;
3772 /* The symbol table entry, if any, that this was derived from. */
3773 struct ppc_link_hash_entry *h;
3774 struct plt_entry *plt_ent;
3776 /* Where this stub is being called from, or, in the case of combined
3777 stub sections, the first input section in the group. */
3780 /* Symbol st_other. */
3781 unsigned char other;
3784 struct ppc_branch_hash_entry {
3786 /* Base hash table entry structure. */
3787 struct bfd_hash_entry root;
3789 /* Offset within branch lookup table. */
3790 unsigned int offset;
3792 /* Generation marker. */
3796 /* Used to track dynamic relocations for local symbols. */
3797 struct ppc_dyn_relocs
3799 struct ppc_dyn_relocs *next;
3801 /* The input section of the reloc. */
3804 /* Total number of relocs copied for the input section. */
3805 unsigned int count : 31;
3807 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3808 unsigned int ifunc : 1;
3811 struct ppc_link_hash_entry
3813 struct elf_link_hash_entry elf;
3816 /* A pointer to the most recently used stub hash entry against this
3818 struct ppc_stub_hash_entry *stub_cache;
3820 /* A pointer to the next symbol starting with a '.' */
3821 struct ppc_link_hash_entry *next_dot_sym;
3824 /* Track dynamic relocs copied for this symbol. */
3825 struct elf_dyn_relocs *dyn_relocs;
3827 /* Link between function code and descriptor symbols. */
3828 struct ppc_link_hash_entry *oh;
3830 /* Flag function code and descriptor symbols. */
3831 unsigned int is_func:1;
3832 unsigned int is_func_descriptor:1;
3833 unsigned int fake:1;
3835 /* Whether global opd/toc sym has been adjusted or not.
3836 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3837 should be set for all globals defined in any opd/toc section. */
3838 unsigned int adjust_done:1;
3840 /* Set if we twiddled this symbol to weak at some stage. */
3841 unsigned int was_undefined:1;
3843 /* Contexts in which symbol is used in the GOT (or TOC).
3844 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3845 corresponding relocs are encountered during check_relocs.
3846 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3847 indicate the corresponding GOT entry type is not needed.
3848 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3849 a TPREL one. We use a separate flag rather than setting TPREL
3850 just for convenience in distinguishing the two cases. */
3851 #define TLS_GD 1 /* GD reloc. */
3852 #define TLS_LD 2 /* LD reloc. */
3853 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3854 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3855 #define TLS_TLS 16 /* Any TLS reloc. */
3856 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3857 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3858 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3859 unsigned char tls_mask;
3862 /* ppc64 ELF linker hash table. */
3864 struct ppc_link_hash_table
3866 struct elf_link_hash_table elf;
3868 /* The stub hash table. */
3869 struct bfd_hash_table stub_hash_table;
3871 /* Another hash table for plt_branch stubs. */
3872 struct bfd_hash_table branch_hash_table;
3874 /* Hash table for function prologue tocsave. */
3875 htab_t tocsave_htab;
3877 /* Linker stub bfd. */
3880 /* Linker call-backs. */
3881 asection * (*add_stub_section) (const char *, asection *);
3882 void (*layout_sections_again) (void);
3884 /* Array to keep track of which stub sections have been created, and
3885 information on stub grouping. */
3887 /* This is the section to which stubs in the group will be attached. */
3889 /* The stub section. */
3891 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3895 /* Temp used when calculating TOC pointers. */
3898 asection *toc_first_sec;
3900 /* Highest input section id. */
3903 /* Highest output section index. */
3906 /* Used when adding symbols. */
3907 struct ppc_link_hash_entry *dot_syms;
3909 /* List of input sections for each output section. */
3910 asection **input_list;
3912 /* Shortcuts to get to dynamic linker sections. */
3919 asection *glink_eh_frame;
3921 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3922 struct ppc_link_hash_entry *tls_get_addr;
3923 struct ppc_link_hash_entry *tls_get_addr_fd;
3925 /* The size of reliplt used by got entry relocs. */
3926 bfd_size_type got_reli_size;
3929 unsigned long stub_count[ppc_stub_plt_call_r2save];
3931 /* Number of stubs against global syms. */
3932 unsigned long stub_globals;
3934 /* Alignment of PLT call stubs. */
3935 unsigned int plt_stub_align:4;
3937 /* Set if we're linking code with function descriptors. */
3938 unsigned int opd_abi:1;
3940 /* Set if PLT call stubs should load r11. */
3941 unsigned int plt_static_chain:1;
3943 /* Set if PLT call stubs need a read-read barrier. */
3944 unsigned int plt_thread_safe:1;
3946 /* Set if we should emit symbols for stubs. */
3947 unsigned int emit_stub_syms:1;
3949 /* Set if __tls_get_addr optimization should not be done. */
3950 unsigned int no_tls_get_addr_opt:1;
3952 /* Support for multiple toc sections. */
3953 unsigned int do_multi_toc:1;
3954 unsigned int multi_toc_needed:1;
3955 unsigned int second_toc_pass:1;
3956 unsigned int do_toc_opt:1;
3959 unsigned int stub_error:1;
3961 /* Temp used by ppc64_elf_process_dot_syms. */
3962 unsigned int twiddled_syms:1;
3964 /* Incremented every time we size stubs. */
3965 unsigned int stub_iteration;
3967 /* Small local sym cache. */
3968 struct sym_cache sym_cache;
3971 /* Rename some of the generic section flags to better document how they
3974 /* Nonzero if this section has TLS related relocations. */
3975 #define has_tls_reloc sec_flg0
3977 /* Nonzero if this section has a call to __tls_get_addr. */
3978 #define has_tls_get_addr_call sec_flg1
3980 /* Nonzero if this section has any toc or got relocs. */
3981 #define has_toc_reloc sec_flg2
3983 /* Nonzero if this section has a call to another section that uses
3985 #define makes_toc_func_call sec_flg3
3987 /* Recursion protection when determining above flag. */
3988 #define call_check_in_progress sec_flg4
3989 #define call_check_done sec_flg5
3991 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3993 #define ppc_hash_table(p) \
3994 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3995 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3997 #define ppc_stub_hash_lookup(table, string, create, copy) \
3998 ((struct ppc_stub_hash_entry *) \
3999 bfd_hash_lookup ((table), (string), (create), (copy)))
4001 #define ppc_branch_hash_lookup(table, string, create, copy) \
4002 ((struct ppc_branch_hash_entry *) \
4003 bfd_hash_lookup ((table), (string), (create), (copy)))
4005 /* Create an entry in the stub hash table. */
4007 static struct bfd_hash_entry *
4008 stub_hash_newfunc (struct bfd_hash_entry *entry,
4009 struct bfd_hash_table *table,
4012 /* Allocate the structure if it has not already been allocated by a
4016 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4021 /* Call the allocation method of the superclass. */
4022 entry = bfd_hash_newfunc (entry, table, string);
4025 struct ppc_stub_hash_entry *eh;
4027 /* Initialize the local fields. */
4028 eh = (struct ppc_stub_hash_entry *) entry;
4029 eh->stub_type = ppc_stub_none;
4030 eh->stub_sec = NULL;
4031 eh->stub_offset = 0;
4032 eh->target_value = 0;
4033 eh->target_section = NULL;
4043 /* Create an entry in the branch hash table. */
4045 static struct bfd_hash_entry *
4046 branch_hash_newfunc (struct bfd_hash_entry *entry,
4047 struct bfd_hash_table *table,
4050 /* Allocate the structure if it has not already been allocated by a
4054 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4059 /* Call the allocation method of the superclass. */
4060 entry = bfd_hash_newfunc (entry, table, string);
4063 struct ppc_branch_hash_entry *eh;
4065 /* Initialize the local fields. */
4066 eh = (struct ppc_branch_hash_entry *) entry;
4074 /* Create an entry in a ppc64 ELF linker hash table. */
4076 static struct bfd_hash_entry *
4077 link_hash_newfunc (struct bfd_hash_entry *entry,
4078 struct bfd_hash_table *table,
4081 /* Allocate the structure if it has not already been allocated by a
4085 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4090 /* Call the allocation method of the superclass. */
4091 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4094 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4096 memset (&eh->u.stub_cache, 0,
4097 (sizeof (struct ppc_link_hash_entry)
4098 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4100 /* When making function calls, old ABI code references function entry
4101 points (dot symbols), while new ABI code references the function
4102 descriptor symbol. We need to make any combination of reference and
4103 definition work together, without breaking archive linking.
4105 For a defined function "foo" and an undefined call to "bar":
4106 An old object defines "foo" and ".foo", references ".bar" (possibly
4108 A new object defines "foo" and references "bar".
4110 A new object thus has no problem with its undefined symbols being
4111 satisfied by definitions in an old object. On the other hand, the
4112 old object won't have ".bar" satisfied by a new object.
4114 Keep a list of newly added dot-symbols. */
4116 if (string[0] == '.')
4118 struct ppc_link_hash_table *htab;
4120 htab = (struct ppc_link_hash_table *) table;
4121 eh->u.next_dot_sym = htab->dot_syms;
4122 htab->dot_syms = eh;
4129 struct tocsave_entry {
4135 tocsave_htab_hash (const void *p)
4137 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4138 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4142 tocsave_htab_eq (const void *p1, const void *p2)
4144 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4145 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4146 return e1->sec == e2->sec && e1->offset == e2->offset;
4149 /* Create a ppc64 ELF linker hash table. */
4151 static struct bfd_link_hash_table *
4152 ppc64_elf_link_hash_table_create (bfd *abfd)
4154 struct ppc_link_hash_table *htab;
4155 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4157 htab = bfd_zmalloc (amt);
4161 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4162 sizeof (struct ppc_link_hash_entry),
4169 /* Init the stub hash table too. */
4170 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4171 sizeof (struct ppc_stub_hash_entry)))
4174 /* And the branch hash table. */
4175 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4176 sizeof (struct ppc_branch_hash_entry)))
4179 htab->tocsave_htab = htab_try_create (1024,
4183 if (htab->tocsave_htab == NULL)
4186 /* Initializing two fields of the union is just cosmetic. We really
4187 only care about glist, but when compiled on a 32-bit host the
4188 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4189 debugger inspection of these fields look nicer. */
4190 htab->elf.init_got_refcount.refcount = 0;
4191 htab->elf.init_got_refcount.glist = NULL;
4192 htab->elf.init_plt_refcount.refcount = 0;
4193 htab->elf.init_plt_refcount.glist = NULL;
4194 htab->elf.init_got_offset.offset = 0;
4195 htab->elf.init_got_offset.glist = NULL;
4196 htab->elf.init_plt_offset.offset = 0;
4197 htab->elf.init_plt_offset.glist = NULL;
4199 return &htab->elf.root;
4202 /* Free the derived linker hash table. */
4205 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4207 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4209 bfd_hash_table_free (&htab->stub_hash_table);
4210 bfd_hash_table_free (&htab->branch_hash_table);
4211 if (htab->tocsave_htab)
4212 htab_delete (htab->tocsave_htab);
4213 _bfd_elf_link_hash_table_free (hash);
4216 /* Create sections for linker generated code. */
4219 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4221 struct ppc_link_hash_table *htab;
4224 htab = ppc_hash_table (info);
4226 /* Create .sfpr for code to save and restore fp regs. */
4227 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4228 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4229 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4231 if (htab->sfpr == NULL
4232 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4235 /* Create .glink for lazy dynamic linking support. */
4236 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4238 if (htab->glink == NULL
4239 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4242 if (!info->no_ld_generated_unwind_info)
4244 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4245 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4246 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4249 if (htab->glink_eh_frame == NULL
4250 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4254 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4255 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4256 if (htab->elf.iplt == NULL
4257 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4260 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4261 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4263 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4264 if (htab->elf.irelplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4268 /* Create branch lookup table for plt_branch stubs. */
4269 flags = (SEC_ALLOC | SEC_LOAD
4270 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4271 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4273 if (htab->brlt == NULL
4274 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4280 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4281 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4282 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4285 if (htab->relbrlt == NULL
4286 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4292 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4295 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4297 struct ppc_link_hash_table *htab;
4299 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4301 /* Always hook our dynamic sections into the first bfd, which is the
4302 linker created stub bfd. This ensures that the GOT header is at
4303 the start of the output TOC section. */
4304 htab = ppc_hash_table (info);
4307 htab->stub_bfd = abfd;
4308 htab->elf.dynobj = abfd;
4310 if (info->relocatable)
4313 return create_linkage_sections (htab->elf.dynobj, info);
4316 /* Build a name for an entry in the stub hash table. */
4319 ppc_stub_name (const asection *input_section,
4320 const asection *sym_sec,
4321 const struct ppc_link_hash_entry *h,
4322 const Elf_Internal_Rela *rel)
4327 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4328 offsets from a sym as a branch target? In fact, we could
4329 probably assume the addend is always zero. */
4330 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4334 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4335 stub_name = bfd_malloc (len);
4336 if (stub_name == NULL)
4339 len = sprintf (stub_name, "%08x.%s+%x",
4340 input_section->id & 0xffffffff,
4341 h->elf.root.root.string,
4342 (int) rel->r_addend & 0xffffffff);
4346 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4347 stub_name = bfd_malloc (len);
4348 if (stub_name == NULL)
4351 len = sprintf (stub_name, "%08x.%x:%x+%x",
4352 input_section->id & 0xffffffff,
4353 sym_sec->id & 0xffffffff,
4354 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4355 (int) rel->r_addend & 0xffffffff);
4357 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4358 stub_name[len - 2] = 0;
4362 /* Look up an entry in the stub hash. Stub entries are cached because
4363 creating the stub name takes a bit of time. */
4365 static struct ppc_stub_hash_entry *
4366 ppc_get_stub_entry (const asection *input_section,
4367 const asection *sym_sec,
4368 struct ppc_link_hash_entry *h,
4369 const Elf_Internal_Rela *rel,
4370 struct ppc_link_hash_table *htab)
4372 struct ppc_stub_hash_entry *stub_entry;
4373 const asection *id_sec;
4375 /* If this input section is part of a group of sections sharing one
4376 stub section, then use the id of the first section in the group.
4377 Stub names need to include a section id, as there may well be
4378 more than one stub used to reach say, printf, and we need to
4379 distinguish between them. */
4380 id_sec = htab->stub_group[input_section->id].link_sec;
4382 if (h != NULL && h->u.stub_cache != NULL
4383 && h->u.stub_cache->h == h
4384 && h->u.stub_cache->id_sec == id_sec)
4386 stub_entry = h->u.stub_cache;
4392 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4393 if (stub_name == NULL)
4396 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4397 stub_name, FALSE, FALSE);
4399 h->u.stub_cache = stub_entry;
4407 /* Add a new stub entry to the stub hash. Not all fields of the new
4408 stub entry are initialised. */
4410 static struct ppc_stub_hash_entry *
4411 ppc_add_stub (const char *stub_name,
4413 struct bfd_link_info *info)
4415 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4418 struct ppc_stub_hash_entry *stub_entry;
4420 link_sec = htab->stub_group[section->id].link_sec;
4421 stub_sec = htab->stub_group[section->id].stub_sec;
4422 if (stub_sec == NULL)
4424 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4425 if (stub_sec == NULL)
4431 namelen = strlen (link_sec->name);
4432 len = namelen + sizeof (STUB_SUFFIX);
4433 s_name = bfd_alloc (htab->stub_bfd, len);
4437 memcpy (s_name, link_sec->name, namelen);
4438 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4439 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4440 if (stub_sec == NULL)
4442 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4444 htab->stub_group[section->id].stub_sec = stub_sec;
4447 /* Enter this entry into the linker stub hash table. */
4448 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4450 if (stub_entry == NULL)
4452 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4453 section->owner, stub_name);
4457 stub_entry->stub_sec = stub_sec;
4458 stub_entry->stub_offset = 0;
4459 stub_entry->id_sec = link_sec;
4463 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4464 not already done. */
4467 create_got_section (bfd *abfd, struct bfd_link_info *info)
4469 asection *got, *relgot;
4471 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4473 if (!is_ppc64_elf (abfd))
4479 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4482 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4483 | SEC_LINKER_CREATED);
4485 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4487 || !bfd_set_section_alignment (abfd, got, 3))
4490 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4491 flags | SEC_READONLY);
4493 || ! bfd_set_section_alignment (abfd, relgot, 3))
4496 ppc64_elf_tdata (abfd)->got = got;
4497 ppc64_elf_tdata (abfd)->relgot = relgot;
4501 /* Create the dynamic sections, and set up shortcuts. */
4504 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4506 struct ppc_link_hash_table *htab;
4508 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4511 htab = ppc_hash_table (info);
4515 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4517 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4519 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4520 || (!info->shared && !htab->relbss))
4526 /* Follow indirect and warning symbol links. */
4528 static inline struct bfd_link_hash_entry *
4529 follow_link (struct bfd_link_hash_entry *h)
4531 while (h->type == bfd_link_hash_indirect
4532 || h->type == bfd_link_hash_warning)
4537 static inline struct elf_link_hash_entry *
4538 elf_follow_link (struct elf_link_hash_entry *h)
4540 return (struct elf_link_hash_entry *) follow_link (&h->root);
4543 static inline struct ppc_link_hash_entry *
4544 ppc_follow_link (struct ppc_link_hash_entry *h)
4546 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4549 /* Merge PLT info on FROM with that on TO. */
4552 move_plt_plist (struct ppc_link_hash_entry *from,
4553 struct ppc_link_hash_entry *to)
4555 if (from->elf.plt.plist != NULL)
4557 if (to->elf.plt.plist != NULL)
4559 struct plt_entry **entp;
4560 struct plt_entry *ent;
4562 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4564 struct plt_entry *dent;
4566 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4567 if (dent->addend == ent->addend)
4569 dent->plt.refcount += ent->plt.refcount;
4576 *entp = to->elf.plt.plist;
4579 to->elf.plt.plist = from->elf.plt.plist;
4580 from->elf.plt.plist = NULL;
4584 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4587 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4588 struct elf_link_hash_entry *dir,
4589 struct elf_link_hash_entry *ind)
4591 struct ppc_link_hash_entry *edir, *eind;
4593 edir = (struct ppc_link_hash_entry *) dir;
4594 eind = (struct ppc_link_hash_entry *) ind;
4596 edir->is_func |= eind->is_func;
4597 edir->is_func_descriptor |= eind->is_func_descriptor;
4598 edir->tls_mask |= eind->tls_mask;
4599 if (eind->oh != NULL)
4600 edir->oh = ppc_follow_link (eind->oh);
4602 /* If called to transfer flags for a weakdef during processing
4603 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4604 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4605 if (!(ELIMINATE_COPY_RELOCS
4606 && eind->elf.root.type != bfd_link_hash_indirect
4607 && edir->elf.dynamic_adjusted))
4608 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4610 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4611 edir->elf.ref_regular |= eind->elf.ref_regular;
4612 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4613 edir->elf.needs_plt |= eind->elf.needs_plt;
4614 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4616 /* Copy over any dynamic relocs we may have on the indirect sym. */
4617 if (eind->dyn_relocs != NULL)
4619 if (edir->dyn_relocs != NULL)
4621 struct elf_dyn_relocs **pp;
4622 struct elf_dyn_relocs *p;
4624 /* Add reloc counts against the indirect sym to the direct sym
4625 list. Merge any entries against the same section. */
4626 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4628 struct elf_dyn_relocs *q;
4630 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4631 if (q->sec == p->sec)
4633 q->pc_count += p->pc_count;
4634 q->count += p->count;
4641 *pp = edir->dyn_relocs;
4644 edir->dyn_relocs = eind->dyn_relocs;
4645 eind->dyn_relocs = NULL;
4648 /* If we were called to copy over info for a weak sym, that's all.
4649 You might think dyn_relocs need not be copied over; After all,
4650 both syms will be dynamic or both non-dynamic so we're just
4651 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4652 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4653 dyn_relocs in read-only sections, and it does so on what is the
4655 if (eind->elf.root.type != bfd_link_hash_indirect)
4658 /* Copy over got entries that we may have already seen to the
4659 symbol which just became indirect. */
4660 if (eind->elf.got.glist != NULL)
4662 if (edir->elf.got.glist != NULL)
4664 struct got_entry **entp;
4665 struct got_entry *ent;
4667 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4669 struct got_entry *dent;
4671 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4672 if (dent->addend == ent->addend
4673 && dent->owner == ent->owner
4674 && dent->tls_type == ent->tls_type)
4676 dent->got.refcount += ent->got.refcount;
4683 *entp = edir->elf.got.glist;
4686 edir->elf.got.glist = eind->elf.got.glist;
4687 eind->elf.got.glist = NULL;
4690 /* And plt entries. */
4691 move_plt_plist (eind, edir);
4693 if (eind->elf.dynindx != -1)
4695 if (edir->elf.dynindx != -1)
4696 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4697 edir->elf.dynstr_index);
4698 edir->elf.dynindx = eind->elf.dynindx;
4699 edir->elf.dynstr_index = eind->elf.dynstr_index;
4700 eind->elf.dynindx = -1;
4701 eind->elf.dynstr_index = 0;
4705 /* Find the function descriptor hash entry from the given function code
4706 hash entry FH. Link the entries via their OH fields. */
4708 static struct ppc_link_hash_entry *
4709 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4711 struct ppc_link_hash_entry *fdh = fh->oh;
4715 const char *fd_name = fh->elf.root.root.string + 1;
4717 fdh = (struct ppc_link_hash_entry *)
4718 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4722 fdh->is_func_descriptor = 1;
4728 return ppc_follow_link (fdh);
4731 /* Make a fake function descriptor sym for the code sym FH. */
4733 static struct ppc_link_hash_entry *
4734 make_fdh (struct bfd_link_info *info,
4735 struct ppc_link_hash_entry *fh)
4739 struct bfd_link_hash_entry *bh;
4740 struct ppc_link_hash_entry *fdh;
4742 abfd = fh->elf.root.u.undef.abfd;
4743 newsym = bfd_make_empty_symbol (abfd);
4744 newsym->name = fh->elf.root.root.string + 1;
4745 newsym->section = bfd_und_section_ptr;
4747 newsym->flags = BSF_WEAK;
4750 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4751 newsym->flags, newsym->section,
4752 newsym->value, NULL, FALSE, FALSE,
4756 fdh = (struct ppc_link_hash_entry *) bh;
4757 fdh->elf.non_elf = 0;
4759 fdh->is_func_descriptor = 1;
4766 /* Fix function descriptor symbols defined in .opd sections to be
4770 ppc64_elf_add_symbol_hook (bfd *ibfd,
4771 struct bfd_link_info *info,
4772 Elf_Internal_Sym *isym,
4774 flagword *flags ATTRIBUTE_UNUSED,
4776 bfd_vma *value ATTRIBUTE_UNUSED)
4778 if ((ibfd->flags & DYNAMIC) == 0
4779 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4780 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4782 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4784 if ((ibfd->flags & DYNAMIC) == 0)
4785 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4787 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4789 else if (*sec != NULL
4790 && strcmp ((*sec)->name, ".opd") == 0)
4791 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4793 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4795 if (abiversion (ibfd) == 0)
4796 set_abiversion (ibfd, 2);
4797 else if (abiversion (ibfd) == 1)
4799 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4800 " for ABI version 1\n"), name);
4801 bfd_set_error (bfd_error_bad_value);
4809 /* Merge non-visibility st_other attributes: local entry point. */
4812 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4813 const Elf_Internal_Sym *isym,
4814 bfd_boolean definition,
4815 bfd_boolean dynamic)
4817 if (definition && !dynamic)
4818 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4819 | ELF_ST_VISIBILITY (h->other));
4822 /* This function makes an old ABI object reference to ".bar" cause the
4823 inclusion of a new ABI object archive that defines "bar".
4824 NAME is a symbol defined in an archive. Return a symbol in the hash
4825 table that might be satisfied by the archive symbols. */
4827 static struct elf_link_hash_entry *
4828 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4829 struct bfd_link_info *info,
4832 struct elf_link_hash_entry *h;
4836 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4838 /* Don't return this sym if it is a fake function descriptor
4839 created by add_symbol_adjust. */
4840 && !(h->root.type == bfd_link_hash_undefweak
4841 && ((struct ppc_link_hash_entry *) h)->fake))
4847 len = strlen (name);
4848 dot_name = bfd_alloc (abfd, len + 2);
4849 if (dot_name == NULL)
4850 return (struct elf_link_hash_entry *) 0 - 1;
4852 memcpy (dot_name + 1, name, len + 1);
4853 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4854 bfd_release (abfd, dot_name);
4858 /* This function satisfies all old ABI object references to ".bar" if a
4859 new ABI object defines "bar". Well, at least, undefined dot symbols
4860 are made weak. This stops later archive searches from including an
4861 object if we already have a function descriptor definition. It also
4862 prevents the linker complaining about undefined symbols.
4863 We also check and correct mismatched symbol visibility here. The
4864 most restrictive visibility of the function descriptor and the
4865 function entry symbol is used. */
4868 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4870 struct ppc_link_hash_table *htab;
4871 struct ppc_link_hash_entry *fdh;
4873 if (eh->elf.root.type == bfd_link_hash_indirect)
4876 if (eh->elf.root.type == bfd_link_hash_warning)
4877 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4879 if (eh->elf.root.root.string[0] != '.')
4882 htab = ppc_hash_table (info);
4886 fdh = lookup_fdh (eh, htab);
4889 if (!info->relocatable
4890 && (eh->elf.root.type == bfd_link_hash_undefined
4891 || eh->elf.root.type == bfd_link_hash_undefweak)
4892 && eh->elf.ref_regular)
4894 /* Make an undefweak function descriptor sym, which is enough to
4895 pull in an --as-needed shared lib, but won't cause link
4896 errors. Archives are handled elsewhere. */
4897 fdh = make_fdh (info, eh);
4900 fdh->elf.ref_regular = 1;
4905 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4906 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4907 if (entry_vis < descr_vis)
4908 fdh->elf.other += entry_vis - descr_vis;
4909 else if (entry_vis > descr_vis)
4910 eh->elf.other += descr_vis - entry_vis;
4912 if ((fdh->elf.root.type == bfd_link_hash_defined
4913 || fdh->elf.root.type == bfd_link_hash_defweak)
4914 && eh->elf.root.type == bfd_link_hash_undefined)
4916 eh->elf.root.type = bfd_link_hash_undefweak;
4917 eh->was_undefined = 1;
4918 htab->twiddled_syms = 1;
4925 /* Process list of dot-symbols we made in link_hash_newfunc. */
4928 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4930 struct ppc_link_hash_table *htab;
4931 struct ppc_link_hash_entry **p, *eh;
4933 if (!is_ppc64_elf (info->output_bfd))
4935 htab = ppc_hash_table (info);
4939 if (is_ppc64_elf (ibfd))
4941 p = &htab->dot_syms;
4942 while ((eh = *p) != NULL)
4945 if (&eh->elf == htab->elf.hgot)
4947 else if (htab->elf.hgot == NULL
4948 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4949 htab->elf.hgot = &eh->elf;
4950 else if (!add_symbol_adjust (eh, info))
4952 p = &eh->u.next_dot_sym;
4956 /* Clear the list for non-ppc64 input files. */
4957 p = &htab->dot_syms;
4958 while ((eh = *p) != NULL)
4961 p = &eh->u.next_dot_sym;
4964 /* We need to fix the undefs list for any syms we have twiddled to
4966 if (htab->twiddled_syms)
4968 bfd_link_repair_undef_list (&htab->elf.root);
4969 htab->twiddled_syms = 0;
4974 /* Undo hash table changes when an --as-needed input file is determined
4975 not to be needed. */
4978 ppc64_elf_notice_as_needed (bfd *ibfd,
4979 struct bfd_link_info *info,
4980 enum notice_asneeded_action act)
4982 if (act == notice_not_needed)
4984 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4989 htab->dot_syms = NULL;
4991 return _bfd_elf_notice_as_needed (ibfd, info, act);
4994 /* If --just-symbols against a final linked binary, then assume we need
4995 toc adjusting stubs when calling functions defined there. */
4998 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5000 if ((sec->flags & SEC_CODE) != 0
5001 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5002 && is_ppc64_elf (sec->owner))
5004 if (abiversion (sec->owner) >= 2
5005 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5006 sec->has_toc_reloc = 1;
5008 _bfd_elf_link_just_syms (sec, info);
5011 static struct plt_entry **
5012 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5013 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5015 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5016 struct plt_entry **local_plt;
5017 unsigned char *local_got_tls_masks;
5019 if (local_got_ents == NULL)
5021 bfd_size_type size = symtab_hdr->sh_info;
5023 size *= (sizeof (*local_got_ents)
5024 + sizeof (*local_plt)
5025 + sizeof (*local_got_tls_masks));
5026 local_got_ents = bfd_zalloc (abfd, size);
5027 if (local_got_ents == NULL)
5029 elf_local_got_ents (abfd) = local_got_ents;
5032 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5034 struct got_entry *ent;
5036 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5037 if (ent->addend == r_addend
5038 && ent->owner == abfd
5039 && ent->tls_type == tls_type)
5043 bfd_size_type amt = sizeof (*ent);
5044 ent = bfd_alloc (abfd, amt);
5047 ent->next = local_got_ents[r_symndx];
5048 ent->addend = r_addend;
5050 ent->tls_type = tls_type;
5051 ent->is_indirect = FALSE;
5052 ent->got.refcount = 0;
5053 local_got_ents[r_symndx] = ent;
5055 ent->got.refcount += 1;
5058 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5059 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5060 local_got_tls_masks[r_symndx] |= tls_type;
5062 return local_plt + r_symndx;
5066 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5068 struct plt_entry *ent;
5070 for (ent = *plist; ent != NULL; ent = ent->next)
5071 if (ent->addend == addend)
5075 bfd_size_type amt = sizeof (*ent);
5076 ent = bfd_alloc (abfd, amt);
5080 ent->addend = addend;
5081 ent->plt.refcount = 0;
5084 ent->plt.refcount += 1;
5089 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5091 return (r_type == R_PPC64_REL24
5092 || r_type == R_PPC64_REL14
5093 || r_type == R_PPC64_REL14_BRTAKEN
5094 || r_type == R_PPC64_REL14_BRNTAKEN
5095 || r_type == R_PPC64_ADDR24
5096 || r_type == R_PPC64_ADDR14
5097 || r_type == R_PPC64_ADDR14_BRTAKEN
5098 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5101 /* Look through the relocs for a section during the first phase, and
5102 calculate needed space in the global offset table, procedure
5103 linkage table, and dynamic reloc sections. */
5106 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5107 asection *sec, const Elf_Internal_Rela *relocs)
5109 struct ppc_link_hash_table *htab;
5110 Elf_Internal_Shdr *symtab_hdr;
5111 struct elf_link_hash_entry **sym_hashes;
5112 const Elf_Internal_Rela *rel;
5113 const Elf_Internal_Rela *rel_end;
5115 asection **opd_sym_map;
5116 struct elf_link_hash_entry *tga, *dottga;
5118 if (info->relocatable)
5121 /* Don't do anything special with non-loaded, non-alloced sections.
5122 In particular, any relocs in such sections should not affect GOT
5123 and PLT reference counting (ie. we don't allow them to create GOT
5124 or PLT entries), there's no possibility or desire to optimize TLS
5125 relocs, and there's not much point in propagating relocs to shared
5126 libs that the dynamic linker won't relocate. */
5127 if ((sec->flags & SEC_ALLOC) == 0)
5130 BFD_ASSERT (is_ppc64_elf (abfd));
5132 htab = ppc_hash_table (info);
5136 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5137 FALSE, FALSE, TRUE);
5138 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5139 FALSE, FALSE, TRUE);
5140 symtab_hdr = &elf_symtab_hdr (abfd);
5141 sym_hashes = elf_sym_hashes (abfd);
5144 if (strcmp (sec->name, ".opd") == 0)
5146 /* Garbage collection needs some extra help with .opd sections.
5147 We don't want to necessarily keep everything referenced by
5148 relocs in .opd, as that would keep all functions. Instead,
5149 if we reference an .opd symbol (a function descriptor), we
5150 want to keep the function code symbol's section. This is
5151 easy for global symbols, but for local syms we need to keep
5152 information about the associated function section. */
5155 if (abiversion (abfd) == 0)
5156 set_abiversion (abfd, 1);
5157 else if (abiversion (abfd) == 2)
5159 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5161 bfd_set_error (bfd_error_bad_value);
5164 amt = sec->size * sizeof (*opd_sym_map) / 8;
5165 opd_sym_map = bfd_zalloc (abfd, amt);
5166 if (opd_sym_map == NULL)
5168 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5169 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5170 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5173 rel_end = relocs + sec->reloc_count;
5174 for (rel = relocs; rel < rel_end; rel++)
5176 unsigned long r_symndx;
5177 struct elf_link_hash_entry *h;
5178 enum elf_ppc64_reloc_type r_type;
5180 struct _ppc64_elf_section_data *ppc64_sec;
5181 struct plt_entry **ifunc;
5183 r_symndx = ELF64_R_SYM (rel->r_info);
5184 if (r_symndx < symtab_hdr->sh_info)
5188 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5189 h = elf_follow_link (h);
5191 /* PR15323, ref flags aren't set for references in the same
5193 h->root.non_ir_ref = 1;
5195 if (h == htab->elf.hgot)
5196 sec->has_toc_reloc = 1;
5203 if (h->type == STT_GNU_IFUNC)
5206 ifunc = &h->plt.plist;
5211 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5216 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5218 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5219 rel->r_addend, PLT_IFUNC);
5224 r_type = ELF64_R_TYPE (rel->r_info);
5225 if (is_branch_reloc (r_type))
5227 if (h != NULL && (h == tga || h == dottga))
5230 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5231 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5232 /* We have a new-style __tls_get_addr call with a marker
5236 /* Mark this section as having an old-style call. */
5237 sec->has_tls_get_addr_call = 1;
5240 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5242 && !update_plt_info (abfd, ifunc, rel->r_addend))
5250 /* These special tls relocs tie a call to __tls_get_addr with
5251 its parameter symbol. */
5254 case R_PPC64_GOT_TLSLD16:
5255 case R_PPC64_GOT_TLSLD16_LO:
5256 case R_PPC64_GOT_TLSLD16_HI:
5257 case R_PPC64_GOT_TLSLD16_HA:
5258 tls_type = TLS_TLS | TLS_LD;
5261 case R_PPC64_GOT_TLSGD16:
5262 case R_PPC64_GOT_TLSGD16_LO:
5263 case R_PPC64_GOT_TLSGD16_HI:
5264 case R_PPC64_GOT_TLSGD16_HA:
5265 tls_type = TLS_TLS | TLS_GD;
5268 case R_PPC64_GOT_TPREL16_DS:
5269 case R_PPC64_GOT_TPREL16_LO_DS:
5270 case R_PPC64_GOT_TPREL16_HI:
5271 case R_PPC64_GOT_TPREL16_HA:
5272 if (!info->executable)
5273 info->flags |= DF_STATIC_TLS;
5274 tls_type = TLS_TLS | TLS_TPREL;
5277 case R_PPC64_GOT_DTPREL16_DS:
5278 case R_PPC64_GOT_DTPREL16_LO_DS:
5279 case R_PPC64_GOT_DTPREL16_HI:
5280 case R_PPC64_GOT_DTPREL16_HA:
5281 tls_type = TLS_TLS | TLS_DTPREL;
5283 sec->has_tls_reloc = 1;
5287 case R_PPC64_GOT16_DS:
5288 case R_PPC64_GOT16_HA:
5289 case R_PPC64_GOT16_HI:
5290 case R_PPC64_GOT16_LO:
5291 case R_PPC64_GOT16_LO_DS:
5292 /* This symbol requires a global offset table entry. */
5293 sec->has_toc_reloc = 1;
5294 if (r_type == R_PPC64_GOT_TLSLD16
5295 || r_type == R_PPC64_GOT_TLSGD16
5296 || r_type == R_PPC64_GOT_TPREL16_DS
5297 || r_type == R_PPC64_GOT_DTPREL16_DS
5298 || r_type == R_PPC64_GOT16
5299 || r_type == R_PPC64_GOT16_DS)
5301 htab->do_multi_toc = 1;
5302 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5305 if (ppc64_elf_tdata (abfd)->got == NULL
5306 && !create_got_section (abfd, info))
5311 struct ppc_link_hash_entry *eh;
5312 struct got_entry *ent;
5314 eh = (struct ppc_link_hash_entry *) h;
5315 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5316 if (ent->addend == rel->r_addend
5317 && ent->owner == abfd
5318 && ent->tls_type == tls_type)
5322 bfd_size_type amt = sizeof (*ent);
5323 ent = bfd_alloc (abfd, amt);
5326 ent->next = eh->elf.got.glist;
5327 ent->addend = rel->r_addend;
5329 ent->tls_type = tls_type;
5330 ent->is_indirect = FALSE;
5331 ent->got.refcount = 0;
5332 eh->elf.got.glist = ent;
5334 ent->got.refcount += 1;
5335 eh->tls_mask |= tls_type;
5338 /* This is a global offset table entry for a local symbol. */
5339 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5340 rel->r_addend, tls_type))
5343 /* We may also need a plt entry if the symbol turns out to be
5345 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5347 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5352 case R_PPC64_PLT16_HA:
5353 case R_PPC64_PLT16_HI:
5354 case R_PPC64_PLT16_LO:
5357 /* This symbol requires a procedure linkage table entry. We
5358 actually build the entry in adjust_dynamic_symbol,
5359 because this might be a case of linking PIC code without
5360 linking in any dynamic objects, in which case we don't
5361 need to generate a procedure linkage table after all. */
5364 /* It does not make sense to have a procedure linkage
5365 table entry for a local symbol. */
5366 bfd_set_error (bfd_error_bad_value);
5371 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5374 if (h->root.root.string[0] == '.'
5375 && h->root.root.string[1] != '\0')
5376 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5380 /* The following relocations don't need to propagate the
5381 relocation if linking a shared object since they are
5382 section relative. */
5383 case R_PPC64_SECTOFF:
5384 case R_PPC64_SECTOFF_LO:
5385 case R_PPC64_SECTOFF_HI:
5386 case R_PPC64_SECTOFF_HA:
5387 case R_PPC64_SECTOFF_DS:
5388 case R_PPC64_SECTOFF_LO_DS:
5389 case R_PPC64_DTPREL16:
5390 case R_PPC64_DTPREL16_LO:
5391 case R_PPC64_DTPREL16_HI:
5392 case R_PPC64_DTPREL16_HA:
5393 case R_PPC64_DTPREL16_DS:
5394 case R_PPC64_DTPREL16_LO_DS:
5395 case R_PPC64_DTPREL16_HIGH:
5396 case R_PPC64_DTPREL16_HIGHA:
5397 case R_PPC64_DTPREL16_HIGHER:
5398 case R_PPC64_DTPREL16_HIGHERA:
5399 case R_PPC64_DTPREL16_HIGHEST:
5400 case R_PPC64_DTPREL16_HIGHESTA:
5405 case R_PPC64_REL16_LO:
5406 case R_PPC64_REL16_HI:
5407 case R_PPC64_REL16_HA:
5411 case R_PPC64_TOC16_DS:
5412 htab->do_multi_toc = 1;
5413 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5414 case R_PPC64_TOC16_LO:
5415 case R_PPC64_TOC16_HI:
5416 case R_PPC64_TOC16_HA:
5417 case R_PPC64_TOC16_LO_DS:
5418 sec->has_toc_reloc = 1;
5421 /* This relocation describes the C++ object vtable hierarchy.
5422 Reconstruct it for later use during GC. */
5423 case R_PPC64_GNU_VTINHERIT:
5424 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5428 /* This relocation describes which C++ vtable entries are actually
5429 used. Record for later use during GC. */
5430 case R_PPC64_GNU_VTENTRY:
5431 BFD_ASSERT (h != NULL);
5433 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5438 case R_PPC64_REL14_BRTAKEN:
5439 case R_PPC64_REL14_BRNTAKEN:
5441 asection *dest = NULL;
5443 /* Heuristic: If jumping outside our section, chances are
5444 we are going to need a stub. */
5447 /* If the sym is weak it may be overridden later, so
5448 don't assume we know where a weak sym lives. */
5449 if (h->root.type == bfd_link_hash_defined)
5450 dest = h->root.u.def.section;
5454 Elf_Internal_Sym *isym;
5456 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5461 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5465 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5470 if (h != NULL && ifunc == NULL)
5472 /* We may need a .plt entry if the function this reloc
5473 refers to is in a shared lib. */
5474 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5477 if (h->root.root.string[0] == '.'
5478 && h->root.root.string[1] != '\0')
5479 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5480 if (h == tga || h == dottga)
5481 sec->has_tls_reloc = 1;
5485 case R_PPC64_TPREL64:
5486 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5487 if (!info->executable)
5488 info->flags |= DF_STATIC_TLS;
5491 case R_PPC64_DTPMOD64:
5492 if (rel + 1 < rel_end
5493 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5494 && rel[1].r_offset == rel->r_offset + 8)
5495 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5497 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5500 case R_PPC64_DTPREL64:
5501 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5503 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5504 && rel[-1].r_offset == rel->r_offset - 8)
5505 /* This is the second reloc of a dtpmod, dtprel pair.
5506 Don't mark with TLS_DTPREL. */
5510 sec->has_tls_reloc = 1;
5513 struct ppc_link_hash_entry *eh;
5514 eh = (struct ppc_link_hash_entry *) h;
5515 eh->tls_mask |= tls_type;
5518 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5519 rel->r_addend, tls_type))
5522 ppc64_sec = ppc64_elf_section_data (sec);
5523 if (ppc64_sec->sec_type != sec_toc)
5527 /* One extra to simplify get_tls_mask. */
5528 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5529 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5530 if (ppc64_sec->u.toc.symndx == NULL)
5532 amt = sec->size * sizeof (bfd_vma) / 8;
5533 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5534 if (ppc64_sec->u.toc.add == NULL)
5536 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5537 ppc64_sec->sec_type = sec_toc;
5539 BFD_ASSERT (rel->r_offset % 8 == 0);
5540 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5541 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5543 /* Mark the second slot of a GD or LD entry.
5544 -1 to indicate GD and -2 to indicate LD. */
5545 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5546 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5547 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5548 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5551 case R_PPC64_TPREL16:
5552 case R_PPC64_TPREL16_LO:
5553 case R_PPC64_TPREL16_HI:
5554 case R_PPC64_TPREL16_HA:
5555 case R_PPC64_TPREL16_DS:
5556 case R_PPC64_TPREL16_LO_DS:
5557 case R_PPC64_TPREL16_HIGH:
5558 case R_PPC64_TPREL16_HIGHA:
5559 case R_PPC64_TPREL16_HIGHER:
5560 case R_PPC64_TPREL16_HIGHERA:
5561 case R_PPC64_TPREL16_HIGHEST:
5562 case R_PPC64_TPREL16_HIGHESTA:
5565 if (!info->executable)
5566 info->flags |= DF_STATIC_TLS;
5571 case R_PPC64_ADDR64:
5572 if (opd_sym_map != NULL
5573 && rel + 1 < rel_end
5574 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5578 if (h->root.root.string[0] == '.'
5579 && h->root.root.string[1] != 0
5580 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5583 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5588 Elf_Internal_Sym *isym;
5590 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5595 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5596 if (s != NULL && s != sec)
5597 opd_sym_map[rel->r_offset / 8] = s;
5602 case R_PPC64_ADDR16:
5603 case R_PPC64_ADDR16_DS:
5604 case R_PPC64_ADDR16_HA:
5605 case R_PPC64_ADDR16_HI:
5606 case R_PPC64_ADDR16_HIGH:
5607 case R_PPC64_ADDR16_HIGHA:
5608 case R_PPC64_ADDR16_HIGHER:
5609 case R_PPC64_ADDR16_HIGHERA:
5610 case R_PPC64_ADDR16_HIGHEST:
5611 case R_PPC64_ADDR16_HIGHESTA:
5612 case R_PPC64_ADDR16_LO:
5613 case R_PPC64_ADDR16_LO_DS:
5614 if (h != NULL && !info->shared && abiversion (abfd) == 2
5615 && rel->r_addend == 0)
5617 /* We may need a .plt entry if this reloc refers to a
5618 function in a shared lib. */
5619 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5621 h->pointer_equality_needed = 1;
5628 case R_PPC64_ADDR14:
5629 case R_PPC64_ADDR14_BRNTAKEN:
5630 case R_PPC64_ADDR14_BRTAKEN:
5631 case R_PPC64_ADDR24:
5632 case R_PPC64_ADDR32:
5633 case R_PPC64_UADDR16:
5634 case R_PPC64_UADDR32:
5635 case R_PPC64_UADDR64:
5637 if (h != NULL && !info->shared)
5638 /* We may need a copy reloc. */
5641 /* Don't propagate .opd relocs. */
5642 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5645 /* If we are creating a shared library, and this is a reloc
5646 against a global symbol, or a non PC relative reloc
5647 against a local symbol, then we need to copy the reloc
5648 into the shared library. However, if we are linking with
5649 -Bsymbolic, we do not need to copy a reloc against a
5650 global symbol which is defined in an object we are
5651 including in the link (i.e., DEF_REGULAR is set). At
5652 this point we have not seen all the input files, so it is
5653 possible that DEF_REGULAR is not set now but will be set
5654 later (it is never cleared). In case of a weak definition,
5655 DEF_REGULAR may be cleared later by a strong definition in
5656 a shared library. We account for that possibility below by
5657 storing information in the dyn_relocs field of the hash
5658 table entry. A similar situation occurs when creating
5659 shared libraries and symbol visibility changes render the
5662 If on the other hand, we are creating an executable, we
5663 may need to keep relocations for symbols satisfied by a
5664 dynamic library if we manage to avoid copy relocs for the
5668 && (must_be_dyn_reloc (info, r_type)
5670 && (!SYMBOLIC_BIND (info, h)
5671 || h->root.type == bfd_link_hash_defweak
5672 || !h->def_regular))))
5673 || (ELIMINATE_COPY_RELOCS
5676 && (h->root.type == bfd_link_hash_defweak
5677 || !h->def_regular))
5681 /* We must copy these reloc types into the output file.
5682 Create a reloc section in dynobj and make room for
5686 sreloc = _bfd_elf_make_dynamic_reloc_section
5687 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5693 /* If this is a global symbol, we count the number of
5694 relocations we need for this symbol. */
5697 struct elf_dyn_relocs *p;
5698 struct elf_dyn_relocs **head;
5700 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5702 if (p == NULL || p->sec != sec)
5704 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5714 if (!must_be_dyn_reloc (info, r_type))
5719 /* Track dynamic relocs needed for local syms too.
5720 We really need local syms available to do this
5722 struct ppc_dyn_relocs *p;
5723 struct ppc_dyn_relocs **head;
5724 bfd_boolean is_ifunc;
5727 Elf_Internal_Sym *isym;
5729 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5734 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5738 vpp = &elf_section_data (s)->local_dynrel;
5739 head = (struct ppc_dyn_relocs **) vpp;
5740 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5742 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5744 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5746 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5752 p->ifunc = is_ifunc;
5768 /* Merge backend specific data from an object file to the output
5769 object file when linking. */
5772 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5774 unsigned long iflags, oflags;
5776 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5779 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5782 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5785 iflags = elf_elfheader (ibfd)->e_flags;
5786 oflags = elf_elfheader (obfd)->e_flags;
5788 if (!elf_flags_init (obfd) || oflags == 0)
5790 elf_flags_init (obfd) = TRUE;
5791 elf_elfheader (obfd)->e_flags = iflags;
5793 else if (iflags == oflags || iflags == 0)
5795 else if (iflags & ~EF_PPC64_ABI)
5797 (*_bfd_error_handler)
5798 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5799 bfd_set_error (bfd_error_bad_value);
5804 (*_bfd_error_handler)
5805 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5806 ibfd, iflags, oflags);
5807 bfd_set_error (bfd_error_bad_value);
5811 /* Merge Tag_compatibility attributes and any common GNU ones. */
5812 _bfd_elf_merge_object_attributes (ibfd, obfd);
5818 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5820 /* Print normal ELF private data. */
5821 _bfd_elf_print_private_bfd_data (abfd, ptr);
5823 if (elf_elfheader (abfd)->e_flags != 0)
5827 /* xgettext:c-format */
5828 fprintf (file, _("private flags = 0x%lx:"),
5829 elf_elfheader (abfd)->e_flags);
5831 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5832 fprintf (file, _(" [abiv%ld]"),
5833 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5840 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5841 of the code entry point, and its section. */
5844 opd_entry_value (asection *opd_sec,
5846 asection **code_sec,
5848 bfd_boolean in_code_sec)
5850 bfd *opd_bfd = opd_sec->owner;
5851 Elf_Internal_Rela *relocs;
5852 Elf_Internal_Rela *lo, *hi, *look;
5855 /* No relocs implies we are linking a --just-symbols object, or looking
5856 at a final linked executable with addr2line or somesuch. */
5857 if (opd_sec->reloc_count == 0)
5859 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5861 if (contents == NULL)
5863 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5864 return (bfd_vma) -1;
5865 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5868 val = bfd_get_64 (opd_bfd, contents + offset);
5869 if (code_sec != NULL)
5871 asection *sec, *likely = NULL;
5877 && val < sec->vma + sec->size)
5883 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5885 && (sec->flags & SEC_LOAD) != 0
5886 && (sec->flags & SEC_ALLOC) != 0)
5891 if (code_off != NULL)
5892 *code_off = val - likely->vma;
5898 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5900 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5902 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5904 /* Go find the opd reloc at the sym address. */
5906 BFD_ASSERT (lo != NULL);
5907 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5911 look = lo + (hi - lo) / 2;
5912 if (look->r_offset < offset)
5914 else if (look->r_offset > offset)
5918 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5920 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5921 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5923 unsigned long symndx = ELF64_R_SYM (look->r_info);
5926 if (symndx < symtab_hdr->sh_info
5927 || elf_sym_hashes (opd_bfd) == NULL)
5929 Elf_Internal_Sym *sym;
5931 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5934 size_t symcnt = symtab_hdr->sh_info;
5935 if (elf_sym_hashes (opd_bfd) == NULL)
5936 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5937 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5938 0, NULL, NULL, NULL);
5941 symtab_hdr->contents = (bfd_byte *) sym;
5945 val = sym->st_value;
5946 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5947 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5951 struct elf_link_hash_entry **sym_hashes;
5952 struct elf_link_hash_entry *rh;
5954 sym_hashes = elf_sym_hashes (opd_bfd);
5955 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5958 rh = elf_follow_link (rh);
5959 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5960 || rh->root.type == bfd_link_hash_defweak);
5961 val = rh->root.u.def.value;
5962 sec = rh->root.u.def.section;
5966 /* Handle the odd case where we can be called
5967 during bfd_elf_link_add_symbols before the
5968 symbol hashes have been fully populated. */
5969 Elf_Internal_Sym *sym;
5971 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5972 symndx, NULL, NULL, NULL);
5976 val = sym->st_value;
5977 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5981 val += look->r_addend;
5982 if (code_off != NULL)
5984 if (code_sec != NULL)
5986 if (in_code_sec && *code_sec != sec)
5991 if (sec != NULL && sec->output_section != NULL)
5992 val += sec->output_section->vma + sec->output_offset;
6001 /* If the ELF symbol SYM might be a function in SEC, return the
6002 function size and set *CODE_OFF to the function's entry point,
6003 otherwise return zero. */
6005 static bfd_size_type
6006 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6011 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6012 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6016 if (!(sym->flags & BSF_SYNTHETIC))
6017 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6019 if (strcmp (sym->section->name, ".opd") == 0)
6021 if (opd_entry_value (sym->section, sym->value,
6022 &sec, code_off, TRUE) == (bfd_vma) -1)
6024 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6025 symbol. This size has nothing to do with the code size of the
6026 function, which is what we're supposed to return, but the
6027 code size isn't available without looking up the dot-sym.
6028 However, doing that would be a waste of time particularly
6029 since elf_find_function will look at the dot-sym anyway.
6030 Now, elf_find_function will keep the largest size of any
6031 function sym found at the code address of interest, so return
6032 1 here to avoid it incorrectly caching a larger function size
6033 for a small function. This does mean we return the wrong
6034 size for a new-ABI function of size 24, but all that does is
6035 disable caching for such functions. */
6041 if (sym->section != sec)
6043 *code_off = sym->value;
6050 /* Return true if symbol is defined in a regular object file. */
6053 is_static_defined (struct elf_link_hash_entry *h)
6055 return ((h->root.type == bfd_link_hash_defined
6056 || h->root.type == bfd_link_hash_defweak)
6057 && h->root.u.def.section != NULL
6058 && h->root.u.def.section->output_section != NULL);
6061 /* If FDH is a function descriptor symbol, return the associated code
6062 entry symbol if it is defined. Return NULL otherwise. */
6064 static struct ppc_link_hash_entry *
6065 defined_code_entry (struct ppc_link_hash_entry *fdh)
6067 if (fdh->is_func_descriptor)
6069 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6070 if (fh->elf.root.type == bfd_link_hash_defined
6071 || fh->elf.root.type == bfd_link_hash_defweak)
6077 /* If FH is a function code entry symbol, return the associated
6078 function descriptor symbol if it is defined. Return NULL otherwise. */
6080 static struct ppc_link_hash_entry *
6081 defined_func_desc (struct ppc_link_hash_entry *fh)
6084 && fh->oh->is_func_descriptor)
6086 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6087 if (fdh->elf.root.type == bfd_link_hash_defined
6088 || fdh->elf.root.type == bfd_link_hash_defweak)
6094 /* Mark all our entry sym sections, both opd and code section. */
6097 ppc64_elf_gc_keep (struct bfd_link_info *info)
6099 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6100 struct bfd_sym_chain *sym;
6105 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6107 struct ppc_link_hash_entry *eh, *fh;
6110 eh = (struct ppc_link_hash_entry *)
6111 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6114 if (eh->elf.root.type != bfd_link_hash_defined
6115 && eh->elf.root.type != bfd_link_hash_defweak)
6118 fh = defined_code_entry (eh);
6121 sec = fh->elf.root.u.def.section;
6122 sec->flags |= SEC_KEEP;
6124 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6125 && opd_entry_value (eh->elf.root.u.def.section,
6126 eh->elf.root.u.def.value,
6127 &sec, NULL, FALSE) != (bfd_vma) -1)
6128 sec->flags |= SEC_KEEP;
6130 sec = eh->elf.root.u.def.section;
6131 sec->flags |= SEC_KEEP;
6135 /* Mark sections containing dynamically referenced symbols. When
6136 building shared libraries, we must assume that any visible symbol is
6140 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6142 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6143 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6144 struct ppc_link_hash_entry *fdh;
6146 /* Dynamic linking info is on the func descriptor sym. */
6147 fdh = defined_func_desc (eh);
6151 if ((eh->elf.root.type == bfd_link_hash_defined
6152 || eh->elf.root.type == bfd_link_hash_defweak)
6153 && (eh->elf.ref_dynamic
6154 || (!info->executable
6155 && eh->elf.def_regular
6156 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6157 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6158 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6159 || !bfd_hide_sym_by_version (info->version_info,
6160 eh->elf.root.root.string)))))
6163 struct ppc_link_hash_entry *fh;
6165 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6167 /* Function descriptor syms cause the associated
6168 function code sym section to be marked. */
6169 fh = defined_code_entry (eh);
6172 code_sec = fh->elf.root.u.def.section;
6173 code_sec->flags |= SEC_KEEP;
6175 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6176 && opd_entry_value (eh->elf.root.u.def.section,
6177 eh->elf.root.u.def.value,
6178 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6179 code_sec->flags |= SEC_KEEP;
6185 /* Return the section that should be marked against GC for a given
6189 ppc64_elf_gc_mark_hook (asection *sec,
6190 struct bfd_link_info *info,
6191 Elf_Internal_Rela *rel,
6192 struct elf_link_hash_entry *h,
6193 Elf_Internal_Sym *sym)
6197 /* Syms return NULL if we're marking .opd, so we avoid marking all
6198 function sections, as all functions are referenced in .opd. */
6200 if (get_opd_info (sec) != NULL)
6205 enum elf_ppc64_reloc_type r_type;
6206 struct ppc_link_hash_entry *eh, *fh, *fdh;
6208 r_type = ELF64_R_TYPE (rel->r_info);
6211 case R_PPC64_GNU_VTINHERIT:
6212 case R_PPC64_GNU_VTENTRY:
6216 switch (h->root.type)
6218 case bfd_link_hash_defined:
6219 case bfd_link_hash_defweak:
6220 eh = (struct ppc_link_hash_entry *) h;
6221 fdh = defined_func_desc (eh);
6225 /* Function descriptor syms cause the associated
6226 function code sym section to be marked. */
6227 fh = defined_code_entry (eh);
6230 /* They also mark their opd section. */
6231 eh->elf.root.u.def.section->gc_mark = 1;
6233 rsec = fh->elf.root.u.def.section;
6235 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6236 && opd_entry_value (eh->elf.root.u.def.section,
6237 eh->elf.root.u.def.value,
6238 &rsec, NULL, FALSE) != (bfd_vma) -1)
6239 eh->elf.root.u.def.section->gc_mark = 1;
6241 rsec = h->root.u.def.section;
6244 case bfd_link_hash_common:
6245 rsec = h->root.u.c.p->section;
6249 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6255 struct _opd_sec_data *opd;
6257 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6258 opd = get_opd_info (rsec);
6259 if (opd != NULL && opd->func_sec != NULL)
6263 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6270 /* Update the .got, .plt. and dynamic reloc reference counts for the
6271 section being removed. */
6274 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6275 asection *sec, const Elf_Internal_Rela *relocs)
6277 struct ppc_link_hash_table *htab;
6278 Elf_Internal_Shdr *symtab_hdr;
6279 struct elf_link_hash_entry **sym_hashes;
6280 struct got_entry **local_got_ents;
6281 const Elf_Internal_Rela *rel, *relend;
6283 if (info->relocatable)
6286 if ((sec->flags & SEC_ALLOC) == 0)
6289 elf_section_data (sec)->local_dynrel = NULL;
6291 htab = ppc_hash_table (info);
6295 symtab_hdr = &elf_symtab_hdr (abfd);
6296 sym_hashes = elf_sym_hashes (abfd);
6297 local_got_ents = elf_local_got_ents (abfd);
6299 relend = relocs + sec->reloc_count;
6300 for (rel = relocs; rel < relend; rel++)
6302 unsigned long r_symndx;
6303 enum elf_ppc64_reloc_type r_type;
6304 struct elf_link_hash_entry *h = NULL;
6305 unsigned char tls_type = 0;
6307 r_symndx = ELF64_R_SYM (rel->r_info);
6308 r_type = ELF64_R_TYPE (rel->r_info);
6309 if (r_symndx >= symtab_hdr->sh_info)
6311 struct ppc_link_hash_entry *eh;
6312 struct elf_dyn_relocs **pp;
6313 struct elf_dyn_relocs *p;
6315 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6316 h = elf_follow_link (h);
6317 eh = (struct ppc_link_hash_entry *) h;
6319 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6322 /* Everything must go for SEC. */
6328 if (is_branch_reloc (r_type))
6330 struct plt_entry **ifunc = NULL;
6333 if (h->type == STT_GNU_IFUNC)
6334 ifunc = &h->plt.plist;
6336 else if (local_got_ents != NULL)
6338 struct plt_entry **local_plt = (struct plt_entry **)
6339 (local_got_ents + symtab_hdr->sh_info);
6340 unsigned char *local_got_tls_masks = (unsigned char *)
6341 (local_plt + symtab_hdr->sh_info);
6342 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6343 ifunc = local_plt + r_symndx;
6347 struct plt_entry *ent;
6349 for (ent = *ifunc; ent != NULL; ent = ent->next)
6350 if (ent->addend == rel->r_addend)
6354 if (ent->plt.refcount > 0)
6355 ent->plt.refcount -= 1;
6362 case R_PPC64_GOT_TLSLD16:
6363 case R_PPC64_GOT_TLSLD16_LO:
6364 case R_PPC64_GOT_TLSLD16_HI:
6365 case R_PPC64_GOT_TLSLD16_HA:
6366 tls_type = TLS_TLS | TLS_LD;
6369 case R_PPC64_GOT_TLSGD16:
6370 case R_PPC64_GOT_TLSGD16_LO:
6371 case R_PPC64_GOT_TLSGD16_HI:
6372 case R_PPC64_GOT_TLSGD16_HA:
6373 tls_type = TLS_TLS | TLS_GD;
6376 case R_PPC64_GOT_TPREL16_DS:
6377 case R_PPC64_GOT_TPREL16_LO_DS:
6378 case R_PPC64_GOT_TPREL16_HI:
6379 case R_PPC64_GOT_TPREL16_HA:
6380 tls_type = TLS_TLS | TLS_TPREL;
6383 case R_PPC64_GOT_DTPREL16_DS:
6384 case R_PPC64_GOT_DTPREL16_LO_DS:
6385 case R_PPC64_GOT_DTPREL16_HI:
6386 case R_PPC64_GOT_DTPREL16_HA:
6387 tls_type = TLS_TLS | TLS_DTPREL;
6391 case R_PPC64_GOT16_DS:
6392 case R_PPC64_GOT16_HA:
6393 case R_PPC64_GOT16_HI:
6394 case R_PPC64_GOT16_LO:
6395 case R_PPC64_GOT16_LO_DS:
6398 struct got_entry *ent;
6403 ent = local_got_ents[r_symndx];
6405 for (; ent != NULL; ent = ent->next)
6406 if (ent->addend == rel->r_addend
6407 && ent->owner == abfd
6408 && ent->tls_type == tls_type)
6412 if (ent->got.refcount > 0)
6413 ent->got.refcount -= 1;
6417 case R_PPC64_PLT16_HA:
6418 case R_PPC64_PLT16_HI:
6419 case R_PPC64_PLT16_LO:
6423 case R_PPC64_REL14_BRNTAKEN:
6424 case R_PPC64_REL14_BRTAKEN:
6428 struct plt_entry *ent;
6430 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6431 if (ent->addend == rel->r_addend)
6433 if (ent != NULL && ent->plt.refcount > 0)
6434 ent->plt.refcount -= 1;
6445 /* The maximum size of .sfpr. */
6446 #define SFPR_MAX (218*4)
6448 struct sfpr_def_parms
6450 const char name[12];
6451 unsigned char lo, hi;
6452 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6453 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6456 /* Auto-generate _save*, _rest* functions in .sfpr. */
6459 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6461 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6463 size_t len = strlen (parm->name);
6464 bfd_boolean writing = FALSE;
6470 memcpy (sym, parm->name, len);
6473 for (i = parm->lo; i <= parm->hi; i++)
6475 struct elf_link_hash_entry *h;
6477 sym[len + 0] = i / 10 + '0';
6478 sym[len + 1] = i % 10 + '0';
6479 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6483 h->root.type = bfd_link_hash_defined;
6484 h->root.u.def.section = htab->sfpr;
6485 h->root.u.def.value = htab->sfpr->size;
6488 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6490 if (htab->sfpr->contents == NULL)
6492 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6493 if (htab->sfpr->contents == NULL)
6499 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6501 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6503 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6504 htab->sfpr->size = p - htab->sfpr->contents;
6512 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6514 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6519 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6521 p = savegpr0 (abfd, p, r);
6522 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6524 bfd_put_32 (abfd, BLR, p);
6529 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6531 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6536 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6538 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6540 p = restgpr0 (abfd, p, r);
6541 bfd_put_32 (abfd, MTLR_R0, p);
6545 p = restgpr0 (abfd, p, 30);
6546 p = restgpr0 (abfd, p, 31);
6548 bfd_put_32 (abfd, BLR, p);
6553 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6555 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6560 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6562 p = savegpr1 (abfd, p, r);
6563 bfd_put_32 (abfd, BLR, p);
6568 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6570 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6575 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6577 p = restgpr1 (abfd, p, r);
6578 bfd_put_32 (abfd, BLR, p);
6583 savefpr (bfd *abfd, bfd_byte *p, int r)
6585 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6590 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6592 p = savefpr (abfd, p, r);
6593 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6595 bfd_put_32 (abfd, BLR, p);
6600 restfpr (bfd *abfd, bfd_byte *p, int r)
6602 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6607 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6609 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6611 p = restfpr (abfd, p, r);
6612 bfd_put_32 (abfd, MTLR_R0, p);
6616 p = restfpr (abfd, p, 30);
6617 p = restfpr (abfd, p, 31);
6619 bfd_put_32 (abfd, BLR, p);
6624 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6626 p = savefpr (abfd, p, r);
6627 bfd_put_32 (abfd, BLR, p);
6632 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6634 p = restfpr (abfd, p, r);
6635 bfd_put_32 (abfd, BLR, p);
6640 savevr (bfd *abfd, bfd_byte *p, int r)
6642 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6644 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6649 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6651 p = savevr (abfd, p, r);
6652 bfd_put_32 (abfd, BLR, p);
6657 restvr (bfd *abfd, bfd_byte *p, int r)
6659 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6661 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6666 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6668 p = restvr (abfd, p, r);
6669 bfd_put_32 (abfd, BLR, p);
6673 /* Called via elf_link_hash_traverse to transfer dynamic linking
6674 information on function code symbol entries to their corresponding
6675 function descriptor symbol entries. */
6678 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6680 struct bfd_link_info *info;
6681 struct ppc_link_hash_table *htab;
6682 struct plt_entry *ent;
6683 struct ppc_link_hash_entry *fh;
6684 struct ppc_link_hash_entry *fdh;
6685 bfd_boolean force_local;
6687 fh = (struct ppc_link_hash_entry *) h;
6688 if (fh->elf.root.type == bfd_link_hash_indirect)
6692 htab = ppc_hash_table (info);
6696 /* Resolve undefined references to dot-symbols as the value
6697 in the function descriptor, if we have one in a regular object.
6698 This is to satisfy cases like ".quad .foo". Calls to functions
6699 in dynamic objects are handled elsewhere. */
6700 if (fh->elf.root.type == bfd_link_hash_undefweak
6701 && fh->was_undefined
6702 && (fdh = defined_func_desc (fh)) != NULL
6703 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6704 && opd_entry_value (fdh->elf.root.u.def.section,
6705 fdh->elf.root.u.def.value,
6706 &fh->elf.root.u.def.section,
6707 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6709 fh->elf.root.type = fdh->elf.root.type;
6710 fh->elf.forced_local = 1;
6711 fh->elf.def_regular = fdh->elf.def_regular;
6712 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6715 /* If this is a function code symbol, transfer dynamic linking
6716 information to the function descriptor symbol. */
6720 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6721 if (ent->plt.refcount > 0)
6724 || fh->elf.root.root.string[0] != '.'
6725 || fh->elf.root.root.string[1] == '\0')
6728 /* Find the corresponding function descriptor symbol. Create it
6729 as undefined if necessary. */
6731 fdh = lookup_fdh (fh, htab);
6733 && !info->executable
6734 && (fh->elf.root.type == bfd_link_hash_undefined
6735 || fh->elf.root.type == bfd_link_hash_undefweak))
6737 fdh = make_fdh (info, fh);
6742 /* Fake function descriptors are made undefweak. If the function
6743 code symbol is strong undefined, make the fake sym the same.
6744 If the function code symbol is defined, then force the fake
6745 descriptor local; We can't support overriding of symbols in a
6746 shared library on a fake descriptor. */
6750 && fdh->elf.root.type == bfd_link_hash_undefweak)
6752 if (fh->elf.root.type == bfd_link_hash_undefined)
6754 fdh->elf.root.type = bfd_link_hash_undefined;
6755 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6757 else if (fh->elf.root.type == bfd_link_hash_defined
6758 || fh->elf.root.type == bfd_link_hash_defweak)
6760 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6765 && !fdh->elf.forced_local
6766 && (!info->executable
6767 || fdh->elf.def_dynamic
6768 || fdh->elf.ref_dynamic
6769 || (fdh->elf.root.type == bfd_link_hash_undefweak
6770 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6772 if (fdh->elf.dynindx == -1)
6773 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6775 fdh->elf.ref_regular |= fh->elf.ref_regular;
6776 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6777 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6778 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6779 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6781 move_plt_plist (fh, fdh);
6782 fdh->elf.needs_plt = 1;
6784 fdh->is_func_descriptor = 1;
6789 /* Now that the info is on the function descriptor, clear the
6790 function code sym info. Any function code syms for which we
6791 don't have a definition in a regular file, we force local.
6792 This prevents a shared library from exporting syms that have
6793 been imported from another library. Function code syms that
6794 are really in the library we must leave global to prevent the
6795 linker dragging in a definition from a static library. */
6796 force_local = (!fh->elf.def_regular
6798 || !fdh->elf.def_regular
6799 || fdh->elf.forced_local);
6800 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6805 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6806 this hook to a) provide some gcc support functions, and b) transfer
6807 dynamic linking information gathered so far on function code symbol
6808 entries, to their corresponding function descriptor symbol entries. */
6811 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6812 struct bfd_link_info *info)
6814 struct ppc_link_hash_table *htab;
6816 static const struct sfpr_def_parms funcs[] =
6818 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6819 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6820 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6821 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6822 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6823 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6824 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6825 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6826 { "._savef", 14, 31, savefpr, savefpr1_tail },
6827 { "._restf", 14, 31, restfpr, restfpr1_tail },
6828 { "_savevr_", 20, 31, savevr, savevr_tail },
6829 { "_restvr_", 20, 31, restvr, restvr_tail }
6832 htab = ppc_hash_table (info);
6836 if (!info->relocatable
6837 && htab->elf.hgot != NULL)
6839 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6840 /* Make .TOC. defined so as to prevent it being made dynamic.
6841 The wrong value here is fixed later in ppc64_elf_set_toc. */
6842 htab->elf.hgot->type = STT_OBJECT;
6843 htab->elf.hgot->root.type = bfd_link_hash_defined;
6844 htab->elf.hgot->root.u.def.value = 0;
6845 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6846 htab->elf.hgot->def_regular = 1;
6847 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6851 if (htab->sfpr == NULL)
6852 /* We don't have any relocs. */
6855 /* Provide any missing _save* and _rest* functions. */
6856 htab->sfpr->size = 0;
6857 if (!info->relocatable)
6858 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6859 if (!sfpr_define (info, &funcs[i]))
6862 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6864 if (htab->sfpr->size == 0)
6865 htab->sfpr->flags |= SEC_EXCLUDE;
6870 /* Return true if we have dynamic relocs that apply to read-only sections. */
6873 readonly_dynrelocs (struct elf_link_hash_entry *h)
6875 struct ppc_link_hash_entry *eh;
6876 struct elf_dyn_relocs *p;
6878 eh = (struct ppc_link_hash_entry *) h;
6879 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6881 asection *s = p->sec->output_section;
6883 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6889 /* Adjust a symbol defined by a dynamic object and referenced by a
6890 regular object. The current definition is in some section of the
6891 dynamic object, but we're not including those sections. We have to
6892 change the definition to something the rest of the link can
6896 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6897 struct elf_link_hash_entry *h)
6899 struct ppc_link_hash_table *htab;
6902 htab = ppc_hash_table (info);
6906 /* Deal with function syms. */
6907 if (h->type == STT_FUNC
6908 || h->type == STT_GNU_IFUNC
6911 /* Clear procedure linkage table information for any symbol that
6912 won't need a .plt entry. */
6913 struct plt_entry *ent;
6914 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6915 if (ent->plt.refcount > 0)
6918 || (h->type != STT_GNU_IFUNC
6919 && (SYMBOL_CALLS_LOCAL (info, h)
6920 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6921 && h->root.type == bfd_link_hash_undefweak))))
6923 h->plt.plist = NULL;
6926 else if (abiversion (info->output_bfd) == 2)
6928 /* After adjust_dynamic_symbol, non_got_ref set in the
6929 non-shared case means that we have allocated space in
6930 .dynbss for the symbol and thus dyn_relocs for this
6931 symbol should be discarded.
6932 If we get here we know we are making a PLT entry for this
6933 symbol, and in an executable we'd normally resolve
6934 relocations against this symbol to the PLT entry. Allow
6935 dynamic relocs if the reference is weak, and the dynamic
6936 relocs will not cause text relocation. */
6937 if (!h->ref_regular_nonweak
6939 && h->type != STT_GNU_IFUNC
6940 && !readonly_dynrelocs (h))
6943 /* If making a plt entry, then we don't need copy relocs. */
6948 h->plt.plist = NULL;
6950 /* If this is a weak symbol, and there is a real definition, the
6951 processor independent code will have arranged for us to see the
6952 real definition first, and we can just use the same value. */
6953 if (h->u.weakdef != NULL)
6955 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6956 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6957 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6958 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6959 if (ELIMINATE_COPY_RELOCS)
6960 h->non_got_ref = h->u.weakdef->non_got_ref;
6964 /* If we are creating a shared library, we must presume that the
6965 only references to the symbol are via the global offset table.
6966 For such cases we need not do anything here; the relocations will
6967 be handled correctly by relocate_section. */
6971 /* If there are no references to this symbol that do not use the
6972 GOT, we don't need to generate a copy reloc. */
6973 if (!h->non_got_ref)
6976 /* Don't generate a copy reloc for symbols defined in the executable. */
6977 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6980 /* If we didn't find any dynamic relocs in read-only sections, then
6981 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6982 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6988 if (h->plt.plist != NULL)
6990 /* We should never get here, but unfortunately there are versions
6991 of gcc out there that improperly (for this ABI) put initialized
6992 function pointers, vtable refs and suchlike in read-only
6993 sections. Allow them to proceed, but warn that this might
6994 break at runtime. */
6995 info->callbacks->einfo
6996 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6997 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6998 h->root.root.string);
7001 /* This is a reference to a symbol defined by a dynamic object which
7002 is not a function. */
7004 /* We must allocate the symbol in our .dynbss section, which will
7005 become part of the .bss section of the executable. There will be
7006 an entry for this symbol in the .dynsym section. The dynamic
7007 object will contain position independent code, so all references
7008 from the dynamic object to this symbol will go through the global
7009 offset table. The dynamic linker will use the .dynsym entry to
7010 determine the address it must put in the global offset table, so
7011 both the dynamic object and the regular object will refer to the
7012 same memory location for the variable. */
7014 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7015 to copy the initial value out of the dynamic object and into the
7016 runtime process image. We need to remember the offset into the
7017 .rela.bss section we are going to use. */
7018 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7020 htab->relbss->size += sizeof (Elf64_External_Rela);
7026 return _bfd_elf_adjust_dynamic_copy (h, s);
7029 /* If given a function descriptor symbol, hide both the function code
7030 sym and the descriptor. */
7032 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7033 struct elf_link_hash_entry *h,
7034 bfd_boolean force_local)
7036 struct ppc_link_hash_entry *eh;
7037 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7039 eh = (struct ppc_link_hash_entry *) h;
7040 if (eh->is_func_descriptor)
7042 struct ppc_link_hash_entry *fh = eh->oh;
7047 struct ppc_link_hash_table *htab;
7050 /* We aren't supposed to use alloca in BFD because on
7051 systems which do not have alloca the version in libiberty
7052 calls xmalloc, which might cause the program to crash
7053 when it runs out of memory. This function doesn't have a
7054 return status, so there's no way to gracefully return an
7055 error. So cheat. We know that string[-1] can be safely
7056 accessed; It's either a string in an ELF string table,
7057 or allocated in an objalloc structure. */
7059 p = eh->elf.root.root.string - 1;
7062 htab = ppc_hash_table (info);
7066 fh = (struct ppc_link_hash_entry *)
7067 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7070 /* Unfortunately, if it so happens that the string we were
7071 looking for was allocated immediately before this string,
7072 then we overwrote the string terminator. That's the only
7073 reason the lookup should fail. */
7076 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7077 while (q >= eh->elf.root.root.string && *q == *p)
7079 if (q < eh->elf.root.root.string && *p == '.')
7080 fh = (struct ppc_link_hash_entry *)
7081 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7090 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7095 get_sym_h (struct elf_link_hash_entry **hp,
7096 Elf_Internal_Sym **symp,
7098 unsigned char **tls_maskp,
7099 Elf_Internal_Sym **locsymsp,
7100 unsigned long r_symndx,
7103 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7105 if (r_symndx >= symtab_hdr->sh_info)
7107 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7108 struct elf_link_hash_entry *h;
7110 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7111 h = elf_follow_link (h);
7119 if (symsecp != NULL)
7121 asection *symsec = NULL;
7122 if (h->root.type == bfd_link_hash_defined
7123 || h->root.type == bfd_link_hash_defweak)
7124 symsec = h->root.u.def.section;
7128 if (tls_maskp != NULL)
7130 struct ppc_link_hash_entry *eh;
7132 eh = (struct ppc_link_hash_entry *) h;
7133 *tls_maskp = &eh->tls_mask;
7138 Elf_Internal_Sym *sym;
7139 Elf_Internal_Sym *locsyms = *locsymsp;
7141 if (locsyms == NULL)
7143 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7144 if (locsyms == NULL)
7145 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7146 symtab_hdr->sh_info,
7147 0, NULL, NULL, NULL);
7148 if (locsyms == NULL)
7150 *locsymsp = locsyms;
7152 sym = locsyms + r_symndx;
7160 if (symsecp != NULL)
7161 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7163 if (tls_maskp != NULL)
7165 struct got_entry **lgot_ents;
7166 unsigned char *tls_mask;
7169 lgot_ents = elf_local_got_ents (ibfd);
7170 if (lgot_ents != NULL)
7172 struct plt_entry **local_plt = (struct plt_entry **)
7173 (lgot_ents + symtab_hdr->sh_info);
7174 unsigned char *lgot_masks = (unsigned char *)
7175 (local_plt + symtab_hdr->sh_info);
7176 tls_mask = &lgot_masks[r_symndx];
7178 *tls_maskp = tls_mask;
7184 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7185 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7186 type suitable for optimization, and 1 otherwise. */
7189 get_tls_mask (unsigned char **tls_maskp,
7190 unsigned long *toc_symndx,
7191 bfd_vma *toc_addend,
7192 Elf_Internal_Sym **locsymsp,
7193 const Elf_Internal_Rela *rel,
7196 unsigned long r_symndx;
7198 struct elf_link_hash_entry *h;
7199 Elf_Internal_Sym *sym;
7203 r_symndx = ELF64_R_SYM (rel->r_info);
7204 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7207 if ((*tls_maskp != NULL && **tls_maskp != 0)
7209 || ppc64_elf_section_data (sec) == NULL
7210 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7213 /* Look inside a TOC section too. */
7216 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7217 off = h->root.u.def.value;
7220 off = sym->st_value;
7221 off += rel->r_addend;
7222 BFD_ASSERT (off % 8 == 0);
7223 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7224 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7225 if (toc_symndx != NULL)
7226 *toc_symndx = r_symndx;
7227 if (toc_addend != NULL)
7228 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7229 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7231 if ((h == NULL || is_static_defined (h))
7232 && (next_r == -1 || next_r == -2))
7237 /* Find (or create) an entry in the tocsave hash table. */
7239 static struct tocsave_entry *
7240 tocsave_find (struct ppc_link_hash_table *htab,
7241 enum insert_option insert,
7242 Elf_Internal_Sym **local_syms,
7243 const Elf_Internal_Rela *irela,
7246 unsigned long r_indx;
7247 struct elf_link_hash_entry *h;
7248 Elf_Internal_Sym *sym;
7249 struct tocsave_entry ent, *p;
7251 struct tocsave_entry **slot;
7253 r_indx = ELF64_R_SYM (irela->r_info);
7254 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7256 if (ent.sec == NULL || ent.sec->output_section == NULL)
7258 (*_bfd_error_handler)
7259 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7264 ent.offset = h->root.u.def.value;
7266 ent.offset = sym->st_value;
7267 ent.offset += irela->r_addend;
7269 hash = tocsave_htab_hash (&ent);
7270 slot = ((struct tocsave_entry **)
7271 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7277 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7286 /* Adjust all global syms defined in opd sections. In gcc generated
7287 code for the old ABI, these will already have been done. */
7290 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7292 struct ppc_link_hash_entry *eh;
7294 struct _opd_sec_data *opd;
7296 if (h->root.type == bfd_link_hash_indirect)
7299 if (h->root.type != bfd_link_hash_defined
7300 && h->root.type != bfd_link_hash_defweak)
7303 eh = (struct ppc_link_hash_entry *) h;
7304 if (eh->adjust_done)
7307 sym_sec = eh->elf.root.u.def.section;
7308 opd = get_opd_info (sym_sec);
7309 if (opd != NULL && opd->adjust != NULL)
7311 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7314 /* This entry has been deleted. */
7315 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7318 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7319 if (discarded_section (dsec))
7321 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7325 eh->elf.root.u.def.value = 0;
7326 eh->elf.root.u.def.section = dsec;
7329 eh->elf.root.u.def.value += adjust;
7330 eh->adjust_done = 1;
7335 /* Handles decrementing dynamic reloc counts for the reloc specified by
7336 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7337 have already been determined. */
7340 dec_dynrel_count (bfd_vma r_info,
7342 struct bfd_link_info *info,
7343 Elf_Internal_Sym **local_syms,
7344 struct elf_link_hash_entry *h,
7345 Elf_Internal_Sym *sym)
7347 enum elf_ppc64_reloc_type r_type;
7348 asection *sym_sec = NULL;
7350 /* Can this reloc be dynamic? This switch, and later tests here
7351 should be kept in sync with the code in check_relocs. */
7352 r_type = ELF64_R_TYPE (r_info);
7358 case R_PPC64_TPREL16:
7359 case R_PPC64_TPREL16_LO:
7360 case R_PPC64_TPREL16_HI:
7361 case R_PPC64_TPREL16_HA:
7362 case R_PPC64_TPREL16_DS:
7363 case R_PPC64_TPREL16_LO_DS:
7364 case R_PPC64_TPREL16_HIGH:
7365 case R_PPC64_TPREL16_HIGHA:
7366 case R_PPC64_TPREL16_HIGHER:
7367 case R_PPC64_TPREL16_HIGHERA:
7368 case R_PPC64_TPREL16_HIGHEST:
7369 case R_PPC64_TPREL16_HIGHESTA:
7373 case R_PPC64_TPREL64:
7374 case R_PPC64_DTPMOD64:
7375 case R_PPC64_DTPREL64:
7376 case R_PPC64_ADDR64:
7380 case R_PPC64_ADDR14:
7381 case R_PPC64_ADDR14_BRNTAKEN:
7382 case R_PPC64_ADDR14_BRTAKEN:
7383 case R_PPC64_ADDR16:
7384 case R_PPC64_ADDR16_DS:
7385 case R_PPC64_ADDR16_HA:
7386 case R_PPC64_ADDR16_HI:
7387 case R_PPC64_ADDR16_HIGH:
7388 case R_PPC64_ADDR16_HIGHA:
7389 case R_PPC64_ADDR16_HIGHER:
7390 case R_PPC64_ADDR16_HIGHERA:
7391 case R_PPC64_ADDR16_HIGHEST:
7392 case R_PPC64_ADDR16_HIGHESTA:
7393 case R_PPC64_ADDR16_LO:
7394 case R_PPC64_ADDR16_LO_DS:
7395 case R_PPC64_ADDR24:
7396 case R_PPC64_ADDR32:
7397 case R_PPC64_UADDR16:
7398 case R_PPC64_UADDR32:
7399 case R_PPC64_UADDR64:
7404 if (local_syms != NULL)
7406 unsigned long r_symndx;
7407 bfd *ibfd = sec->owner;
7409 r_symndx = ELF64_R_SYM (r_info);
7410 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7415 && (must_be_dyn_reloc (info, r_type)
7417 && (!SYMBOLIC_BIND (info, h)
7418 || h->root.type == bfd_link_hash_defweak
7419 || !h->def_regular))))
7420 || (ELIMINATE_COPY_RELOCS
7423 && (h->root.type == bfd_link_hash_defweak
7424 || !h->def_regular)))
7431 struct elf_dyn_relocs *p;
7432 struct elf_dyn_relocs **pp;
7433 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7435 /* elf_gc_sweep may have already removed all dyn relocs associated
7436 with local syms for a given section. Also, symbol flags are
7437 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7438 report a dynreloc miscount. */
7439 if (*pp == NULL && info->gc_sections)
7442 while ((p = *pp) != NULL)
7446 if (!must_be_dyn_reloc (info, r_type))
7458 struct ppc_dyn_relocs *p;
7459 struct ppc_dyn_relocs **pp;
7461 bfd_boolean is_ifunc;
7463 if (local_syms == NULL)
7464 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7465 if (sym_sec == NULL)
7468 vpp = &elf_section_data (sym_sec)->local_dynrel;
7469 pp = (struct ppc_dyn_relocs **) vpp;
7471 if (*pp == NULL && info->gc_sections)
7474 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7475 while ((p = *pp) != NULL)
7477 if (p->sec == sec && p->ifunc == is_ifunc)
7488 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7490 bfd_set_error (bfd_error_bad_value);
7494 /* Remove unused Official Procedure Descriptor entries. Currently we
7495 only remove those associated with functions in discarded link-once
7496 sections, or weakly defined functions that have been overridden. It
7497 would be possible to remove many more entries for statically linked
7501 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7504 bfd_boolean some_edited = FALSE;
7505 asection *need_pad = NULL;
7507 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7510 Elf_Internal_Rela *relstart, *rel, *relend;
7511 Elf_Internal_Shdr *symtab_hdr;
7512 Elf_Internal_Sym *local_syms;
7514 struct _opd_sec_data *opd;
7515 bfd_boolean need_edit, add_aux_fields;
7516 bfd_size_type cnt_16b = 0;
7518 if (!is_ppc64_elf (ibfd))
7521 sec = bfd_get_section_by_name (ibfd, ".opd");
7522 if (sec == NULL || sec->size == 0)
7525 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7528 if (sec->output_section == bfd_abs_section_ptr)
7531 /* Look through the section relocs. */
7532 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7536 symtab_hdr = &elf_symtab_hdr (ibfd);
7538 /* Read the relocations. */
7539 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7541 if (relstart == NULL)
7544 /* First run through the relocs to check they are sane, and to
7545 determine whether we need to edit this opd section. */
7549 relend = relstart + sec->reloc_count;
7550 for (rel = relstart; rel < relend; )
7552 enum elf_ppc64_reloc_type r_type;
7553 unsigned long r_symndx;
7555 struct elf_link_hash_entry *h;
7556 Elf_Internal_Sym *sym;
7558 /* .opd contains a regular array of 16 or 24 byte entries. We're
7559 only interested in the reloc pointing to a function entry
7561 if (rel->r_offset != offset
7562 || rel + 1 >= relend
7563 || (rel + 1)->r_offset != offset + 8)
7565 /* If someone messes with .opd alignment then after a
7566 "ld -r" we might have padding in the middle of .opd.
7567 Also, there's nothing to prevent someone putting
7568 something silly in .opd with the assembler. No .opd
7569 optimization for them! */
7571 (*_bfd_error_handler)
7572 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7577 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7578 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7580 (*_bfd_error_handler)
7581 (_("%B: unexpected reloc type %u in .opd section"),
7587 r_symndx = ELF64_R_SYM (rel->r_info);
7588 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7592 if (sym_sec == NULL || sym_sec->owner == NULL)
7594 const char *sym_name;
7596 sym_name = h->root.root.string;
7598 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7601 (*_bfd_error_handler)
7602 (_("%B: undefined sym `%s' in .opd section"),
7608 /* opd entries are always for functions defined in the
7609 current input bfd. If the symbol isn't defined in the
7610 input bfd, then we won't be using the function in this
7611 bfd; It must be defined in a linkonce section in another
7612 bfd, or is weak. It's also possible that we are
7613 discarding the function due to a linker script /DISCARD/,
7614 which we test for via the output_section. */
7615 if (sym_sec->owner != ibfd
7616 || sym_sec->output_section == bfd_abs_section_ptr)
7621 || (rel + 1 == relend && rel->r_offset == offset + 16))
7623 if (sec->size == offset + 24)
7628 if (rel == relend && sec->size == offset + 16)
7636 if (rel->r_offset == offset + 24)
7638 else if (rel->r_offset != offset + 16)
7640 else if (rel + 1 < relend
7641 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7642 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7647 else if (rel + 2 < relend
7648 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7649 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7658 add_aux_fields = non_overlapping && cnt_16b > 0;
7660 if (need_edit || add_aux_fields)
7662 Elf_Internal_Rela *write_rel;
7663 Elf_Internal_Shdr *rel_hdr;
7664 bfd_byte *rptr, *wptr;
7665 bfd_byte *new_contents;
7670 new_contents = NULL;
7671 amt = sec->size * sizeof (long) / 8;
7672 opd = &ppc64_elf_section_data (sec)->u.opd;
7673 opd->adjust = bfd_zalloc (sec->owner, amt);
7674 if (opd->adjust == NULL)
7676 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7678 /* This seems a waste of time as input .opd sections are all
7679 zeros as generated by gcc, but I suppose there's no reason
7680 this will always be so. We might start putting something in
7681 the third word of .opd entries. */
7682 if ((sec->flags & SEC_IN_MEMORY) == 0)
7685 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7690 if (local_syms != NULL
7691 && symtab_hdr->contents != (unsigned char *) local_syms)
7693 if (elf_section_data (sec)->relocs != relstart)
7697 sec->contents = loc;
7698 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7701 elf_section_data (sec)->relocs = relstart;
7703 new_contents = sec->contents;
7706 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7707 if (new_contents == NULL)
7711 wptr = new_contents;
7712 rptr = sec->contents;
7714 write_rel = relstart;
7718 for (rel = relstart; rel < relend; rel++)
7720 unsigned long r_symndx;
7722 struct elf_link_hash_entry *h;
7723 Elf_Internal_Sym *sym;
7725 r_symndx = ELF64_R_SYM (rel->r_info);
7726 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7730 if (rel->r_offset == offset)
7732 struct ppc_link_hash_entry *fdh = NULL;
7734 /* See if the .opd entry is full 24 byte or
7735 16 byte (with fd_aux entry overlapped with next
7738 if ((rel + 2 == relend && sec->size == offset + 16)
7739 || (rel + 3 < relend
7740 && rel[2].r_offset == offset + 16
7741 && rel[3].r_offset == offset + 24
7742 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7743 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7747 && h->root.root.string[0] == '.')
7749 struct ppc_link_hash_table *htab;
7751 htab = ppc_hash_table (info);
7753 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7756 && fdh->elf.root.type != bfd_link_hash_defined
7757 && fdh->elf.root.type != bfd_link_hash_defweak)
7761 skip = (sym_sec->owner != ibfd
7762 || sym_sec->output_section == bfd_abs_section_ptr);
7765 if (fdh != NULL && sym_sec->owner == ibfd)
7767 /* Arrange for the function descriptor sym
7769 fdh->elf.root.u.def.value = 0;
7770 fdh->elf.root.u.def.section = sym_sec;
7772 opd->adjust[rel->r_offset / 8] = -1;
7776 /* We'll be keeping this opd entry. */
7780 /* Redefine the function descriptor symbol to
7781 this location in the opd section. It is
7782 necessary to update the value here rather
7783 than using an array of adjustments as we do
7784 for local symbols, because various places
7785 in the generic ELF code use the value
7786 stored in u.def.value. */
7787 fdh->elf.root.u.def.value = wptr - new_contents;
7788 fdh->adjust_done = 1;
7791 /* Local syms are a bit tricky. We could
7792 tweak them as they can be cached, but
7793 we'd need to look through the local syms
7794 for the function descriptor sym which we
7795 don't have at the moment. So keep an
7796 array of adjustments. */
7797 opd->adjust[rel->r_offset / 8]
7798 = (wptr - new_contents) - (rptr - sec->contents);
7801 memcpy (wptr, rptr, opd_ent_size);
7802 wptr += opd_ent_size;
7803 if (add_aux_fields && opd_ent_size == 16)
7805 memset (wptr, '\0', 8);
7809 rptr += opd_ent_size;
7810 offset += opd_ent_size;
7816 && !info->relocatable
7817 && !dec_dynrel_count (rel->r_info, sec, info,
7823 /* We need to adjust any reloc offsets to point to the
7824 new opd entries. While we're at it, we may as well
7825 remove redundant relocs. */
7826 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7827 if (write_rel != rel)
7828 memcpy (write_rel, rel, sizeof (*rel));
7833 sec->size = wptr - new_contents;
7834 sec->reloc_count = write_rel - relstart;
7837 free (sec->contents);
7838 sec->contents = new_contents;
7841 /* Fudge the header size too, as this is used later in
7842 elf_bfd_final_link if we are emitting relocs. */
7843 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7844 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7847 else if (elf_section_data (sec)->relocs != relstart)
7850 if (local_syms != NULL
7851 && symtab_hdr->contents != (unsigned char *) local_syms)
7853 if (!info->keep_memory)
7856 symtab_hdr->contents = (unsigned char *) local_syms;
7861 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7863 /* If we are doing a final link and the last .opd entry is just 16 byte
7864 long, add a 8 byte padding after it. */
7865 if (need_pad != NULL && !info->relocatable)
7869 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7871 BFD_ASSERT (need_pad->size > 0);
7873 p = bfd_malloc (need_pad->size + 8);
7877 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7878 p, 0, need_pad->size))
7881 need_pad->contents = p;
7882 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7886 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7890 need_pad->contents = p;
7893 memset (need_pad->contents + need_pad->size, 0, 8);
7894 need_pad->size += 8;
7900 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7903 ppc64_elf_tls_setup (struct bfd_link_info *info,
7904 int no_tls_get_addr_opt,
7907 struct ppc_link_hash_table *htab;
7909 htab = ppc_hash_table (info);
7913 if (abiversion (info->output_bfd) == 1)
7917 htab->do_multi_toc = 0;
7918 else if (!htab->do_multi_toc)
7921 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7922 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7923 FALSE, FALSE, TRUE));
7924 /* Move dynamic linking info to the function descriptor sym. */
7925 if (htab->tls_get_addr != NULL)
7926 func_desc_adjust (&htab->tls_get_addr->elf, info);
7927 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7928 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7929 FALSE, FALSE, TRUE));
7930 if (!no_tls_get_addr_opt)
7932 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7934 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7935 FALSE, FALSE, TRUE);
7937 func_desc_adjust (opt, info);
7938 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7939 FALSE, FALSE, TRUE);
7941 && (opt_fd->root.type == bfd_link_hash_defined
7942 || opt_fd->root.type == bfd_link_hash_defweak))
7944 /* If glibc supports an optimized __tls_get_addr call stub,
7945 signalled by the presence of __tls_get_addr_opt, and we'll
7946 be calling __tls_get_addr via a plt call stub, then
7947 make __tls_get_addr point to __tls_get_addr_opt. */
7948 tga_fd = &htab->tls_get_addr_fd->elf;
7949 if (htab->elf.dynamic_sections_created
7951 && (tga_fd->type == STT_FUNC
7952 || tga_fd->needs_plt)
7953 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7954 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7955 && tga_fd->root.type == bfd_link_hash_undefweak)))
7957 struct plt_entry *ent;
7959 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7960 if (ent->plt.refcount > 0)
7964 tga_fd->root.type = bfd_link_hash_indirect;
7965 tga_fd->root.u.i.link = &opt_fd->root;
7966 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7967 if (opt_fd->dynindx != -1)
7969 /* Use __tls_get_addr_opt in dynamic relocations. */
7970 opt_fd->dynindx = -1;
7971 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7972 opt_fd->dynstr_index);
7973 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7976 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7977 tga = &htab->tls_get_addr->elf;
7978 if (opt != NULL && tga != NULL)
7980 tga->root.type = bfd_link_hash_indirect;
7981 tga->root.u.i.link = &opt->root;
7982 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7983 _bfd_elf_link_hash_hide_symbol (info, opt,
7985 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7987 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7988 htab->tls_get_addr_fd->is_func_descriptor = 1;
7989 if (htab->tls_get_addr != NULL)
7991 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7992 htab->tls_get_addr->is_func = 1;
7998 no_tls_get_addr_opt = TRUE;
8000 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8001 return _bfd_elf_tls_setup (info->output_bfd, info);
8004 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8008 branch_reloc_hash_match (const bfd *ibfd,
8009 const Elf_Internal_Rela *rel,
8010 const struct ppc_link_hash_entry *hash1,
8011 const struct ppc_link_hash_entry *hash2)
8013 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8014 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8015 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8017 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8019 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8020 struct elf_link_hash_entry *h;
8022 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8023 h = elf_follow_link (h);
8024 if (h == &hash1->elf || h == &hash2->elf)
8030 /* Run through all the TLS relocs looking for optimization
8031 opportunities. The linker has been hacked (see ppc64elf.em) to do
8032 a preliminary section layout so that we know the TLS segment
8033 offsets. We can't optimize earlier because some optimizations need
8034 to know the tp offset, and we need to optimize before allocating
8035 dynamic relocations. */
8038 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8042 struct ppc_link_hash_table *htab;
8043 unsigned char *toc_ref;
8046 if (info->relocatable || !info->executable)
8049 htab = ppc_hash_table (info);
8053 /* Make two passes over the relocs. On the first pass, mark toc
8054 entries involved with tls relocs, and check that tls relocs
8055 involved in setting up a tls_get_addr call are indeed followed by
8056 such a call. If they are not, we can't do any tls optimization.
8057 On the second pass twiddle tls_mask flags to notify
8058 relocate_section that optimization can be done, and adjust got
8059 and plt refcounts. */
8061 for (pass = 0; pass < 2; ++pass)
8062 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8064 Elf_Internal_Sym *locsyms = NULL;
8065 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8067 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8068 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8070 Elf_Internal_Rela *relstart, *rel, *relend;
8071 bfd_boolean found_tls_get_addr_arg = 0;
8073 /* Read the relocations. */
8074 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8076 if (relstart == NULL)
8079 relend = relstart + sec->reloc_count;
8080 for (rel = relstart; rel < relend; rel++)
8082 enum elf_ppc64_reloc_type r_type;
8083 unsigned long r_symndx;
8084 struct elf_link_hash_entry *h;
8085 Elf_Internal_Sym *sym;
8087 unsigned char *tls_mask;
8088 unsigned char tls_set, tls_clear, tls_type = 0;
8090 bfd_boolean ok_tprel, is_local;
8091 long toc_ref_index = 0;
8092 int expecting_tls_get_addr = 0;
8093 bfd_boolean ret = FALSE;
8095 r_symndx = ELF64_R_SYM (rel->r_info);
8096 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8100 if (elf_section_data (sec)->relocs != relstart)
8102 if (toc_ref != NULL)
8105 && (elf_symtab_hdr (ibfd).contents
8106 != (unsigned char *) locsyms))
8113 if (h->root.type == bfd_link_hash_defined
8114 || h->root.type == bfd_link_hash_defweak)
8115 value = h->root.u.def.value;
8116 else if (h->root.type == bfd_link_hash_undefweak)
8120 found_tls_get_addr_arg = 0;
8125 /* Symbols referenced by TLS relocs must be of type
8126 STT_TLS. So no need for .opd local sym adjust. */
8127 value = sym->st_value;
8136 && h->root.type == bfd_link_hash_undefweak)
8140 value += sym_sec->output_offset;
8141 value += sym_sec->output_section->vma;
8142 value -= htab->elf.tls_sec->vma;
8143 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8144 < (bfd_vma) 1 << 32);
8148 r_type = ELF64_R_TYPE (rel->r_info);
8149 /* If this section has old-style __tls_get_addr calls
8150 without marker relocs, then check that each
8151 __tls_get_addr call reloc is preceded by a reloc
8152 that conceivably belongs to the __tls_get_addr arg
8153 setup insn. If we don't find matching arg setup
8154 relocs, don't do any tls optimization. */
8156 && sec->has_tls_get_addr_call
8158 && (h == &htab->tls_get_addr->elf
8159 || h == &htab->tls_get_addr_fd->elf)
8160 && !found_tls_get_addr_arg
8161 && is_branch_reloc (r_type))
8163 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8164 "TLS optimization disabled\n"),
8165 ibfd, sec, rel->r_offset);
8170 found_tls_get_addr_arg = 0;
8173 case R_PPC64_GOT_TLSLD16:
8174 case R_PPC64_GOT_TLSLD16_LO:
8175 expecting_tls_get_addr = 1;
8176 found_tls_get_addr_arg = 1;
8179 case R_PPC64_GOT_TLSLD16_HI:
8180 case R_PPC64_GOT_TLSLD16_HA:
8181 /* These relocs should never be against a symbol
8182 defined in a shared lib. Leave them alone if
8183 that turns out to be the case. */
8190 tls_type = TLS_TLS | TLS_LD;
8193 case R_PPC64_GOT_TLSGD16:
8194 case R_PPC64_GOT_TLSGD16_LO:
8195 expecting_tls_get_addr = 1;
8196 found_tls_get_addr_arg = 1;
8199 case R_PPC64_GOT_TLSGD16_HI:
8200 case R_PPC64_GOT_TLSGD16_HA:
8206 tls_set = TLS_TLS | TLS_TPRELGD;
8208 tls_type = TLS_TLS | TLS_GD;
8211 case R_PPC64_GOT_TPREL16_DS:
8212 case R_PPC64_GOT_TPREL16_LO_DS:
8213 case R_PPC64_GOT_TPREL16_HI:
8214 case R_PPC64_GOT_TPREL16_HA:
8219 tls_clear = TLS_TPREL;
8220 tls_type = TLS_TLS | TLS_TPREL;
8227 found_tls_get_addr_arg = 1;
8232 case R_PPC64_TOC16_LO:
8233 if (sym_sec == NULL || sym_sec != toc)
8236 /* Mark this toc entry as referenced by a TLS
8237 code sequence. We can do that now in the
8238 case of R_PPC64_TLS, and after checking for
8239 tls_get_addr for the TOC16 relocs. */
8240 if (toc_ref == NULL)
8241 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8242 if (toc_ref == NULL)
8246 value = h->root.u.def.value;
8248 value = sym->st_value;
8249 value += rel->r_addend;
8250 BFD_ASSERT (value < toc->size && value % 8 == 0);
8251 toc_ref_index = (value + toc->output_offset) / 8;
8252 if (r_type == R_PPC64_TLS
8253 || r_type == R_PPC64_TLSGD
8254 || r_type == R_PPC64_TLSLD)
8256 toc_ref[toc_ref_index] = 1;
8260 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8265 expecting_tls_get_addr = 2;
8268 case R_PPC64_TPREL64:
8272 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8277 tls_set = TLS_EXPLICIT;
8278 tls_clear = TLS_TPREL;
8283 case R_PPC64_DTPMOD64:
8287 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8289 if (rel + 1 < relend
8291 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8292 && rel[1].r_offset == rel->r_offset + 8)
8296 tls_set = TLS_EXPLICIT | TLS_GD;
8299 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8308 tls_set = TLS_EXPLICIT;
8319 if (!expecting_tls_get_addr
8320 || !sec->has_tls_get_addr_call)
8323 if (rel + 1 < relend
8324 && branch_reloc_hash_match (ibfd, rel + 1,
8326 htab->tls_get_addr_fd))
8328 if (expecting_tls_get_addr == 2)
8330 /* Check for toc tls entries. */
8331 unsigned char *toc_tls;
8334 retval = get_tls_mask (&toc_tls, NULL, NULL,
8339 if (toc_tls != NULL)
8341 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8342 found_tls_get_addr_arg = 1;
8344 toc_ref[toc_ref_index] = 1;
8350 if (expecting_tls_get_addr != 1)
8353 /* Uh oh, we didn't find the expected call. We
8354 could just mark this symbol to exclude it
8355 from tls optimization but it's safer to skip
8356 the entire optimization. */
8357 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8358 "TLS optimization disabled\n"),
8359 ibfd, sec, rel->r_offset);
8364 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8366 struct plt_entry *ent;
8367 for (ent = htab->tls_get_addr->elf.plt.plist;
8370 if (ent->addend == 0)
8372 if (ent->plt.refcount > 0)
8374 ent->plt.refcount -= 1;
8375 expecting_tls_get_addr = 0;
8381 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8383 struct plt_entry *ent;
8384 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8387 if (ent->addend == 0)
8389 if (ent->plt.refcount > 0)
8390 ent->plt.refcount -= 1;
8398 if ((tls_set & TLS_EXPLICIT) == 0)
8400 struct got_entry *ent;
8402 /* Adjust got entry for this reloc. */
8406 ent = elf_local_got_ents (ibfd)[r_symndx];
8408 for (; ent != NULL; ent = ent->next)
8409 if (ent->addend == rel->r_addend
8410 && ent->owner == ibfd
8411 && ent->tls_type == tls_type)
8418 /* We managed to get rid of a got entry. */
8419 if (ent->got.refcount > 0)
8420 ent->got.refcount -= 1;
8425 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8426 we'll lose one or two dyn relocs. */
8427 if (!dec_dynrel_count (rel->r_info, sec, info,
8431 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8433 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8439 *tls_mask |= tls_set;
8440 *tls_mask &= ~tls_clear;
8443 if (elf_section_data (sec)->relocs != relstart)
8448 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8450 if (!info->keep_memory)
8453 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8457 if (toc_ref != NULL)
8462 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8463 the values of any global symbols in a toc section that has been
8464 edited. Globals in toc sections should be a rarity, so this function
8465 sets a flag if any are found in toc sections other than the one just
8466 edited, so that futher hash table traversals can be avoided. */
8468 struct adjust_toc_info
8471 unsigned long *skip;
8472 bfd_boolean global_toc_syms;
8475 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8478 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8480 struct ppc_link_hash_entry *eh;
8481 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8484 if (h->root.type != bfd_link_hash_defined
8485 && h->root.type != bfd_link_hash_defweak)
8488 eh = (struct ppc_link_hash_entry *) h;
8489 if (eh->adjust_done)
8492 if (eh->elf.root.u.def.section == toc_inf->toc)
8494 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8495 i = toc_inf->toc->rawsize >> 3;
8497 i = eh->elf.root.u.def.value >> 3;
8499 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8501 (*_bfd_error_handler)
8502 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8505 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8506 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8509 eh->elf.root.u.def.value -= toc_inf->skip[i];
8510 eh->adjust_done = 1;
8512 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8513 toc_inf->global_toc_syms = TRUE;
8518 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8521 ok_lo_toc_insn (unsigned int insn)
8523 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8524 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8525 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8526 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8527 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8528 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8529 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8530 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8531 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8532 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8533 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8534 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8535 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8536 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8537 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8539 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8540 && ((insn & 3) == 0 || (insn & 3) == 3))
8541 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8544 /* Examine all relocs referencing .toc sections in order to remove
8545 unused .toc entries. */
8548 ppc64_elf_edit_toc (struct bfd_link_info *info)
8551 struct adjust_toc_info toc_inf;
8552 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8554 htab->do_toc_opt = 1;
8555 toc_inf.global_toc_syms = TRUE;
8556 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8558 asection *toc, *sec;
8559 Elf_Internal_Shdr *symtab_hdr;
8560 Elf_Internal_Sym *local_syms;
8561 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8562 unsigned long *skip, *drop;
8563 unsigned char *used;
8564 unsigned char *keep, last, some_unused;
8566 if (!is_ppc64_elf (ibfd))
8569 toc = bfd_get_section_by_name (ibfd, ".toc");
8572 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8573 || discarded_section (toc))
8578 symtab_hdr = &elf_symtab_hdr (ibfd);
8580 /* Look at sections dropped from the final link. */
8583 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8585 if (sec->reloc_count == 0
8586 || !discarded_section (sec)
8587 || get_opd_info (sec)
8588 || (sec->flags & SEC_ALLOC) == 0
8589 || (sec->flags & SEC_DEBUGGING) != 0)
8592 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8593 if (relstart == NULL)
8596 /* Run through the relocs to see which toc entries might be
8598 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8600 enum elf_ppc64_reloc_type r_type;
8601 unsigned long r_symndx;
8603 struct elf_link_hash_entry *h;
8604 Elf_Internal_Sym *sym;
8607 r_type = ELF64_R_TYPE (rel->r_info);
8614 case R_PPC64_TOC16_LO:
8615 case R_PPC64_TOC16_HI:
8616 case R_PPC64_TOC16_HA:
8617 case R_PPC64_TOC16_DS:
8618 case R_PPC64_TOC16_LO_DS:
8622 r_symndx = ELF64_R_SYM (rel->r_info);
8623 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8631 val = h->root.u.def.value;
8633 val = sym->st_value;
8634 val += rel->r_addend;
8636 if (val >= toc->size)
8639 /* Anything in the toc ought to be aligned to 8 bytes.
8640 If not, don't mark as unused. */
8646 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8651 skip[val >> 3] = ref_from_discarded;
8654 if (elf_section_data (sec)->relocs != relstart)
8658 /* For largetoc loads of address constants, we can convert
8659 . addis rx,2,addr@got@ha
8660 . ld ry,addr@got@l(rx)
8662 . addis rx,2,addr@toc@ha
8663 . addi ry,rx,addr@toc@l
8664 when addr is within 2G of the toc pointer. This then means
8665 that the word storing "addr" in the toc is no longer needed. */
8667 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8668 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8669 && toc->reloc_count != 0)
8671 /* Read toc relocs. */
8672 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8674 if (toc_relocs == NULL)
8677 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8679 enum elf_ppc64_reloc_type r_type;
8680 unsigned long r_symndx;
8682 struct elf_link_hash_entry *h;
8683 Elf_Internal_Sym *sym;
8686 r_type = ELF64_R_TYPE (rel->r_info);
8687 if (r_type != R_PPC64_ADDR64)
8690 r_symndx = ELF64_R_SYM (rel->r_info);
8691 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8696 || discarded_section (sym_sec))
8699 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8704 if (h->type == STT_GNU_IFUNC)
8706 val = h->root.u.def.value;
8710 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8712 val = sym->st_value;
8714 val += rel->r_addend;
8715 val += sym_sec->output_section->vma + sym_sec->output_offset;
8717 /* We don't yet know the exact toc pointer value, but we
8718 know it will be somewhere in the toc section. Don't
8719 optimize if the difference from any possible toc
8720 pointer is outside [ff..f80008000, 7fff7fff]. */
8721 addr = toc->output_section->vma + TOC_BASE_OFF;
8722 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8725 addr = toc->output_section->vma + toc->output_section->rawsize;
8726 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8731 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8736 skip[rel->r_offset >> 3]
8737 |= can_optimize | ((rel - toc_relocs) << 2);
8744 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8748 if (local_syms != NULL
8749 && symtab_hdr->contents != (unsigned char *) local_syms)
8753 && elf_section_data (sec)->relocs != relstart)
8755 if (toc_relocs != NULL
8756 && elf_section_data (toc)->relocs != toc_relocs)
8763 /* Now check all kept sections that might reference the toc.
8764 Check the toc itself last. */
8765 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8768 sec = (sec == toc ? NULL
8769 : sec->next == NULL ? toc
8770 : sec->next == toc && toc->next ? toc->next
8775 if (sec->reloc_count == 0
8776 || discarded_section (sec)
8777 || get_opd_info (sec)
8778 || (sec->flags & SEC_ALLOC) == 0
8779 || (sec->flags & SEC_DEBUGGING) != 0)
8782 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8784 if (relstart == NULL)
8787 /* Mark toc entries referenced as used. */
8791 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8793 enum elf_ppc64_reloc_type r_type;
8794 unsigned long r_symndx;
8796 struct elf_link_hash_entry *h;
8797 Elf_Internal_Sym *sym;
8799 enum {no_check, check_lo, check_ha} insn_check;
8801 r_type = ELF64_R_TYPE (rel->r_info);
8805 insn_check = no_check;
8808 case R_PPC64_GOT_TLSLD16_HA:
8809 case R_PPC64_GOT_TLSGD16_HA:
8810 case R_PPC64_GOT_TPREL16_HA:
8811 case R_PPC64_GOT_DTPREL16_HA:
8812 case R_PPC64_GOT16_HA:
8813 case R_PPC64_TOC16_HA:
8814 insn_check = check_ha;
8817 case R_PPC64_GOT_TLSLD16_LO:
8818 case R_PPC64_GOT_TLSGD16_LO:
8819 case R_PPC64_GOT_TPREL16_LO_DS:
8820 case R_PPC64_GOT_DTPREL16_LO_DS:
8821 case R_PPC64_GOT16_LO:
8822 case R_PPC64_GOT16_LO_DS:
8823 case R_PPC64_TOC16_LO:
8824 case R_PPC64_TOC16_LO_DS:
8825 insn_check = check_lo;
8829 if (insn_check != no_check)
8831 bfd_vma off = rel->r_offset & ~3;
8832 unsigned char buf[4];
8835 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8840 insn = bfd_get_32 (ibfd, buf);
8841 if (insn_check == check_lo
8842 ? !ok_lo_toc_insn (insn)
8843 : ((insn & ((0x3f << 26) | 0x1f << 16))
8844 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8848 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8849 sprintf (str, "%#08x", insn);
8850 info->callbacks->einfo
8851 (_("%P: %H: toc optimization is not supported for"
8852 " %s instruction.\n"),
8853 ibfd, sec, rel->r_offset & ~3, str);
8860 case R_PPC64_TOC16_LO:
8861 case R_PPC64_TOC16_HI:
8862 case R_PPC64_TOC16_HA:
8863 case R_PPC64_TOC16_DS:
8864 case R_PPC64_TOC16_LO_DS:
8865 /* In case we're taking addresses of toc entries. */
8866 case R_PPC64_ADDR64:
8873 r_symndx = ELF64_R_SYM (rel->r_info);
8874 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8885 val = h->root.u.def.value;
8887 val = sym->st_value;
8888 val += rel->r_addend;
8890 if (val >= toc->size)
8893 if ((skip[val >> 3] & can_optimize) != 0)
8900 case R_PPC64_TOC16_HA:
8903 case R_PPC64_TOC16_LO_DS:
8904 off = rel->r_offset;
8905 off += (bfd_big_endian (ibfd) ? -2 : 3);
8906 if (!bfd_get_section_contents (ibfd, sec, &opc,
8912 if ((opc & (0x3f << 2)) == (58u << 2))
8917 /* Wrong sort of reloc, or not a ld. We may
8918 as well clear ref_from_discarded too. */
8925 /* For the toc section, we only mark as used if this
8926 entry itself isn't unused. */
8927 else if ((used[rel->r_offset >> 3]
8928 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8931 /* Do all the relocs again, to catch reference
8940 if (elf_section_data (sec)->relocs != relstart)
8944 /* Merge the used and skip arrays. Assume that TOC
8945 doublewords not appearing as either used or unused belong
8946 to to an entry more than one doubleword in size. */
8947 for (drop = skip, keep = used, last = 0, some_unused = 0;
8948 drop < skip + (toc->size + 7) / 8;
8953 *drop &= ~ref_from_discarded;
8954 if ((*drop & can_optimize) != 0)
8958 else if ((*drop & ref_from_discarded) != 0)
8961 last = ref_from_discarded;
8971 bfd_byte *contents, *src;
8973 Elf_Internal_Sym *sym;
8974 bfd_boolean local_toc_syms = FALSE;
8976 /* Shuffle the toc contents, and at the same time convert the
8977 skip array from booleans into offsets. */
8978 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8981 elf_section_data (toc)->this_hdr.contents = contents;
8983 for (src = contents, off = 0, drop = skip;
8984 src < contents + toc->size;
8987 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8992 memcpy (src - off, src, 8);
8996 toc->rawsize = toc->size;
8997 toc->size = src - contents - off;
8999 /* Adjust addends for relocs against the toc section sym,
9000 and optimize any accesses we can. */
9001 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9003 if (sec->reloc_count == 0
9004 || discarded_section (sec))
9007 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9009 if (relstart == NULL)
9012 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9014 enum elf_ppc64_reloc_type r_type;
9015 unsigned long r_symndx;
9017 struct elf_link_hash_entry *h;
9020 r_type = ELF64_R_TYPE (rel->r_info);
9027 case R_PPC64_TOC16_LO:
9028 case R_PPC64_TOC16_HI:
9029 case R_PPC64_TOC16_HA:
9030 case R_PPC64_TOC16_DS:
9031 case R_PPC64_TOC16_LO_DS:
9032 case R_PPC64_ADDR64:
9036 r_symndx = ELF64_R_SYM (rel->r_info);
9037 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9045 val = h->root.u.def.value;
9048 val = sym->st_value;
9050 local_toc_syms = TRUE;
9053 val += rel->r_addend;
9055 if (val > toc->rawsize)
9057 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9059 else if ((skip[val >> 3] & can_optimize) != 0)
9061 Elf_Internal_Rela *tocrel
9062 = toc_relocs + (skip[val >> 3] >> 2);
9063 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9067 case R_PPC64_TOC16_HA:
9068 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9071 case R_PPC64_TOC16_LO_DS:
9072 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9076 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9078 info->callbacks->einfo
9079 (_("%P: %H: %s references "
9080 "optimized away TOC entry\n"),
9081 ibfd, sec, rel->r_offset,
9082 ppc64_elf_howto_table[r_type]->name);
9083 bfd_set_error (bfd_error_bad_value);
9086 rel->r_addend = tocrel->r_addend;
9087 elf_section_data (sec)->relocs = relstart;
9091 if (h != NULL || sym->st_value != 0)
9094 rel->r_addend -= skip[val >> 3];
9095 elf_section_data (sec)->relocs = relstart;
9098 if (elf_section_data (sec)->relocs != relstart)
9102 /* We shouldn't have local or global symbols defined in the TOC,
9103 but handle them anyway. */
9104 if (local_syms != NULL)
9105 for (sym = local_syms;
9106 sym < local_syms + symtab_hdr->sh_info;
9108 if (sym->st_value != 0
9109 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9113 if (sym->st_value > toc->rawsize)
9114 i = toc->rawsize >> 3;
9116 i = sym->st_value >> 3;
9118 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9121 (*_bfd_error_handler)
9122 (_("%s defined on removed toc entry"),
9123 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9126 while ((skip[i] & (ref_from_discarded | can_optimize)));
9127 sym->st_value = (bfd_vma) i << 3;
9130 sym->st_value -= skip[i];
9131 symtab_hdr->contents = (unsigned char *) local_syms;
9134 /* Adjust any global syms defined in this toc input section. */
9135 if (toc_inf.global_toc_syms)
9138 toc_inf.skip = skip;
9139 toc_inf.global_toc_syms = FALSE;
9140 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9144 if (toc->reloc_count != 0)
9146 Elf_Internal_Shdr *rel_hdr;
9147 Elf_Internal_Rela *wrel;
9150 /* Remove unused toc relocs, and adjust those we keep. */
9151 if (toc_relocs == NULL)
9152 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9154 if (toc_relocs == NULL)
9158 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9159 if ((skip[rel->r_offset >> 3]
9160 & (ref_from_discarded | can_optimize)) == 0)
9162 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9163 wrel->r_info = rel->r_info;
9164 wrel->r_addend = rel->r_addend;
9167 else if (!dec_dynrel_count (rel->r_info, toc, info,
9168 &local_syms, NULL, NULL))
9171 elf_section_data (toc)->relocs = toc_relocs;
9172 toc->reloc_count = wrel - toc_relocs;
9173 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9174 sz = rel_hdr->sh_entsize;
9175 rel_hdr->sh_size = toc->reloc_count * sz;
9178 else if (toc_relocs != NULL
9179 && elf_section_data (toc)->relocs != toc_relocs)
9182 if (local_syms != NULL
9183 && symtab_hdr->contents != (unsigned char *) local_syms)
9185 if (!info->keep_memory)
9188 symtab_hdr->contents = (unsigned char *) local_syms;
9196 /* Return true iff input section I references the TOC using
9197 instructions limited to +/-32k offsets. */
9200 ppc64_elf_has_small_toc_reloc (asection *i)
9202 return (is_ppc64_elf (i->owner)
9203 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9206 /* Allocate space for one GOT entry. */
9209 allocate_got (struct elf_link_hash_entry *h,
9210 struct bfd_link_info *info,
9211 struct got_entry *gent)
9213 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9215 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9216 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9218 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9219 ? 2 : 1) * sizeof (Elf64_External_Rela);
9220 asection *got = ppc64_elf_tdata (gent->owner)->got;
9222 gent->got.offset = got->size;
9223 got->size += entsize;
9225 dyn = htab->elf.dynamic_sections_created;
9226 if (h->type == STT_GNU_IFUNC)
9228 htab->elf.irelplt->size += rentsize;
9229 htab->got_reli_size += rentsize;
9231 else if ((info->shared
9232 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9233 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9234 || h->root.type != bfd_link_hash_undefweak))
9236 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9237 relgot->size += rentsize;
9241 /* This function merges got entries in the same toc group. */
9244 merge_got_entries (struct got_entry **pent)
9246 struct got_entry *ent, *ent2;
9248 for (ent = *pent; ent != NULL; ent = ent->next)
9249 if (!ent->is_indirect)
9250 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9251 if (!ent2->is_indirect
9252 && ent2->addend == ent->addend
9253 && ent2->tls_type == ent->tls_type
9254 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9256 ent2->is_indirect = TRUE;
9257 ent2->got.ent = ent;
9261 /* Allocate space in .plt, .got and associated reloc sections for
9265 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9267 struct bfd_link_info *info;
9268 struct ppc_link_hash_table *htab;
9270 struct ppc_link_hash_entry *eh;
9271 struct elf_dyn_relocs *p;
9272 struct got_entry **pgent, *gent;
9274 if (h->root.type == bfd_link_hash_indirect)
9277 info = (struct bfd_link_info *) inf;
9278 htab = ppc_hash_table (info);
9282 if ((htab->elf.dynamic_sections_created
9284 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9285 || h->type == STT_GNU_IFUNC)
9287 struct plt_entry *pent;
9288 bfd_boolean doneone = FALSE;
9289 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9290 if (pent->plt.refcount > 0)
9292 if (!htab->elf.dynamic_sections_created
9293 || h->dynindx == -1)
9296 pent->plt.offset = s->size;
9297 s->size += PLT_ENTRY_SIZE (htab);
9298 s = htab->elf.irelplt;
9302 /* If this is the first .plt entry, make room for the special
9306 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9308 pent->plt.offset = s->size;
9310 /* Make room for this entry. */
9311 s->size += PLT_ENTRY_SIZE (htab);
9313 /* Make room for the .glink code. */
9316 s->size += GLINK_CALL_STUB_SIZE;
9319 /* We need bigger stubs past index 32767. */
9320 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9327 /* We also need to make an entry in the .rela.plt section. */
9328 s = htab->elf.srelplt;
9330 s->size += sizeof (Elf64_External_Rela);
9334 pent->plt.offset = (bfd_vma) -1;
9337 h->plt.plist = NULL;
9343 h->plt.plist = NULL;
9347 eh = (struct ppc_link_hash_entry *) h;
9348 /* Run through the TLS GD got entries first if we're changing them
9350 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9351 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9352 if (gent->got.refcount > 0
9353 && (gent->tls_type & TLS_GD) != 0)
9355 /* This was a GD entry that has been converted to TPREL. If
9356 there happens to be a TPREL entry we can use that one. */
9357 struct got_entry *ent;
9358 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9359 if (ent->got.refcount > 0
9360 && (ent->tls_type & TLS_TPREL) != 0
9361 && ent->addend == gent->addend
9362 && ent->owner == gent->owner)
9364 gent->got.refcount = 0;
9368 /* If not, then we'll be using our own TPREL entry. */
9369 if (gent->got.refcount != 0)
9370 gent->tls_type = TLS_TLS | TLS_TPREL;
9373 /* Remove any list entry that won't generate a word in the GOT before
9374 we call merge_got_entries. Otherwise we risk merging to empty
9376 pgent = &h->got.glist;
9377 while ((gent = *pgent) != NULL)
9378 if (gent->got.refcount > 0)
9380 if ((gent->tls_type & TLS_LD) != 0
9383 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9384 *pgent = gent->next;
9387 pgent = &gent->next;
9390 *pgent = gent->next;
9392 if (!htab->do_multi_toc)
9393 merge_got_entries (&h->got.glist);
9395 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9396 if (!gent->is_indirect)
9398 /* Make sure this symbol is output as a dynamic symbol.
9399 Undefined weak syms won't yet be marked as dynamic,
9400 nor will all TLS symbols. */
9401 if (h->dynindx == -1
9403 && h->type != STT_GNU_IFUNC
9404 && htab->elf.dynamic_sections_created)
9406 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9410 if (!is_ppc64_elf (gent->owner))
9413 allocate_got (h, info, gent);
9416 if (eh->dyn_relocs == NULL
9417 || (!htab->elf.dynamic_sections_created
9418 && h->type != STT_GNU_IFUNC))
9421 /* In the shared -Bsymbolic case, discard space allocated for
9422 dynamic pc-relative relocs against symbols which turn out to be
9423 defined in regular objects. For the normal shared case, discard
9424 space for relocs that have become local due to symbol visibility
9429 /* Relocs that use pc_count are those that appear on a call insn,
9430 or certain REL relocs (see must_be_dyn_reloc) that can be
9431 generated via assembly. We want calls to protected symbols to
9432 resolve directly to the function rather than going via the plt.
9433 If people want function pointer comparisons to work as expected
9434 then they should avoid writing weird assembly. */
9435 if (SYMBOL_CALLS_LOCAL (info, h))
9437 struct elf_dyn_relocs **pp;
9439 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9441 p->count -= p->pc_count;
9450 /* Also discard relocs on undefined weak syms with non-default
9452 if (eh->dyn_relocs != NULL
9453 && h->root.type == bfd_link_hash_undefweak)
9455 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9456 eh->dyn_relocs = NULL;
9458 /* Make sure this symbol is output as a dynamic symbol.
9459 Undefined weak syms won't yet be marked as dynamic. */
9460 else if (h->dynindx == -1
9461 && !h->forced_local)
9463 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9468 else if (h->type == STT_GNU_IFUNC)
9470 if (!h->non_got_ref)
9471 eh->dyn_relocs = NULL;
9473 else if (ELIMINATE_COPY_RELOCS)
9475 /* For the non-shared case, discard space for relocs against
9476 symbols which turn out to need copy relocs or are not
9482 /* Make sure this symbol is output as a dynamic symbol.
9483 Undefined weak syms won't yet be marked as dynamic. */
9484 if (h->dynindx == -1
9485 && !h->forced_local)
9487 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9491 /* If that succeeded, we know we'll be keeping all the
9493 if (h->dynindx != -1)
9497 eh->dyn_relocs = NULL;
9502 /* Finally, allocate space. */
9503 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9505 asection *sreloc = elf_section_data (p->sec)->sreloc;
9506 if (eh->elf.type == STT_GNU_IFUNC)
9507 sreloc = htab->elf.irelplt;
9508 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9514 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9515 to set up space for global entry stubs. These are put in glink,
9516 after the branch table. */
9519 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9521 struct bfd_link_info *info;
9522 struct ppc_link_hash_table *htab;
9523 struct plt_entry *pent;
9526 if (h->root.type == bfd_link_hash_indirect)
9529 if (!h->pointer_equality_needed)
9536 htab = ppc_hash_table (info);
9541 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9542 if (pent->plt.offset != (bfd_vma) -1
9543 && pent->addend == 0)
9545 /* For ELFv2, if this symbol is not defined in a regular file
9546 and we are not generating a shared library or pie, then we
9547 need to define the symbol in the executable on a call stub.
9548 This is to avoid text relocations. */
9549 s->size = (s->size + 15) & -16;
9550 h->root.u.def.section = s;
9551 h->root.u.def.value = s->size;
9558 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9559 read-only sections. */
9562 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9564 if (h->root.type == bfd_link_hash_indirect)
9567 if (readonly_dynrelocs (h))
9569 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9571 /* Not an error, just cut short the traversal. */
9577 /* Set the sizes of the dynamic sections. */
9580 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9581 struct bfd_link_info *info)
9583 struct ppc_link_hash_table *htab;
9588 struct got_entry *first_tlsld;
9590 htab = ppc_hash_table (info);
9594 dynobj = htab->elf.dynobj;
9598 if (htab->elf.dynamic_sections_created)
9600 /* Set the contents of the .interp section to the interpreter. */
9601 if (info->executable)
9603 s = bfd_get_linker_section (dynobj, ".interp");
9606 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9607 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9611 /* Set up .got offsets for local syms, and space for local dynamic
9613 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9615 struct got_entry **lgot_ents;
9616 struct got_entry **end_lgot_ents;
9617 struct plt_entry **local_plt;
9618 struct plt_entry **end_local_plt;
9619 unsigned char *lgot_masks;
9620 bfd_size_type locsymcount;
9621 Elf_Internal_Shdr *symtab_hdr;
9623 if (!is_ppc64_elf (ibfd))
9626 for (s = ibfd->sections; s != NULL; s = s->next)
9628 struct ppc_dyn_relocs *p;
9630 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9632 if (!bfd_is_abs_section (p->sec)
9633 && bfd_is_abs_section (p->sec->output_section))
9635 /* Input section has been discarded, either because
9636 it is a copy of a linkonce section or due to
9637 linker script /DISCARD/, so we'll be discarding
9640 else if (p->count != 0)
9642 asection *srel = elf_section_data (p->sec)->sreloc;
9644 srel = htab->elf.irelplt;
9645 srel->size += p->count * sizeof (Elf64_External_Rela);
9646 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9647 info->flags |= DF_TEXTREL;
9652 lgot_ents = elf_local_got_ents (ibfd);
9656 symtab_hdr = &elf_symtab_hdr (ibfd);
9657 locsymcount = symtab_hdr->sh_info;
9658 end_lgot_ents = lgot_ents + locsymcount;
9659 local_plt = (struct plt_entry **) end_lgot_ents;
9660 end_local_plt = local_plt + locsymcount;
9661 lgot_masks = (unsigned char *) end_local_plt;
9662 s = ppc64_elf_tdata (ibfd)->got;
9663 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9665 struct got_entry **pent, *ent;
9668 while ((ent = *pent) != NULL)
9669 if (ent->got.refcount > 0)
9671 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9673 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9678 unsigned int ent_size = 8;
9679 unsigned int rel_size = sizeof (Elf64_External_Rela);
9681 ent->got.offset = s->size;
9682 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9687 s->size += ent_size;
9688 if ((*lgot_masks & PLT_IFUNC) != 0)
9690 htab->elf.irelplt->size += rel_size;
9691 htab->got_reli_size += rel_size;
9693 else if (info->shared)
9695 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9696 srel->size += rel_size;
9705 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9706 for (; local_plt < end_local_plt; ++local_plt)
9708 struct plt_entry *ent;
9710 for (ent = *local_plt; ent != NULL; ent = ent->next)
9711 if (ent->plt.refcount > 0)
9714 ent->plt.offset = s->size;
9715 s->size += PLT_ENTRY_SIZE (htab);
9717 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9720 ent->plt.offset = (bfd_vma) -1;
9724 /* Allocate global sym .plt and .got entries, and space for global
9725 sym dynamic relocs. */
9726 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9727 /* Stash the end of glink branch table. */
9728 if (htab->glink != NULL)
9729 htab->glink->rawsize = htab->glink->size;
9731 if (!htab->opd_abi && !info->shared)
9732 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9735 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9737 struct got_entry *ent;
9739 if (!is_ppc64_elf (ibfd))
9742 ent = ppc64_tlsld_got (ibfd);
9743 if (ent->got.refcount > 0)
9745 if (!htab->do_multi_toc && first_tlsld != NULL)
9747 ent->is_indirect = TRUE;
9748 ent->got.ent = first_tlsld;
9752 if (first_tlsld == NULL)
9754 s = ppc64_elf_tdata (ibfd)->got;
9755 ent->got.offset = s->size;
9760 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9761 srel->size += sizeof (Elf64_External_Rela);
9766 ent->got.offset = (bfd_vma) -1;
9769 /* We now have determined the sizes of the various dynamic sections.
9770 Allocate memory for them. */
9772 for (s = dynobj->sections; s != NULL; s = s->next)
9774 if ((s->flags & SEC_LINKER_CREATED) == 0)
9777 if (s == htab->brlt || s == htab->relbrlt)
9778 /* These haven't been allocated yet; don't strip. */
9780 else if (s == htab->elf.sgot
9781 || s == htab->elf.splt
9782 || s == htab->elf.iplt
9784 || s == htab->dynbss)
9786 /* Strip this section if we don't need it; see the
9789 else if (s == htab->glink_eh_frame)
9791 if (!bfd_is_abs_section (s->output_section))
9792 /* Not sized yet. */
9795 else if (CONST_STRNEQ (s->name, ".rela"))
9799 if (s != htab->elf.srelplt)
9802 /* We use the reloc_count field as a counter if we need
9803 to copy relocs into the output file. */
9809 /* It's not one of our sections, so don't allocate space. */
9815 /* If we don't need this section, strip it from the
9816 output file. This is mostly to handle .rela.bss and
9817 .rela.plt. We must create both sections in
9818 create_dynamic_sections, because they must be created
9819 before the linker maps input sections to output
9820 sections. The linker does that before
9821 adjust_dynamic_symbol is called, and it is that
9822 function which decides whether anything needs to go
9823 into these sections. */
9824 s->flags |= SEC_EXCLUDE;
9828 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9831 /* Allocate memory for the section contents. We use bfd_zalloc
9832 here in case unused entries are not reclaimed before the
9833 section's contents are written out. This should not happen,
9834 but this way if it does we get a R_PPC64_NONE reloc in .rela
9835 sections instead of garbage.
9836 We also rely on the section contents being zero when writing
9838 s->contents = bfd_zalloc (dynobj, s->size);
9839 if (s->contents == NULL)
9843 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9845 if (!is_ppc64_elf (ibfd))
9848 s = ppc64_elf_tdata (ibfd)->got;
9849 if (s != NULL && s != htab->elf.sgot)
9852 s->flags |= SEC_EXCLUDE;
9855 s->contents = bfd_zalloc (ibfd, s->size);
9856 if (s->contents == NULL)
9860 s = ppc64_elf_tdata (ibfd)->relgot;
9864 s->flags |= SEC_EXCLUDE;
9867 s->contents = bfd_zalloc (ibfd, s->size);
9868 if (s->contents == NULL)
9876 if (htab->elf.dynamic_sections_created)
9878 bfd_boolean tls_opt;
9880 /* Add some entries to the .dynamic section. We fill in the
9881 values later, in ppc64_elf_finish_dynamic_sections, but we
9882 must add the entries now so that we get the correct size for
9883 the .dynamic section. The DT_DEBUG entry is filled in by the
9884 dynamic linker and used by the debugger. */
9885 #define add_dynamic_entry(TAG, VAL) \
9886 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9888 if (info->executable)
9890 if (!add_dynamic_entry (DT_DEBUG, 0))
9894 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9896 if (!add_dynamic_entry (DT_PLTGOT, 0)
9897 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9898 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9899 || !add_dynamic_entry (DT_JMPREL, 0)
9900 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9904 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9906 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9907 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9911 tls_opt = (!htab->no_tls_get_addr_opt
9912 && htab->tls_get_addr_fd != NULL
9913 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9914 if (tls_opt || !htab->opd_abi)
9916 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9922 if (!add_dynamic_entry (DT_RELA, 0)
9923 || !add_dynamic_entry (DT_RELASZ, 0)
9924 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9927 /* If any dynamic relocs apply to a read-only section,
9928 then we need a DT_TEXTREL entry. */
9929 if ((info->flags & DF_TEXTREL) == 0)
9930 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9932 if ((info->flags & DF_TEXTREL) != 0)
9934 if (!add_dynamic_entry (DT_TEXTREL, 0))
9939 #undef add_dynamic_entry
9944 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9947 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9949 if (h->plt.plist != NULL
9951 && !h->pointer_equality_needed)
9954 return _bfd_elf_hash_symbol (h);
9957 /* Determine the type of stub needed, if any, for a call. */
9959 static inline enum ppc_stub_type
9960 ppc_type_of_stub (asection *input_sec,
9961 const Elf_Internal_Rela *rel,
9962 struct ppc_link_hash_entry **hash,
9963 struct plt_entry **plt_ent,
9964 bfd_vma destination,
9965 unsigned long local_off)
9967 struct ppc_link_hash_entry *h = *hash;
9969 bfd_vma branch_offset;
9970 bfd_vma max_branch_offset;
9971 enum elf_ppc64_reloc_type r_type;
9975 struct plt_entry *ent;
9976 struct ppc_link_hash_entry *fdh = h;
9978 && h->oh->is_func_descriptor)
9980 fdh = ppc_follow_link (h->oh);
9984 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9985 if (ent->addend == rel->r_addend
9986 && ent->plt.offset != (bfd_vma) -1)
9989 return ppc_stub_plt_call;
9992 /* Here, we know we don't have a plt entry. If we don't have a
9993 either a defined function descriptor or a defined entry symbol
9994 in a regular object file, then it is pointless trying to make
9995 any other type of stub. */
9996 if (!is_static_defined (&fdh->elf)
9997 && !is_static_defined (&h->elf))
9998 return ppc_stub_none;
10000 else if (elf_local_got_ents (input_sec->owner) != NULL)
10002 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10003 struct plt_entry **local_plt = (struct plt_entry **)
10004 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10005 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10007 if (local_plt[r_symndx] != NULL)
10009 struct plt_entry *ent;
10011 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10012 if (ent->addend == rel->r_addend
10013 && ent->plt.offset != (bfd_vma) -1)
10016 return ppc_stub_plt_call;
10021 /* Determine where the call point is. */
10022 location = (input_sec->output_offset
10023 + input_sec->output_section->vma
10026 branch_offset = destination - location;
10027 r_type = ELF64_R_TYPE (rel->r_info);
10029 /* Determine if a long branch stub is needed. */
10030 max_branch_offset = 1 << 25;
10031 if (r_type != R_PPC64_REL24)
10032 max_branch_offset = 1 << 15;
10034 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10035 /* We need a stub. Figure out whether a long_branch or plt_branch
10036 is needed later. */
10037 return ppc_stub_long_branch;
10039 return ppc_stub_none;
10042 /* With power7 weakly ordered memory model, it is possible for ld.so
10043 to update a plt entry in one thread and have another thread see a
10044 stale zero toc entry. To avoid this we need some sort of acquire
10045 barrier in the call stub. One solution is to make the load of the
10046 toc word seem to appear to depend on the load of the function entry
10047 word. Another solution is to test for r2 being zero, and branch to
10048 the appropriate glink entry if so.
10050 . fake dep barrier compare
10051 . ld 12,xxx(2) ld 12,xxx(2)
10052 . mtctr 12 mtctr 12
10053 . xor 11,12,12 ld 2,xxx+8(2)
10054 . add 2,2,11 cmpldi 2,0
10055 . ld 2,xxx+8(2) bnectr+
10056 . bctr b <glink_entry>
10058 The solution involving the compare turns out to be faster, so
10059 that's what we use unless the branch won't reach. */
10061 #define ALWAYS_USE_FAKE_DEP 0
10062 #define ALWAYS_EMIT_R2SAVE 0
10064 #define PPC_LO(v) ((v) & 0xffff)
10065 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10066 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10068 static inline unsigned int
10069 plt_stub_size (struct ppc_link_hash_table *htab,
10070 struct ppc_stub_hash_entry *stub_entry,
10073 unsigned size = 12;
10075 if (ALWAYS_EMIT_R2SAVE
10076 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10078 if (PPC_HA (off) != 0)
10083 if (htab->plt_static_chain)
10085 if (htab->plt_thread_safe)
10087 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10090 if (stub_entry->h != NULL
10091 && (stub_entry->h == htab->tls_get_addr_fd
10092 || stub_entry->h == htab->tls_get_addr)
10093 && !htab->no_tls_get_addr_opt)
10098 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10099 then return the padding needed to do so. */
10100 static inline unsigned int
10101 plt_stub_pad (struct ppc_link_hash_table *htab,
10102 struct ppc_stub_hash_entry *stub_entry,
10105 int stub_align = 1 << htab->plt_stub_align;
10106 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10107 bfd_vma stub_off = stub_entry->stub_sec->size;
10109 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10110 > (stub_size & -stub_align))
10111 return stub_align - (stub_off & (stub_align - 1));
10115 /* Build a .plt call stub. */
10117 static inline bfd_byte *
10118 build_plt_stub (struct ppc_link_hash_table *htab,
10119 struct ppc_stub_hash_entry *stub_entry,
10120 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10122 bfd *obfd = htab->stub_bfd;
10123 bfd_boolean plt_load_toc = htab->opd_abi;
10124 bfd_boolean plt_static_chain = htab->plt_static_chain;
10125 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10126 bfd_boolean use_fake_dep = plt_thread_safe;
10127 bfd_vma cmp_branch_off = 0;
10129 if (!ALWAYS_USE_FAKE_DEP
10132 && !(stub_entry->h != NULL
10133 && (stub_entry->h == htab->tls_get_addr_fd
10134 || stub_entry->h == htab->tls_get_addr)
10135 && !htab->no_tls_get_addr_opt))
10137 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10138 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10139 / PLT_ENTRY_SIZE (htab));
10140 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10143 if (pltindex > 32768)
10144 glinkoff += (pltindex - 32768) * 4;
10146 + htab->glink->output_offset
10147 + htab->glink->output_section->vma);
10148 from = (p - stub_entry->stub_sec->contents
10149 + 4 * (ALWAYS_EMIT_R2SAVE
10150 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10151 + 4 * (PPC_HA (offset) != 0)
10152 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10153 != PPC_HA (offset))
10154 + 4 * (plt_static_chain != 0)
10156 + stub_entry->stub_sec->output_offset
10157 + stub_entry->stub_sec->output_section->vma);
10158 cmp_branch_off = to - from;
10159 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10162 if (PPC_HA (offset) != 0)
10166 if (ALWAYS_EMIT_R2SAVE
10167 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10168 r[0].r_offset += 4;
10169 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10170 r[1].r_offset = r[0].r_offset + 4;
10171 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10172 r[1].r_addend = r[0].r_addend;
10175 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10177 r[2].r_offset = r[1].r_offset + 4;
10178 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10179 r[2].r_addend = r[0].r_addend;
10183 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10184 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10185 r[2].r_addend = r[0].r_addend + 8;
10186 if (plt_static_chain)
10188 r[3].r_offset = r[2].r_offset + 4;
10189 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10190 r[3].r_addend = r[0].r_addend + 16;
10195 if (ALWAYS_EMIT_R2SAVE
10196 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10197 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10198 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10199 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10201 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10203 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10206 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10211 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10212 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10214 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10215 if (plt_static_chain)
10216 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10223 if (ALWAYS_EMIT_R2SAVE
10224 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10225 r[0].r_offset += 4;
10226 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10229 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10231 r[1].r_offset = r[0].r_offset + 4;
10232 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10233 r[1].r_addend = r[0].r_addend;
10237 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10238 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10239 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10240 if (plt_static_chain)
10242 r[2].r_offset = r[1].r_offset + 4;
10243 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10244 r[2].r_addend = r[0].r_addend + 8;
10249 if (ALWAYS_EMIT_R2SAVE
10250 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10251 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10252 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10254 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10256 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10259 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10264 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10265 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10267 if (plt_static_chain)
10268 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10269 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10272 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10274 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10275 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10276 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10279 bfd_put_32 (obfd, BCTR, p), p += 4;
10283 /* Build a special .plt call stub for __tls_get_addr. */
10285 #define LD_R11_0R3 0xe9630000
10286 #define LD_R12_0R3 0xe9830000
10287 #define MR_R0_R3 0x7c601b78
10288 #define CMPDI_R11_0 0x2c2b0000
10289 #define ADD_R3_R12_R13 0x7c6c6a14
10290 #define BEQLR 0x4d820020
10291 #define MR_R3_R0 0x7c030378
10292 #define STD_R11_0R1 0xf9610000
10293 #define BCTRL 0x4e800421
10294 #define LD_R11_0R1 0xe9610000
10295 #define MTLR_R11 0x7d6803a6
10297 static inline bfd_byte *
10298 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10299 struct ppc_stub_hash_entry *stub_entry,
10300 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10302 bfd *obfd = htab->stub_bfd;
10304 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10305 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10306 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10307 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10308 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10309 bfd_put_32 (obfd, BEQLR, p), p += 4;
10310 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10311 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10312 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10315 r[0].r_offset += 9 * 4;
10316 p = build_plt_stub (htab, stub_entry, p, offset, r);
10317 bfd_put_32 (obfd, BCTRL, p - 4);
10319 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10320 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10321 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10322 bfd_put_32 (obfd, BLR, p), p += 4;
10327 static Elf_Internal_Rela *
10328 get_relocs (asection *sec, int count)
10330 Elf_Internal_Rela *relocs;
10331 struct bfd_elf_section_data *elfsec_data;
10333 elfsec_data = elf_section_data (sec);
10334 relocs = elfsec_data->relocs;
10335 if (relocs == NULL)
10337 bfd_size_type relsize;
10338 relsize = sec->reloc_count * sizeof (*relocs);
10339 relocs = bfd_alloc (sec->owner, relsize);
10340 if (relocs == NULL)
10342 elfsec_data->relocs = relocs;
10343 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10344 sizeof (Elf_Internal_Shdr));
10345 if (elfsec_data->rela.hdr == NULL)
10347 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10348 * sizeof (Elf64_External_Rela));
10349 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10350 sec->reloc_count = 0;
10352 relocs += sec->reloc_count;
10353 sec->reloc_count += count;
10358 get_r2off (struct bfd_link_info *info,
10359 struct ppc_stub_hash_entry *stub_entry)
10361 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10362 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10366 /* Support linking -R objects. Get the toc pointer from the
10369 if (!htab->opd_abi)
10371 asection *opd = stub_entry->h->elf.root.u.def.section;
10372 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10374 if (strcmp (opd->name, ".opd") != 0
10375 || opd->reloc_count != 0)
10377 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10378 stub_entry->h->elf.root.root.string);
10379 bfd_set_error (bfd_error_bad_value);
10382 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10384 r2off = bfd_get_64 (opd->owner, buf);
10385 r2off -= elf_gp (info->output_bfd);
10387 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10392 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10394 struct ppc_stub_hash_entry *stub_entry;
10395 struct ppc_branch_hash_entry *br_entry;
10396 struct bfd_link_info *info;
10397 struct ppc_link_hash_table *htab;
10402 Elf_Internal_Rela *r;
10405 /* Massage our args to the form they really have. */
10406 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10409 htab = ppc_hash_table (info);
10413 /* Make a note of the offset within the stubs for this entry. */
10414 stub_entry->stub_offset = stub_entry->stub_sec->size;
10415 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10417 htab->stub_count[stub_entry->stub_type - 1] += 1;
10418 switch (stub_entry->stub_type)
10420 case ppc_stub_long_branch:
10421 case ppc_stub_long_branch_r2off:
10422 /* Branches are relative. This is where we are going to. */
10423 dest = (stub_entry->target_value
10424 + stub_entry->target_section->output_offset
10425 + stub_entry->target_section->output_section->vma);
10426 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10429 /* And this is where we are coming from. */
10430 off -= (stub_entry->stub_offset
10431 + stub_entry->stub_sec->output_offset
10432 + stub_entry->stub_sec->output_section->vma);
10435 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10437 bfd_vma r2off = get_r2off (info, stub_entry);
10441 htab->stub_error = TRUE;
10444 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10447 if (PPC_HA (r2off) != 0)
10450 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10453 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10457 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10459 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10461 info->callbacks->einfo
10462 (_("%P: long branch stub `%s' offset overflow\n"),
10463 stub_entry->root.string);
10464 htab->stub_error = TRUE;
10468 if (info->emitrelocations)
10470 r = get_relocs (stub_entry->stub_sec, 1);
10473 r->r_offset = loc - stub_entry->stub_sec->contents;
10474 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10475 r->r_addend = dest;
10476 if (stub_entry->h != NULL)
10478 struct elf_link_hash_entry **hashes;
10479 unsigned long symndx;
10480 struct ppc_link_hash_entry *h;
10482 hashes = elf_sym_hashes (htab->stub_bfd);
10483 if (hashes == NULL)
10485 bfd_size_type hsize;
10487 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10488 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10489 if (hashes == NULL)
10491 elf_sym_hashes (htab->stub_bfd) = hashes;
10492 htab->stub_globals = 1;
10494 symndx = htab->stub_globals++;
10496 hashes[symndx] = &h->elf;
10497 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10498 if (h->oh != NULL && h->oh->is_func)
10499 h = ppc_follow_link (h->oh);
10500 if (h->elf.root.u.def.section != stub_entry->target_section)
10501 /* H is an opd symbol. The addend must be zero. */
10505 off = (h->elf.root.u.def.value
10506 + h->elf.root.u.def.section->output_offset
10507 + h->elf.root.u.def.section->output_section->vma);
10508 r->r_addend -= off;
10514 case ppc_stub_plt_branch:
10515 case ppc_stub_plt_branch_r2off:
10516 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10517 stub_entry->root.string + 9,
10519 if (br_entry == NULL)
10521 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10522 stub_entry->root.string);
10523 htab->stub_error = TRUE;
10527 dest = (stub_entry->target_value
10528 + stub_entry->target_section->output_offset
10529 + stub_entry->target_section->output_section->vma);
10530 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10531 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10533 bfd_put_64 (htab->brlt->owner, dest,
10534 htab->brlt->contents + br_entry->offset);
10536 if (br_entry->iter == htab->stub_iteration)
10538 br_entry->iter = 0;
10540 if (htab->relbrlt != NULL)
10542 /* Create a reloc for the branch lookup table entry. */
10543 Elf_Internal_Rela rela;
10546 rela.r_offset = (br_entry->offset
10547 + htab->brlt->output_offset
10548 + htab->brlt->output_section->vma);
10549 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10550 rela.r_addend = dest;
10552 rl = htab->relbrlt->contents;
10553 rl += (htab->relbrlt->reloc_count++
10554 * sizeof (Elf64_External_Rela));
10555 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10557 else if (info->emitrelocations)
10559 r = get_relocs (htab->brlt, 1);
10562 /* brlt, being SEC_LINKER_CREATED does not go through the
10563 normal reloc processing. Symbols and offsets are not
10564 translated from input file to output file form, so
10565 set up the offset per the output file. */
10566 r->r_offset = (br_entry->offset
10567 + htab->brlt->output_offset
10568 + htab->brlt->output_section->vma);
10569 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10570 r->r_addend = dest;
10574 dest = (br_entry->offset
10575 + htab->brlt->output_offset
10576 + htab->brlt->output_section->vma);
10579 - elf_gp (htab->brlt->output_section->owner)
10580 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10582 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10584 info->callbacks->einfo
10585 (_("%P: linkage table error against `%T'\n"),
10586 stub_entry->root.string);
10587 bfd_set_error (bfd_error_bad_value);
10588 htab->stub_error = TRUE;
10592 if (info->emitrelocations)
10594 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10597 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10598 if (bfd_big_endian (info->output_bfd))
10599 r[0].r_offset += 2;
10600 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10601 r[0].r_offset += 4;
10602 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10603 r[0].r_addend = dest;
10604 if (PPC_HA (off) != 0)
10606 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10607 r[1].r_offset = r[0].r_offset + 4;
10608 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10609 r[1].r_addend = r[0].r_addend;
10613 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10615 if (PPC_HA (off) != 0)
10618 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10620 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10625 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10630 bfd_vma r2off = get_r2off (info, stub_entry);
10632 if (r2off == 0 && htab->opd_abi)
10634 htab->stub_error = TRUE;
10638 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10641 if (PPC_HA (off) != 0)
10644 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10646 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10649 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10651 if (PPC_HA (r2off) != 0)
10655 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10657 if (PPC_LO (r2off) != 0)
10661 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10665 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10667 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10670 case ppc_stub_plt_call:
10671 case ppc_stub_plt_call_r2save:
10672 if (stub_entry->h != NULL
10673 && stub_entry->h->is_func_descriptor
10674 && stub_entry->h->oh != NULL)
10676 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10678 /* If the old-ABI "dot-symbol" is undefined make it weak so
10679 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10680 FIXME: We used to define the symbol on one of the call
10681 stubs instead, which is why we test symbol section id
10682 against htab->top_id in various places. Likely all
10683 these checks could now disappear. */
10684 if (fh->elf.root.type == bfd_link_hash_undefined)
10685 fh->elf.root.type = bfd_link_hash_undefweak;
10686 /* Stop undo_symbol_twiddle changing it back to undefined. */
10687 fh->was_undefined = 0;
10690 /* Now build the stub. */
10691 dest = stub_entry->plt_ent->plt.offset & ~1;
10692 if (dest >= (bfd_vma) -2)
10695 plt = htab->elf.splt;
10696 if (!htab->elf.dynamic_sections_created
10697 || stub_entry->h == NULL
10698 || stub_entry->h->elf.dynindx == -1)
10699 plt = htab->elf.iplt;
10701 dest += plt->output_offset + plt->output_section->vma;
10703 if (stub_entry->h == NULL
10704 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10706 Elf_Internal_Rela rela;
10709 rela.r_offset = dest;
10711 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10713 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10714 rela.r_addend = (stub_entry->target_value
10715 + stub_entry->target_section->output_offset
10716 + stub_entry->target_section->output_section->vma);
10718 rl = (htab->elf.irelplt->contents
10719 + (htab->elf.irelplt->reloc_count++
10720 * sizeof (Elf64_External_Rela)));
10721 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10722 stub_entry->plt_ent->plt.offset |= 1;
10726 - elf_gp (plt->output_section->owner)
10727 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10729 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10731 info->callbacks->einfo
10732 (_("%P: linkage table error against `%T'\n"),
10733 stub_entry->h != NULL
10734 ? stub_entry->h->elf.root.root.string
10736 bfd_set_error (bfd_error_bad_value);
10737 htab->stub_error = TRUE;
10741 if (htab->plt_stub_align != 0)
10743 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10745 stub_entry->stub_sec->size += pad;
10746 stub_entry->stub_offset = stub_entry->stub_sec->size;
10751 if (info->emitrelocations)
10753 r = get_relocs (stub_entry->stub_sec,
10755 + (PPC_HA (off) != 0)
10756 + (htab->plt_static_chain
10757 && PPC_HA (off + 16) == PPC_HA (off))));
10760 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10761 if (bfd_big_endian (info->output_bfd))
10762 r[0].r_offset += 2;
10763 r[0].r_addend = dest;
10765 if (stub_entry->h != NULL
10766 && (stub_entry->h == htab->tls_get_addr_fd
10767 || stub_entry->h == htab->tls_get_addr)
10768 && !htab->no_tls_get_addr_opt)
10769 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10771 p = build_plt_stub (htab, stub_entry, loc, off, r);
10780 stub_entry->stub_sec->size += size;
10782 if (htab->emit_stub_syms)
10784 struct elf_link_hash_entry *h;
10787 const char *const stub_str[] = { "long_branch",
10788 "long_branch_r2off",
10790 "plt_branch_r2off",
10794 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10795 len2 = strlen (stub_entry->root.string);
10796 name = bfd_malloc (len1 + len2 + 2);
10799 memcpy (name, stub_entry->root.string, 9);
10800 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10801 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10802 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10805 if (h->root.type == bfd_link_hash_new)
10807 h->root.type = bfd_link_hash_defined;
10808 h->root.u.def.section = stub_entry->stub_sec;
10809 h->root.u.def.value = stub_entry->stub_offset;
10810 h->ref_regular = 1;
10811 h->def_regular = 1;
10812 h->ref_regular_nonweak = 1;
10813 h->forced_local = 1;
10821 /* As above, but don't actually build the stub. Just bump offset so
10822 we know stub section sizes, and select plt_branch stubs where
10823 long_branch stubs won't do. */
10826 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10828 struct ppc_stub_hash_entry *stub_entry;
10829 struct bfd_link_info *info;
10830 struct ppc_link_hash_table *htab;
10834 /* Massage our args to the form they really have. */
10835 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10838 htab = ppc_hash_table (info);
10842 if (stub_entry->stub_type == ppc_stub_plt_call
10843 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10846 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10847 if (off >= (bfd_vma) -2)
10849 plt = htab->elf.splt;
10850 if (!htab->elf.dynamic_sections_created
10851 || stub_entry->h == NULL
10852 || stub_entry->h->elf.dynindx == -1)
10853 plt = htab->elf.iplt;
10854 off += (plt->output_offset
10855 + plt->output_section->vma
10856 - elf_gp (plt->output_section->owner)
10857 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10859 size = plt_stub_size (htab, stub_entry, off);
10860 if (htab->plt_stub_align)
10861 size += plt_stub_pad (htab, stub_entry, off);
10862 if (info->emitrelocations)
10864 stub_entry->stub_sec->reloc_count
10865 += ((PPC_HA (off) != 0)
10867 ? 2 + (htab->plt_static_chain
10868 && PPC_HA (off + 16) == PPC_HA (off))
10870 stub_entry->stub_sec->flags |= SEC_RELOC;
10875 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10878 bfd_vma local_off = 0;
10880 off = (stub_entry->target_value
10881 + stub_entry->target_section->output_offset
10882 + stub_entry->target_section->output_section->vma);
10883 off -= (stub_entry->stub_sec->size
10884 + stub_entry->stub_sec->output_offset
10885 + stub_entry->stub_sec->output_section->vma);
10887 /* Reset the stub type from the plt variant in case we now
10888 can reach with a shorter stub. */
10889 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10890 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10893 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10895 r2off = get_r2off (info, stub_entry);
10896 if (r2off == 0 && htab->opd_abi)
10898 htab->stub_error = TRUE;
10902 if (PPC_HA (r2off) != 0)
10907 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10909 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10910 Do the same for -R objects without function descriptors. */
10911 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10912 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10915 struct ppc_branch_hash_entry *br_entry;
10917 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10918 stub_entry->root.string + 9,
10920 if (br_entry == NULL)
10922 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10923 stub_entry->root.string);
10924 htab->stub_error = TRUE;
10928 if (br_entry->iter != htab->stub_iteration)
10930 br_entry->iter = htab->stub_iteration;
10931 br_entry->offset = htab->brlt->size;
10932 htab->brlt->size += 8;
10934 if (htab->relbrlt != NULL)
10935 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10936 else if (info->emitrelocations)
10938 htab->brlt->reloc_count += 1;
10939 htab->brlt->flags |= SEC_RELOC;
10943 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10944 off = (br_entry->offset
10945 + htab->brlt->output_offset
10946 + htab->brlt->output_section->vma
10947 - elf_gp (htab->brlt->output_section->owner)
10948 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10950 if (info->emitrelocations)
10952 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10953 stub_entry->stub_sec->flags |= SEC_RELOC;
10956 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10959 if (PPC_HA (off) != 0)
10965 if (PPC_HA (off) != 0)
10968 if (PPC_HA (r2off) != 0)
10970 if (PPC_LO (r2off) != 0)
10974 else if (info->emitrelocations)
10976 stub_entry->stub_sec->reloc_count += 1;
10977 stub_entry->stub_sec->flags |= SEC_RELOC;
10981 stub_entry->stub_sec->size += size;
10985 /* Set up various things so that we can make a list of input sections
10986 for each output section included in the link. Returns -1 on error,
10987 0 when no stubs will be needed, and 1 on success. */
10990 ppc64_elf_setup_section_lists
10991 (struct bfd_link_info *info,
10992 asection *(*add_stub_section) (const char *, asection *),
10993 void (*layout_sections_again) (void))
10996 int top_id, top_index, id;
10998 asection **input_list;
11000 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11004 /* Stash our params away. */
11005 htab->add_stub_section = add_stub_section;
11006 htab->layout_sections_again = layout_sections_again;
11008 /* Find the top input section id. */
11009 for (input_bfd = info->input_bfds, top_id = 3;
11011 input_bfd = input_bfd->link_next)
11013 for (section = input_bfd->sections;
11015 section = section->next)
11017 if (top_id < section->id)
11018 top_id = section->id;
11022 htab->top_id = top_id;
11023 amt = sizeof (struct map_stub) * (top_id + 1);
11024 htab->stub_group = bfd_zmalloc (amt);
11025 if (htab->stub_group == NULL)
11028 /* Set toc_off for com, und, abs and ind sections. */
11029 for (id = 0; id < 3; id++)
11030 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11032 /* We can't use output_bfd->section_count here to find the top output
11033 section index as some sections may have been removed, and
11034 strip_excluded_output_sections doesn't renumber the indices. */
11035 for (section = info->output_bfd->sections, top_index = 0;
11037 section = section->next)
11039 if (top_index < section->index)
11040 top_index = section->index;
11043 htab->top_index = top_index;
11044 amt = sizeof (asection *) * (top_index + 1);
11045 input_list = bfd_zmalloc (amt);
11046 htab->input_list = input_list;
11047 if (input_list == NULL)
11053 /* Set up for first pass at multitoc partitioning. */
11056 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11058 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11060 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11061 htab->toc_bfd = NULL;
11062 htab->toc_first_sec = NULL;
11065 /* The linker repeatedly calls this function for each TOC input section
11066 and linker generated GOT section. Group input bfds such that the toc
11067 within a group is less than 64k in size. */
11070 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11072 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11073 bfd_vma addr, off, limit;
11078 if (!htab->second_toc_pass)
11080 /* Keep track of the first .toc or .got section for this input bfd. */
11081 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11085 htab->toc_bfd = isec->owner;
11086 htab->toc_first_sec = isec;
11089 addr = isec->output_offset + isec->output_section->vma;
11090 off = addr - htab->toc_curr;
11091 limit = 0x80008000;
11092 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11094 if (off + isec->size > limit)
11096 addr = (htab->toc_first_sec->output_offset
11097 + htab->toc_first_sec->output_section->vma);
11098 htab->toc_curr = addr;
11101 /* toc_curr is the base address of this toc group. Set elf_gp
11102 for the input section to be the offset relative to the
11103 output toc base plus 0x8000. Making the input elf_gp an
11104 offset allows us to move the toc as a whole without
11105 recalculating input elf_gp. */
11106 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11107 off += TOC_BASE_OFF;
11109 /* Die if someone uses a linker script that doesn't keep input
11110 file .toc and .got together. */
11112 && elf_gp (isec->owner) != 0
11113 && elf_gp (isec->owner) != off)
11116 elf_gp (isec->owner) = off;
11120 /* During the second pass toc_first_sec points to the start of
11121 a toc group, and toc_curr is used to track the old elf_gp.
11122 We use toc_bfd to ensure we only look at each bfd once. */
11123 if (htab->toc_bfd == isec->owner)
11125 htab->toc_bfd = isec->owner;
11127 if (htab->toc_first_sec == NULL
11128 || htab->toc_curr != elf_gp (isec->owner))
11130 htab->toc_curr = elf_gp (isec->owner);
11131 htab->toc_first_sec = isec;
11133 addr = (htab->toc_first_sec->output_offset
11134 + htab->toc_first_sec->output_section->vma);
11135 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11136 elf_gp (isec->owner) = off;
11141 /* Called via elf_link_hash_traverse to merge GOT entries for global
11145 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11147 if (h->root.type == bfd_link_hash_indirect)
11150 merge_got_entries (&h->got.glist);
11155 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11159 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11161 struct got_entry *gent;
11163 if (h->root.type == bfd_link_hash_indirect)
11166 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11167 if (!gent->is_indirect)
11168 allocate_got (h, (struct bfd_link_info *) inf, gent);
11172 /* Called on the first multitoc pass after the last call to
11173 ppc64_elf_next_toc_section. This function removes duplicate GOT
11177 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11179 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11180 struct bfd *ibfd, *ibfd2;
11181 bfd_boolean done_something;
11183 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11185 if (!htab->do_multi_toc)
11188 /* Merge global sym got entries within a toc group. */
11189 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11191 /* And tlsld_got. */
11192 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11194 struct got_entry *ent, *ent2;
11196 if (!is_ppc64_elf (ibfd))
11199 ent = ppc64_tlsld_got (ibfd);
11200 if (!ent->is_indirect
11201 && ent->got.offset != (bfd_vma) -1)
11203 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11205 if (!is_ppc64_elf (ibfd2))
11208 ent2 = ppc64_tlsld_got (ibfd2);
11209 if (!ent2->is_indirect
11210 && ent2->got.offset != (bfd_vma) -1
11211 && elf_gp (ibfd2) == elf_gp (ibfd))
11213 ent2->is_indirect = TRUE;
11214 ent2->got.ent = ent;
11220 /* Zap sizes of got sections. */
11221 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11222 htab->elf.irelplt->size -= htab->got_reli_size;
11223 htab->got_reli_size = 0;
11225 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11227 asection *got, *relgot;
11229 if (!is_ppc64_elf (ibfd))
11232 got = ppc64_elf_tdata (ibfd)->got;
11235 got->rawsize = got->size;
11237 relgot = ppc64_elf_tdata (ibfd)->relgot;
11238 relgot->rawsize = relgot->size;
11243 /* Now reallocate the got, local syms first. We don't need to
11244 allocate section contents again since we never increase size. */
11245 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11247 struct got_entry **lgot_ents;
11248 struct got_entry **end_lgot_ents;
11249 struct plt_entry **local_plt;
11250 struct plt_entry **end_local_plt;
11251 unsigned char *lgot_masks;
11252 bfd_size_type locsymcount;
11253 Elf_Internal_Shdr *symtab_hdr;
11256 if (!is_ppc64_elf (ibfd))
11259 lgot_ents = elf_local_got_ents (ibfd);
11263 symtab_hdr = &elf_symtab_hdr (ibfd);
11264 locsymcount = symtab_hdr->sh_info;
11265 end_lgot_ents = lgot_ents + locsymcount;
11266 local_plt = (struct plt_entry **) end_lgot_ents;
11267 end_local_plt = local_plt + locsymcount;
11268 lgot_masks = (unsigned char *) end_local_plt;
11269 s = ppc64_elf_tdata (ibfd)->got;
11270 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11272 struct got_entry *ent;
11274 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11276 unsigned int ent_size = 8;
11277 unsigned int rel_size = sizeof (Elf64_External_Rela);
11279 ent->got.offset = s->size;
11280 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11285 s->size += ent_size;
11286 if ((*lgot_masks & PLT_IFUNC) != 0)
11288 htab->elf.irelplt->size += rel_size;
11289 htab->got_reli_size += rel_size;
11291 else if (info->shared)
11293 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11294 srel->size += rel_size;
11300 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11302 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11304 struct got_entry *ent;
11306 if (!is_ppc64_elf (ibfd))
11309 ent = ppc64_tlsld_got (ibfd);
11310 if (!ent->is_indirect
11311 && ent->got.offset != (bfd_vma) -1)
11313 asection *s = ppc64_elf_tdata (ibfd)->got;
11314 ent->got.offset = s->size;
11318 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11319 srel->size += sizeof (Elf64_External_Rela);
11324 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11325 if (!done_something)
11326 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11330 if (!is_ppc64_elf (ibfd))
11333 got = ppc64_elf_tdata (ibfd)->got;
11336 done_something = got->rawsize != got->size;
11337 if (done_something)
11342 if (done_something)
11343 (*htab->layout_sections_again) ();
11345 /* Set up for second pass over toc sections to recalculate elf_gp
11346 on input sections. */
11347 htab->toc_bfd = NULL;
11348 htab->toc_first_sec = NULL;
11349 htab->second_toc_pass = TRUE;
11350 return done_something;
11353 /* Called after second pass of multitoc partitioning. */
11356 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11358 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11360 /* After the second pass, toc_curr tracks the TOC offset used
11361 for code sections below in ppc64_elf_next_input_section. */
11362 htab->toc_curr = TOC_BASE_OFF;
11365 /* No toc references were found in ISEC. If the code in ISEC makes no
11366 calls, then there's no need to use toc adjusting stubs when branching
11367 into ISEC. Actually, indirect calls from ISEC are OK as they will
11368 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11369 needed, and 2 if a cyclical call-graph was found but no other reason
11370 for a stub was detected. If called from the top level, a return of
11371 2 means the same as a return of 0. */
11374 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11378 /* Mark this section as checked. */
11379 isec->call_check_done = 1;
11381 /* We know none of our code bearing sections will need toc stubs. */
11382 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11385 if (isec->size == 0)
11388 if (isec->output_section == NULL)
11392 if (isec->reloc_count != 0)
11394 Elf_Internal_Rela *relstart, *rel;
11395 Elf_Internal_Sym *local_syms;
11396 struct ppc_link_hash_table *htab;
11398 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11399 info->keep_memory);
11400 if (relstart == NULL)
11403 /* Look for branches to outside of this section. */
11405 htab = ppc_hash_table (info);
11409 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11411 enum elf_ppc64_reloc_type r_type;
11412 unsigned long r_symndx;
11413 struct elf_link_hash_entry *h;
11414 struct ppc_link_hash_entry *eh;
11415 Elf_Internal_Sym *sym;
11417 struct _opd_sec_data *opd;
11421 r_type = ELF64_R_TYPE (rel->r_info);
11422 if (r_type != R_PPC64_REL24
11423 && r_type != R_PPC64_REL14
11424 && r_type != R_PPC64_REL14_BRTAKEN
11425 && r_type != R_PPC64_REL14_BRNTAKEN)
11428 r_symndx = ELF64_R_SYM (rel->r_info);
11429 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11436 /* Calls to dynamic lib functions go through a plt call stub
11438 eh = (struct ppc_link_hash_entry *) h;
11440 && (eh->elf.plt.plist != NULL
11442 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11448 if (sym_sec == NULL)
11449 /* Ignore other undefined symbols. */
11452 /* Assume branches to other sections not included in the
11453 link need stubs too, to cover -R and absolute syms. */
11454 if (sym_sec->output_section == NULL)
11461 sym_value = sym->st_value;
11464 if (h->root.type != bfd_link_hash_defined
11465 && h->root.type != bfd_link_hash_defweak)
11467 sym_value = h->root.u.def.value;
11469 sym_value += rel->r_addend;
11471 /* If this branch reloc uses an opd sym, find the code section. */
11472 opd = get_opd_info (sym_sec);
11475 if (h == NULL && opd->adjust != NULL)
11479 adjust = opd->adjust[sym->st_value / 8];
11481 /* Assume deleted functions won't ever be called. */
11483 sym_value += adjust;
11486 dest = opd_entry_value (sym_sec, sym_value,
11487 &sym_sec, NULL, FALSE);
11488 if (dest == (bfd_vma) -1)
11493 + sym_sec->output_offset
11494 + sym_sec->output_section->vma);
11496 /* Ignore branch to self. */
11497 if (sym_sec == isec)
11500 /* If the called function uses the toc, we need a stub. */
11501 if (sym_sec->has_toc_reloc
11502 || sym_sec->makes_toc_func_call)
11508 /* Assume any branch that needs a long branch stub might in fact
11509 need a plt_branch stub. A plt_branch stub uses r2. */
11510 else if (dest - (isec->output_offset
11511 + isec->output_section->vma
11512 + rel->r_offset) + (1 << 25)
11513 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11521 /* If calling back to a section in the process of being
11522 tested, we can't say for sure that no toc adjusting stubs
11523 are needed, so don't return zero. */
11524 else if (sym_sec->call_check_in_progress)
11527 /* Branches to another section that itself doesn't have any TOC
11528 references are OK. Recursively call ourselves to check. */
11529 else if (!sym_sec->call_check_done)
11533 /* Mark current section as indeterminate, so that other
11534 sections that call back to current won't be marked as
11536 isec->call_check_in_progress = 1;
11537 recur = toc_adjusting_stub_needed (info, sym_sec);
11538 isec->call_check_in_progress = 0;
11549 if (local_syms != NULL
11550 && (elf_symtab_hdr (isec->owner).contents
11551 != (unsigned char *) local_syms))
11553 if (elf_section_data (isec)->relocs != relstart)
11558 && isec->map_head.s != NULL
11559 && (strcmp (isec->output_section->name, ".init") == 0
11560 || strcmp (isec->output_section->name, ".fini") == 0))
11562 if (isec->map_head.s->has_toc_reloc
11563 || isec->map_head.s->makes_toc_func_call)
11565 else if (!isec->map_head.s->call_check_done)
11568 isec->call_check_in_progress = 1;
11569 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11570 isec->call_check_in_progress = 0;
11577 isec->makes_toc_func_call = 1;
11582 /* The linker repeatedly calls this function for each input section,
11583 in the order that input sections are linked into output sections.
11584 Build lists of input sections to determine groupings between which
11585 we may insert linker stubs. */
11588 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11595 if ((isec->output_section->flags & SEC_CODE) != 0
11596 && isec->output_section->index <= htab->top_index)
11598 asection **list = htab->input_list + isec->output_section->index;
11599 /* Steal the link_sec pointer for our list. */
11600 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11601 /* This happens to make the list in reverse order,
11602 which is what we want. */
11603 PREV_SEC (isec) = *list;
11607 if (htab->multi_toc_needed)
11609 /* Analyse sections that aren't already flagged as needing a
11610 valid toc pointer. Exclude .fixup for the linux kernel.
11611 .fixup contains branches, but only back to the function that
11612 hit an exception. */
11613 if (!(isec->has_toc_reloc
11614 || (isec->flags & SEC_CODE) == 0
11615 || strcmp (isec->name, ".fixup") == 0
11616 || isec->call_check_done))
11618 if (toc_adjusting_stub_needed (info, isec) < 0)
11621 /* Make all sections use the TOC assigned for this object file.
11622 This will be wrong for pasted sections; We fix that in
11623 check_pasted_section(). */
11624 if (elf_gp (isec->owner) != 0)
11625 htab->toc_curr = elf_gp (isec->owner);
11628 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11632 /* Check that all .init and .fini sections use the same toc, if they
11633 have toc relocs. */
11636 check_pasted_section (struct bfd_link_info *info, const char *name)
11638 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11642 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11643 bfd_vma toc_off = 0;
11646 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11647 if (i->has_toc_reloc)
11650 toc_off = htab->stub_group[i->id].toc_off;
11651 else if (toc_off != htab->stub_group[i->id].toc_off)
11656 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11657 if (i->makes_toc_func_call)
11659 toc_off = htab->stub_group[i->id].toc_off;
11663 /* Make sure the whole pasted function uses the same toc offset. */
11665 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11666 htab->stub_group[i->id].toc_off = toc_off;
11672 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11674 return (check_pasted_section (info, ".init")
11675 & check_pasted_section (info, ".fini"));
11678 /* See whether we can group stub sections together. Grouping stub
11679 sections may result in fewer stubs. More importantly, we need to
11680 put all .init* and .fini* stubs at the beginning of the .init or
11681 .fini output sections respectively, because glibc splits the
11682 _init and _fini functions into multiple parts. Putting a stub in
11683 the middle of a function is not a good idea. */
11686 group_sections (struct ppc_link_hash_table *htab,
11687 bfd_size_type stub_group_size,
11688 bfd_boolean stubs_always_before_branch)
11691 bfd_size_type stub14_group_size;
11692 bfd_boolean suppress_size_errors;
11694 suppress_size_errors = FALSE;
11695 stub14_group_size = stub_group_size;
11696 if (stub_group_size == 1)
11698 /* Default values. */
11699 if (stubs_always_before_branch)
11701 stub_group_size = 0x1e00000;
11702 stub14_group_size = 0x7800;
11706 stub_group_size = 0x1c00000;
11707 stub14_group_size = 0x7000;
11709 suppress_size_errors = TRUE;
11712 list = htab->input_list + htab->top_index;
11715 asection *tail = *list;
11716 while (tail != NULL)
11720 bfd_size_type total;
11721 bfd_boolean big_sec;
11725 total = tail->size;
11726 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11727 && ppc64_elf_section_data (tail)->has_14bit_branch
11728 ? stub14_group_size : stub_group_size);
11729 if (big_sec && !suppress_size_errors)
11730 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11731 tail->owner, tail);
11732 curr_toc = htab->stub_group[tail->id].toc_off;
11734 while ((prev = PREV_SEC (curr)) != NULL
11735 && ((total += curr->output_offset - prev->output_offset)
11736 < (ppc64_elf_section_data (prev) != NULL
11737 && ppc64_elf_section_data (prev)->has_14bit_branch
11738 ? stub14_group_size : stub_group_size))
11739 && htab->stub_group[prev->id].toc_off == curr_toc)
11742 /* OK, the size from the start of CURR to the end is less
11743 than stub_group_size and thus can be handled by one stub
11744 section. (or the tail section is itself larger than
11745 stub_group_size, in which case we may be toast.) We
11746 should really be keeping track of the total size of stubs
11747 added here, as stubs contribute to the final output
11748 section size. That's a little tricky, and this way will
11749 only break if stubs added make the total size more than
11750 2^25, ie. for the default stub_group_size, if stubs total
11751 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11754 prev = PREV_SEC (tail);
11755 /* Set up this stub group. */
11756 htab->stub_group[tail->id].link_sec = curr;
11758 while (tail != curr && (tail = prev) != NULL);
11760 /* But wait, there's more! Input sections up to stub_group_size
11761 bytes before the stub section can be handled by it too.
11762 Don't do this if we have a really large section after the
11763 stubs, as adding more stubs increases the chance that
11764 branches may not reach into the stub section. */
11765 if (!stubs_always_before_branch && !big_sec)
11768 while (prev != NULL
11769 && ((total += tail->output_offset - prev->output_offset)
11770 < (ppc64_elf_section_data (prev) != NULL
11771 && ppc64_elf_section_data (prev)->has_14bit_branch
11772 ? stub14_group_size : stub_group_size))
11773 && htab->stub_group[prev->id].toc_off == curr_toc)
11776 prev = PREV_SEC (tail);
11777 htab->stub_group[tail->id].link_sec = curr;
11783 while (list-- != htab->input_list);
11784 free (htab->input_list);
11788 static const unsigned char glink_eh_frame_cie[] =
11790 0, 0, 0, 16, /* length. */
11791 0, 0, 0, 0, /* id. */
11792 1, /* CIE version. */
11793 'z', 'R', 0, /* Augmentation string. */
11794 4, /* Code alignment. */
11795 0x78, /* Data alignment. */
11797 1, /* Augmentation size. */
11798 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11799 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11802 /* Stripping output sections is normally done before dynamic section
11803 symbols have been allocated. This function is called later, and
11804 handles cases like htab->brlt which is mapped to its own output
11808 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11810 if (isec->size == 0
11811 && isec->output_section->size == 0
11812 && !(isec->output_section->flags & SEC_KEEP)
11813 && !bfd_section_removed_from_list (info->output_bfd,
11814 isec->output_section)
11815 && elf_section_data (isec->output_section)->dynindx == 0)
11817 isec->output_section->flags |= SEC_EXCLUDE;
11818 bfd_section_list_remove (info->output_bfd, isec->output_section);
11819 info->output_bfd->section_count--;
11823 /* Determine and set the size of the stub section for a final link.
11825 The basic idea here is to examine all the relocations looking for
11826 PC-relative calls to a target that is unreachable with a "bl"
11830 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11831 bfd_boolean plt_static_chain, int plt_thread_safe,
11832 int plt_stub_align)
11834 bfd_size_type stub_group_size;
11835 bfd_boolean stubs_always_before_branch;
11836 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11841 htab->plt_static_chain = plt_static_chain;
11842 htab->plt_stub_align = plt_stub_align;
11843 if (plt_thread_safe == -1 && !info->executable)
11844 plt_thread_safe = 1;
11845 if (!htab->opd_abi)
11846 plt_thread_safe = 0;
11847 else if (plt_thread_safe == -1)
11849 static const char *const thread_starter[] =
11853 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11855 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11856 "mq_notify", "create_timer",
11860 "GOMP_parallel_start",
11861 "GOMP_parallel_loop_static_start",
11862 "GOMP_parallel_loop_dynamic_start",
11863 "GOMP_parallel_loop_guided_start",
11864 "GOMP_parallel_loop_runtime_start",
11865 "GOMP_parallel_sections_start",
11869 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11871 struct elf_link_hash_entry *h;
11872 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11873 FALSE, FALSE, TRUE);
11874 plt_thread_safe = h != NULL && h->ref_regular;
11875 if (plt_thread_safe)
11879 htab->plt_thread_safe = plt_thread_safe;
11880 stubs_always_before_branch = group_size < 0;
11881 if (group_size < 0)
11882 stub_group_size = -group_size;
11884 stub_group_size = group_size;
11886 group_sections (htab, stub_group_size, stubs_always_before_branch);
11891 unsigned int bfd_indx;
11892 asection *stub_sec;
11894 htab->stub_iteration += 1;
11896 for (input_bfd = info->input_bfds, bfd_indx = 0;
11898 input_bfd = input_bfd->link_next, bfd_indx++)
11900 Elf_Internal_Shdr *symtab_hdr;
11902 Elf_Internal_Sym *local_syms = NULL;
11904 if (!is_ppc64_elf (input_bfd))
11907 /* We'll need the symbol table in a second. */
11908 symtab_hdr = &elf_symtab_hdr (input_bfd);
11909 if (symtab_hdr->sh_info == 0)
11912 /* Walk over each section attached to the input bfd. */
11913 for (section = input_bfd->sections;
11915 section = section->next)
11917 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11919 /* If there aren't any relocs, then there's nothing more
11921 if ((section->flags & SEC_RELOC) == 0
11922 || (section->flags & SEC_ALLOC) == 0
11923 || (section->flags & SEC_LOAD) == 0
11924 || (section->flags & SEC_CODE) == 0
11925 || section->reloc_count == 0)
11928 /* If this section is a link-once section that will be
11929 discarded, then don't create any stubs. */
11930 if (section->output_section == NULL
11931 || section->output_section->owner != info->output_bfd)
11934 /* Get the relocs. */
11936 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11937 info->keep_memory);
11938 if (internal_relocs == NULL)
11939 goto error_ret_free_local;
11941 /* Now examine each relocation. */
11942 irela = internal_relocs;
11943 irelaend = irela + section->reloc_count;
11944 for (; irela < irelaend; irela++)
11946 enum elf_ppc64_reloc_type r_type;
11947 unsigned int r_indx;
11948 enum ppc_stub_type stub_type;
11949 struct ppc_stub_hash_entry *stub_entry;
11950 asection *sym_sec, *code_sec;
11951 bfd_vma sym_value, code_value;
11952 bfd_vma destination;
11953 unsigned long local_off;
11954 bfd_boolean ok_dest;
11955 struct ppc_link_hash_entry *hash;
11956 struct ppc_link_hash_entry *fdh;
11957 struct elf_link_hash_entry *h;
11958 Elf_Internal_Sym *sym;
11960 const asection *id_sec;
11961 struct _opd_sec_data *opd;
11962 struct plt_entry *plt_ent;
11964 r_type = ELF64_R_TYPE (irela->r_info);
11965 r_indx = ELF64_R_SYM (irela->r_info);
11967 if (r_type >= R_PPC64_max)
11969 bfd_set_error (bfd_error_bad_value);
11970 goto error_ret_free_internal;
11973 /* Only look for stubs on branch instructions. */
11974 if (r_type != R_PPC64_REL24
11975 && r_type != R_PPC64_REL14
11976 && r_type != R_PPC64_REL14_BRTAKEN
11977 && r_type != R_PPC64_REL14_BRNTAKEN)
11980 /* Now determine the call target, its name, value,
11982 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11983 r_indx, input_bfd))
11984 goto error_ret_free_internal;
11985 hash = (struct ppc_link_hash_entry *) h;
11992 sym_value = sym->st_value;
11995 else if (hash->elf.root.type == bfd_link_hash_defined
11996 || hash->elf.root.type == bfd_link_hash_defweak)
11998 sym_value = hash->elf.root.u.def.value;
11999 if (sym_sec->output_section != NULL)
12002 else if (hash->elf.root.type == bfd_link_hash_undefweak
12003 || hash->elf.root.type == bfd_link_hash_undefined)
12005 /* Recognise an old ABI func code entry sym, and
12006 use the func descriptor sym instead if it is
12008 if (hash->elf.root.root.string[0] == '.'
12009 && (fdh = lookup_fdh (hash, htab)) != NULL)
12011 if (fdh->elf.root.type == bfd_link_hash_defined
12012 || fdh->elf.root.type == bfd_link_hash_defweak)
12014 sym_sec = fdh->elf.root.u.def.section;
12015 sym_value = fdh->elf.root.u.def.value;
12016 if (sym_sec->output_section != NULL)
12025 bfd_set_error (bfd_error_bad_value);
12026 goto error_ret_free_internal;
12033 sym_value += irela->r_addend;
12034 destination = (sym_value
12035 + sym_sec->output_offset
12036 + sym_sec->output_section->vma);
12037 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12042 code_sec = sym_sec;
12043 code_value = sym_value;
12044 opd = get_opd_info (sym_sec);
12049 if (hash == NULL && opd->adjust != NULL)
12051 long adjust = opd->adjust[sym_value / 8];
12054 code_value += adjust;
12055 sym_value += adjust;
12057 dest = opd_entry_value (sym_sec, sym_value,
12058 &code_sec, &code_value, FALSE);
12059 if (dest != (bfd_vma) -1)
12061 destination = dest;
12064 /* Fixup old ABI sym to point at code
12066 hash->elf.root.type = bfd_link_hash_defweak;
12067 hash->elf.root.u.def.section = code_sec;
12068 hash->elf.root.u.def.value = code_value;
12073 /* Determine what (if any) linker stub is needed. */
12075 stub_type = ppc_type_of_stub (section, irela, &hash,
12076 &plt_ent, destination,
12079 if (stub_type != ppc_stub_plt_call)
12081 /* Check whether we need a TOC adjusting stub.
12082 Since the linker pastes together pieces from
12083 different object files when creating the
12084 _init and _fini functions, it may be that a
12085 call to what looks like a local sym is in
12086 fact a call needing a TOC adjustment. */
12087 if (code_sec != NULL
12088 && code_sec->output_section != NULL
12089 && (htab->stub_group[code_sec->id].toc_off
12090 != htab->stub_group[section->id].toc_off)
12091 && (code_sec->has_toc_reloc
12092 || code_sec->makes_toc_func_call))
12093 stub_type = ppc_stub_long_branch_r2off;
12096 if (stub_type == ppc_stub_none)
12099 /* __tls_get_addr calls might be eliminated. */
12100 if (stub_type != ppc_stub_plt_call
12102 && (hash == htab->tls_get_addr
12103 || hash == htab->tls_get_addr_fd)
12104 && section->has_tls_reloc
12105 && irela != internal_relocs)
12107 /* Get tls info. */
12108 unsigned char *tls_mask;
12110 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12111 irela - 1, input_bfd))
12112 goto error_ret_free_internal;
12113 if (*tls_mask != 0)
12117 if (stub_type == ppc_stub_plt_call
12118 && irela + 1 < irelaend
12119 && irela[1].r_offset == irela->r_offset + 4
12120 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12122 if (!tocsave_find (htab, INSERT,
12123 &local_syms, irela + 1, input_bfd))
12124 goto error_ret_free_internal;
12126 else if (stub_type == ppc_stub_plt_call)
12127 stub_type = ppc_stub_plt_call_r2save;
12129 /* Support for grouping stub sections. */
12130 id_sec = htab->stub_group[section->id].link_sec;
12132 /* Get the name of this stub. */
12133 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12135 goto error_ret_free_internal;
12137 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12138 stub_name, FALSE, FALSE);
12139 if (stub_entry != NULL)
12141 /* The proper stub has already been created. */
12143 if (stub_type == ppc_stub_plt_call_r2save)
12144 stub_entry->stub_type = stub_type;
12148 stub_entry = ppc_add_stub (stub_name, section, info);
12149 if (stub_entry == NULL)
12152 error_ret_free_internal:
12153 if (elf_section_data (section)->relocs == NULL)
12154 free (internal_relocs);
12155 error_ret_free_local:
12156 if (local_syms != NULL
12157 && (symtab_hdr->contents
12158 != (unsigned char *) local_syms))
12163 stub_entry->stub_type = stub_type;
12164 if (stub_type != ppc_stub_plt_call
12165 && stub_type != ppc_stub_plt_call_r2save)
12167 stub_entry->target_value = code_value;
12168 stub_entry->target_section = code_sec;
12172 stub_entry->target_value = sym_value;
12173 stub_entry->target_section = sym_sec;
12175 stub_entry->h = hash;
12176 stub_entry->plt_ent = plt_ent;
12177 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12179 if (stub_entry->h != NULL)
12180 htab->stub_globals += 1;
12183 /* We're done with the internal relocs, free them. */
12184 if (elf_section_data (section)->relocs != internal_relocs)
12185 free (internal_relocs);
12188 if (local_syms != NULL
12189 && symtab_hdr->contents != (unsigned char *) local_syms)
12191 if (!info->keep_memory)
12194 symtab_hdr->contents = (unsigned char *) local_syms;
12198 /* We may have added some stubs. Find out the new size of the
12200 for (stub_sec = htab->stub_bfd->sections;
12202 stub_sec = stub_sec->next)
12203 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12205 stub_sec->rawsize = stub_sec->size;
12206 stub_sec->size = 0;
12207 stub_sec->reloc_count = 0;
12208 stub_sec->flags &= ~SEC_RELOC;
12211 htab->brlt->size = 0;
12212 htab->brlt->reloc_count = 0;
12213 htab->brlt->flags &= ~SEC_RELOC;
12214 if (htab->relbrlt != NULL)
12215 htab->relbrlt->size = 0;
12217 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12219 if (info->emitrelocations
12220 && htab->glink != NULL && htab->glink->size != 0)
12222 htab->glink->reloc_count = 1;
12223 htab->glink->flags |= SEC_RELOC;
12226 if (htab->glink_eh_frame != NULL
12227 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12228 && htab->glink_eh_frame->output_section->size != 0)
12230 size_t size = 0, align;
12232 for (stub_sec = htab->stub_bfd->sections;
12234 stub_sec = stub_sec->next)
12235 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12237 if (htab->glink != NULL && htab->glink->size != 0)
12240 size += sizeof (glink_eh_frame_cie);
12242 align <<= htab->glink_eh_frame->output_section->alignment_power;
12244 size = (size + align) & ~align;
12245 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12246 htab->glink_eh_frame->size = size;
12249 if (htab->plt_stub_align != 0)
12250 for (stub_sec = htab->stub_bfd->sections;
12252 stub_sec = stub_sec->next)
12253 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12254 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12255 & (-1 << htab->plt_stub_align));
12257 for (stub_sec = htab->stub_bfd->sections;
12259 stub_sec = stub_sec->next)
12260 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12261 && stub_sec->rawsize != stub_sec->size)
12264 /* Exit from this loop when no stubs have been added, and no stubs
12265 have changed size. */
12266 if (stub_sec == NULL
12267 && (htab->glink_eh_frame == NULL
12268 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12271 /* Ask the linker to do its stuff. */
12272 (*htab->layout_sections_again) ();
12275 maybe_strip_output (info, htab->brlt);
12276 if (htab->glink_eh_frame != NULL)
12277 maybe_strip_output (info, htab->glink_eh_frame);
12282 /* Called after we have determined section placement. If sections
12283 move, we'll be called again. Provide a value for TOCstart. */
12286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12291 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12292 order. The TOC starts where the first of these sections starts. */
12293 s = bfd_get_section_by_name (obfd, ".got");
12294 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12295 s = bfd_get_section_by_name (obfd, ".toc");
12296 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12297 s = bfd_get_section_by_name (obfd, ".tocbss");
12298 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12299 s = bfd_get_section_by_name (obfd, ".plt");
12300 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12302 /* This may happen for
12303 o references to TOC base (SYM@toc / TOC[tc0]) without a
12305 o bad linker script
12306 o --gc-sections and empty TOC sections
12308 FIXME: Warn user? */
12310 /* Look for a likely section. We probably won't even be
12312 for (s = obfd->sections; s != NULL; s = s->next)
12313 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12315 == (SEC_ALLOC | SEC_SMALL_DATA))
12318 for (s = obfd->sections; s != NULL; s = s->next)
12319 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12320 == (SEC_ALLOC | SEC_SMALL_DATA))
12323 for (s = obfd->sections; s != NULL; s = s->next)
12324 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12328 for (s = obfd->sections; s != NULL; s = s->next)
12329 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12335 TOCstart = s->output_section->vma + s->output_offset;
12337 _bfd_set_gp_value (obfd, TOCstart);
12339 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12341 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12344 && htab->elf.hgot != NULL)
12346 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12347 htab->elf.hgot->root.u.def.section = s;
12353 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12354 write out any global entry stubs. */
12357 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12359 struct bfd_link_info *info;
12360 struct ppc_link_hash_table *htab;
12361 struct plt_entry *pent;
12364 if (h->root.type == bfd_link_hash_indirect)
12367 if (!h->pointer_equality_needed)
12370 if (h->def_regular)
12374 htab = ppc_hash_table (info);
12379 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12380 if (pent->plt.offset != (bfd_vma) -1
12381 && pent->addend == 0)
12387 p = s->contents + h->root.u.def.value;
12388 plt = htab->elf.splt;
12389 if (!htab->elf.dynamic_sections_created
12390 || h->dynindx == -1)
12391 plt = htab->elf.iplt;
12392 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12393 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12395 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12397 info->callbacks->einfo
12398 (_("%P: linkage table error against `%T'\n"),
12399 h->root.root.string);
12400 bfd_set_error (bfd_error_bad_value);
12401 htab->stub_error = TRUE;
12404 if (PPC_HA (off) != 0)
12406 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12409 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12411 bfd_put_32 (s->owner, MTCTR_R12, p);
12413 bfd_put_32 (s->owner, BCTR, p);
12419 /* Build all the stubs associated with the current output file.
12420 The stubs are kept in a hash table attached to the main linker
12421 hash table. This function is called via gldelf64ppc_finish. */
12424 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12425 struct bfd_link_info *info,
12428 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12429 asection *stub_sec;
12431 int stub_sec_count = 0;
12436 htab->emit_stub_syms = emit_stub_syms;
12438 /* Allocate memory to hold the linker stubs. */
12439 for (stub_sec = htab->stub_bfd->sections;
12441 stub_sec = stub_sec->next)
12442 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12443 && stub_sec->size != 0)
12445 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12446 if (stub_sec->contents == NULL)
12448 /* We want to check that built size is the same as calculated
12449 size. rawsize is a convenient location to use. */
12450 stub_sec->rawsize = stub_sec->size;
12451 stub_sec->size = 0;
12454 if (htab->glink != NULL && htab->glink->size != 0)
12459 /* Build the .glink plt call stub. */
12460 if (htab->emit_stub_syms)
12462 struct elf_link_hash_entry *h;
12463 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12464 TRUE, FALSE, FALSE);
12467 if (h->root.type == bfd_link_hash_new)
12469 h->root.type = bfd_link_hash_defined;
12470 h->root.u.def.section = htab->glink;
12471 h->root.u.def.value = 8;
12472 h->ref_regular = 1;
12473 h->def_regular = 1;
12474 h->ref_regular_nonweak = 1;
12475 h->forced_local = 1;
12479 plt0 = (htab->elf.splt->output_section->vma
12480 + htab->elf.splt->output_offset
12482 if (info->emitrelocations)
12484 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12487 r->r_offset = (htab->glink->output_offset
12488 + htab->glink->output_section->vma);
12489 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12490 r->r_addend = plt0;
12492 p = htab->glink->contents;
12493 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12494 bfd_put_64 (htab->glink->owner, plt0, p);
12498 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12500 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12502 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12504 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12506 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12508 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12510 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12512 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12514 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12516 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12521 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12523 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12525 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12527 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12529 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12531 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12533 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12535 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12537 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12539 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12541 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12543 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12546 bfd_put_32 (htab->glink->owner, BCTR, p);
12548 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12550 bfd_put_32 (htab->glink->owner, NOP, p);
12554 /* Build the .glink lazy link call stubs. */
12556 while (p < htab->glink->contents + htab->glink->rawsize)
12562 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12567 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12569 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12574 bfd_put_32 (htab->glink->owner,
12575 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12580 /* Build .glink global entry stubs. */
12581 if (htab->glink->size > htab->glink->rawsize)
12582 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12585 if (htab->brlt->size != 0)
12587 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12589 if (htab->brlt->contents == NULL)
12592 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12594 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12595 htab->relbrlt->size);
12596 if (htab->relbrlt->contents == NULL)
12600 if (htab->glink_eh_frame != NULL
12601 && htab->glink_eh_frame->size != 0)
12604 bfd_byte *last_fde;
12605 size_t last_fde_len, size, align, pad;
12607 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12610 htab->glink_eh_frame->contents = p;
12613 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12615 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12616 /* CIE length (rewrite in case little-endian). */
12617 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12618 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12619 p += sizeof (glink_eh_frame_cie);
12621 for (stub_sec = htab->stub_bfd->sections;
12623 stub_sec = stub_sec->next)
12624 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12629 bfd_put_32 (htab->elf.dynobj, 16, p);
12632 val = p - htab->glink_eh_frame->contents;
12633 bfd_put_32 (htab->elf.dynobj, val, p);
12635 /* Offset to stub section. */
12636 val = (stub_sec->output_section->vma
12637 + stub_sec->output_offset);
12638 val -= (htab->glink_eh_frame->output_section->vma
12639 + htab->glink_eh_frame->output_offset);
12640 val -= p - htab->glink_eh_frame->contents;
12641 if (val + 0x80000000 > 0xffffffff)
12643 info->callbacks->einfo
12644 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12648 bfd_put_32 (htab->elf.dynobj, val, p);
12650 /* stub section size. */
12651 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12653 /* Augmentation. */
12658 if (htab->glink != NULL && htab->glink->size != 0)
12663 bfd_put_32 (htab->elf.dynobj, 20, p);
12666 val = p - htab->glink_eh_frame->contents;
12667 bfd_put_32 (htab->elf.dynobj, val, p);
12669 /* Offset to .glink. */
12670 val = (htab->glink->output_section->vma
12671 + htab->glink->output_offset
12673 val -= (htab->glink_eh_frame->output_section->vma
12674 + htab->glink_eh_frame->output_offset);
12675 val -= p - htab->glink_eh_frame->contents;
12676 if (val + 0x80000000 > 0xffffffff)
12678 info->callbacks->einfo
12679 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12680 htab->glink->name);
12683 bfd_put_32 (htab->elf.dynobj, val, p);
12686 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12688 /* Augmentation. */
12691 *p++ = DW_CFA_advance_loc + 1;
12692 *p++ = DW_CFA_register;
12695 *p++ = DW_CFA_advance_loc + 4;
12696 *p++ = DW_CFA_restore_extended;
12699 /* Subsume any padding into the last FDE if user .eh_frame
12700 sections are aligned more than glink_eh_frame. Otherwise any
12701 zero padding will be seen as a terminator. */
12702 size = p - htab->glink_eh_frame->contents;
12704 align <<= htab->glink_eh_frame->output_section->alignment_power;
12706 pad = ((size + align) & ~align) - size;
12707 htab->glink_eh_frame->size = size + pad;
12708 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12711 /* Build the stubs as directed by the stub hash table. */
12712 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12714 if (htab->relbrlt != NULL)
12715 htab->relbrlt->reloc_count = 0;
12717 if (htab->plt_stub_align != 0)
12718 for (stub_sec = htab->stub_bfd->sections;
12720 stub_sec = stub_sec->next)
12721 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12722 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12723 & (-1 << htab->plt_stub_align));
12725 for (stub_sec = htab->stub_bfd->sections;
12727 stub_sec = stub_sec->next)
12728 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12730 stub_sec_count += 1;
12731 if (stub_sec->rawsize != stub_sec->size)
12735 if (stub_sec != NULL
12736 || (htab->glink_eh_frame != NULL
12737 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12739 htab->stub_error = TRUE;
12740 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12743 if (htab->stub_error)
12748 *stats = bfd_malloc (500);
12749 if (*stats == NULL)
12752 sprintf (*stats, _("linker stubs in %u group%s\n"
12754 " toc adjust %lu\n"
12755 " long branch %lu\n"
12756 " long toc adj %lu\n"
12758 " plt call toc %lu"),
12760 stub_sec_count == 1 ? "" : "s",
12761 htab->stub_count[ppc_stub_long_branch - 1],
12762 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12763 htab->stub_count[ppc_stub_plt_branch - 1],
12764 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12765 htab->stub_count[ppc_stub_plt_call - 1],
12766 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12771 /* This function undoes the changes made by add_symbol_adjust. */
12774 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12776 struct ppc_link_hash_entry *eh;
12778 if (h->root.type == bfd_link_hash_indirect)
12781 eh = (struct ppc_link_hash_entry *) h;
12782 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12785 eh->elf.root.type = bfd_link_hash_undefined;
12790 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12792 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12795 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12798 /* What to do when ld finds relocations against symbols defined in
12799 discarded sections. */
12801 static unsigned int
12802 ppc64_elf_action_discarded (asection *sec)
12804 if (strcmp (".opd", sec->name) == 0)
12807 if (strcmp (".toc", sec->name) == 0)
12810 if (strcmp (".toc1", sec->name) == 0)
12813 return _bfd_elf_default_action_discarded (sec);
12816 /* The RELOCATE_SECTION function is called by the ELF backend linker
12817 to handle the relocations for a section.
12819 The relocs are always passed as Rela structures; if the section
12820 actually uses Rel structures, the r_addend field will always be
12823 This function is responsible for adjust the section contents as
12824 necessary, and (if using Rela relocs and generating a
12825 relocatable output file) adjusting the reloc addend as
12828 This function does not have to worry about setting the reloc
12829 address or the reloc symbol index.
12831 LOCAL_SYMS is a pointer to the swapped in local symbols.
12833 LOCAL_SECTIONS is an array giving the section in the input file
12834 corresponding to the st_shndx field of each local symbol.
12836 The global hash table entry for the global symbols can be found
12837 via elf_sym_hashes (input_bfd).
12839 When generating relocatable output, this function must handle
12840 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12841 going to be the section symbol corresponding to the output
12842 section, which means that the addend must be adjusted
12846 ppc64_elf_relocate_section (bfd *output_bfd,
12847 struct bfd_link_info *info,
12849 asection *input_section,
12850 bfd_byte *contents,
12851 Elf_Internal_Rela *relocs,
12852 Elf_Internal_Sym *local_syms,
12853 asection **local_sections)
12855 struct ppc_link_hash_table *htab;
12856 Elf_Internal_Shdr *symtab_hdr;
12857 struct elf_link_hash_entry **sym_hashes;
12858 Elf_Internal_Rela *rel;
12859 Elf_Internal_Rela *relend;
12860 Elf_Internal_Rela outrel;
12862 struct got_entry **local_got_ents;
12864 bfd_boolean ret = TRUE;
12865 bfd_boolean is_opd;
12866 /* Assume 'at' branch hints. */
12867 bfd_boolean is_isa_v2 = TRUE;
12868 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12870 /* Initialize howto table if needed. */
12871 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12874 htab = ppc_hash_table (info);
12878 /* Don't relocate stub sections. */
12879 if (input_section->owner == htab->stub_bfd)
12882 BFD_ASSERT (is_ppc64_elf (input_bfd));
12884 local_got_ents = elf_local_got_ents (input_bfd);
12885 TOCstart = elf_gp (output_bfd);
12886 symtab_hdr = &elf_symtab_hdr (input_bfd);
12887 sym_hashes = elf_sym_hashes (input_bfd);
12888 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12891 relend = relocs + input_section->reloc_count;
12892 for (; rel < relend; rel++)
12894 enum elf_ppc64_reloc_type r_type;
12896 bfd_reloc_status_type r;
12897 Elf_Internal_Sym *sym;
12899 struct elf_link_hash_entry *h_elf;
12900 struct ppc_link_hash_entry *h;
12901 struct ppc_link_hash_entry *fdh;
12902 const char *sym_name;
12903 unsigned long r_symndx, toc_symndx;
12904 bfd_vma toc_addend;
12905 unsigned char tls_mask, tls_gd, tls_type;
12906 unsigned char sym_type;
12907 bfd_vma relocation;
12908 bfd_boolean unresolved_reloc;
12909 bfd_boolean warned;
12910 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12913 struct ppc_stub_hash_entry *stub_entry;
12914 bfd_vma max_br_offset;
12916 const Elf_Internal_Rela orig_rel = *rel;
12918 r_type = ELF64_R_TYPE (rel->r_info);
12919 r_symndx = ELF64_R_SYM (rel->r_info);
12921 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12922 symbol of the previous ADDR64 reloc. The symbol gives us the
12923 proper TOC base to use. */
12924 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12926 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12928 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12934 unresolved_reloc = FALSE;
12937 if (r_symndx < symtab_hdr->sh_info)
12939 /* It's a local symbol. */
12940 struct _opd_sec_data *opd;
12942 sym = local_syms + r_symndx;
12943 sec = local_sections[r_symndx];
12944 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12945 sym_type = ELF64_ST_TYPE (sym->st_info);
12946 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12947 opd = get_opd_info (sec);
12948 if (opd != NULL && opd->adjust != NULL)
12950 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12955 /* If this is a relocation against the opd section sym
12956 and we have edited .opd, adjust the reloc addend so
12957 that ld -r and ld --emit-relocs output is correct.
12958 If it is a reloc against some other .opd symbol,
12959 then the symbol value will be adjusted later. */
12960 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12961 rel->r_addend += adjust;
12963 relocation += adjust;
12969 bfd_boolean ignored;
12971 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12972 r_symndx, symtab_hdr, sym_hashes,
12973 h_elf, sec, relocation,
12974 unresolved_reloc, warned, ignored);
12975 sym_name = h_elf->root.root.string;
12976 sym_type = h_elf->type;
12978 && sec->owner == output_bfd
12979 && strcmp (sec->name, ".opd") == 0)
12981 /* This is a symbol defined in a linker script. All
12982 such are defined in output sections, even those
12983 defined by simple assignment from a symbol defined in
12984 an input section. Transfer the symbol to an
12985 appropriate input .opd section, so that a branch to
12986 this symbol will be mapped to the location specified
12987 by the opd entry. */
12988 struct bfd_link_order *lo;
12989 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12990 if (lo->type == bfd_indirect_link_order)
12992 asection *isec = lo->u.indirect.section;
12993 if (h_elf->root.u.def.value >= isec->output_offset
12994 && h_elf->root.u.def.value < (isec->output_offset
12997 h_elf->root.u.def.value -= isec->output_offset;
12998 h_elf->root.u.def.section = isec;
13005 h = (struct ppc_link_hash_entry *) h_elf;
13007 if (sec != NULL && discarded_section (sec))
13008 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13010 ppc64_elf_howto_table[r_type], 0,
13013 if (info->relocatable)
13016 if (h != NULL && &h->elf == htab->elf.hgot)
13018 relocation = (TOCstart
13019 + htab->stub_group[input_section->id].toc_off);
13020 sec = bfd_abs_section_ptr;
13021 unresolved_reloc = FALSE;
13024 /* TLS optimizations. Replace instruction sequences and relocs
13025 based on information we collected in tls_optimize. We edit
13026 RELOCS so that --emit-relocs will output something sensible
13027 for the final instruction stream. */
13032 tls_mask = h->tls_mask;
13033 else if (local_got_ents != NULL)
13035 struct plt_entry **local_plt = (struct plt_entry **)
13036 (local_got_ents + symtab_hdr->sh_info);
13037 unsigned char *lgot_masks = (unsigned char *)
13038 (local_plt + symtab_hdr->sh_info);
13039 tls_mask = lgot_masks[r_symndx];
13042 && (r_type == R_PPC64_TLS
13043 || r_type == R_PPC64_TLSGD
13044 || r_type == R_PPC64_TLSLD))
13046 /* Check for toc tls entries. */
13047 unsigned char *toc_tls;
13049 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13050 &local_syms, rel, input_bfd))
13054 tls_mask = *toc_tls;
13057 /* Check that tls relocs are used with tls syms, and non-tls
13058 relocs are used with non-tls syms. */
13059 if (r_symndx != STN_UNDEF
13060 && r_type != R_PPC64_NONE
13062 || h->elf.root.type == bfd_link_hash_defined
13063 || h->elf.root.type == bfd_link_hash_defweak)
13064 && (IS_PPC64_TLS_RELOC (r_type)
13065 != (sym_type == STT_TLS
13066 || (sym_type == STT_SECTION
13067 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13070 && (r_type == R_PPC64_TLS
13071 || r_type == R_PPC64_TLSGD
13072 || r_type == R_PPC64_TLSLD))
13073 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13076 info->callbacks->einfo
13077 (!IS_PPC64_TLS_RELOC (r_type)
13078 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13079 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13080 input_bfd, input_section, rel->r_offset,
13081 ppc64_elf_howto_table[r_type]->name,
13085 /* Ensure reloc mapping code below stays sane. */
13086 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13087 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13088 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13089 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13090 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13091 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13092 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13093 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13094 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13095 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13103 case R_PPC64_LO_DS_OPT:
13104 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13105 if ((insn & (0x3f << 26)) != 58u << 26)
13107 insn += (14u << 26) - (58u << 26);
13108 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13109 r_type = R_PPC64_TOC16_LO;
13110 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13113 case R_PPC64_TOC16:
13114 case R_PPC64_TOC16_LO:
13115 case R_PPC64_TOC16_DS:
13116 case R_PPC64_TOC16_LO_DS:
13118 /* Check for toc tls entries. */
13119 unsigned char *toc_tls;
13122 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13123 &local_syms, rel, input_bfd);
13129 tls_mask = *toc_tls;
13130 if (r_type == R_PPC64_TOC16_DS
13131 || r_type == R_PPC64_TOC16_LO_DS)
13134 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13139 /* If we found a GD reloc pair, then we might be
13140 doing a GD->IE transition. */
13143 tls_gd = TLS_TPRELGD;
13144 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13147 else if (retval == 3)
13149 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13157 case R_PPC64_GOT_TPREL16_HI:
13158 case R_PPC64_GOT_TPREL16_HA:
13160 && (tls_mask & TLS_TPREL) == 0)
13162 rel->r_offset -= d_offset;
13163 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13164 r_type = R_PPC64_NONE;
13165 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13169 case R_PPC64_GOT_TPREL16_DS:
13170 case R_PPC64_GOT_TPREL16_LO_DS:
13172 && (tls_mask & TLS_TPREL) == 0)
13175 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13177 insn |= 0x3c0d0000; /* addis 0,13,0 */
13178 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13179 r_type = R_PPC64_TPREL16_HA;
13180 if (toc_symndx != 0)
13182 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13183 rel->r_addend = toc_addend;
13184 /* We changed the symbol. Start over in order to
13185 get h, sym, sec etc. right. */
13190 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13196 && (tls_mask & TLS_TPREL) == 0)
13198 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13199 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13202 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13203 /* Was PPC64_TLS which sits on insn boundary, now
13204 PPC64_TPREL16_LO which is at low-order half-word. */
13205 rel->r_offset += d_offset;
13206 r_type = R_PPC64_TPREL16_LO;
13207 if (toc_symndx != 0)
13209 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13210 rel->r_addend = toc_addend;
13211 /* We changed the symbol. Start over in order to
13212 get h, sym, sec etc. right. */
13217 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13221 case R_PPC64_GOT_TLSGD16_HI:
13222 case R_PPC64_GOT_TLSGD16_HA:
13223 tls_gd = TLS_TPRELGD;
13224 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13228 case R_PPC64_GOT_TLSLD16_HI:
13229 case R_PPC64_GOT_TLSLD16_HA:
13230 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13233 if ((tls_mask & tls_gd) != 0)
13234 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13235 + R_PPC64_GOT_TPREL16_DS);
13238 rel->r_offset -= d_offset;
13239 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13240 r_type = R_PPC64_NONE;
13242 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13246 case R_PPC64_GOT_TLSGD16:
13247 case R_PPC64_GOT_TLSGD16_LO:
13248 tls_gd = TLS_TPRELGD;
13249 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13253 case R_PPC64_GOT_TLSLD16:
13254 case R_PPC64_GOT_TLSLD16_LO:
13255 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13257 unsigned int insn1, insn2, insn3;
13261 offset = (bfd_vma) -1;
13262 /* If not using the newer R_PPC64_TLSGD/LD to mark
13263 __tls_get_addr calls, we must trust that the call
13264 stays with its arg setup insns, ie. that the next
13265 reloc is the __tls_get_addr call associated with
13266 the current reloc. Edit both insns. */
13267 if (input_section->has_tls_get_addr_call
13268 && rel + 1 < relend
13269 && branch_reloc_hash_match (input_bfd, rel + 1,
13270 htab->tls_get_addr,
13271 htab->tls_get_addr_fd))
13272 offset = rel[1].r_offset;
13273 if ((tls_mask & tls_gd) != 0)
13276 insn1 = bfd_get_32 (output_bfd,
13277 contents + rel->r_offset - d_offset);
13278 insn1 &= (1 << 26) - (1 << 2);
13279 insn1 |= 58 << 26; /* ld */
13280 insn2 = 0x7c636a14; /* add 3,3,13 */
13281 if (offset != (bfd_vma) -1)
13282 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13283 if ((tls_mask & TLS_EXPLICIT) == 0)
13284 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13285 + R_PPC64_GOT_TPREL16_DS);
13287 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13288 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13293 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13294 insn2 = 0x38630000; /* addi 3,3,0 */
13297 /* Was an LD reloc. */
13299 sec = local_sections[toc_symndx];
13301 r_symndx < symtab_hdr->sh_info;
13303 if (local_sections[r_symndx] == sec)
13305 if (r_symndx >= symtab_hdr->sh_info)
13306 r_symndx = STN_UNDEF;
13307 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13308 if (r_symndx != STN_UNDEF)
13309 rel->r_addend -= (local_syms[r_symndx].st_value
13310 + sec->output_offset
13311 + sec->output_section->vma);
13313 else if (toc_symndx != 0)
13315 r_symndx = toc_symndx;
13316 rel->r_addend = toc_addend;
13318 r_type = R_PPC64_TPREL16_HA;
13319 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13320 if (offset != (bfd_vma) -1)
13322 rel[1].r_info = ELF64_R_INFO (r_symndx,
13323 R_PPC64_TPREL16_LO);
13324 rel[1].r_offset = offset + d_offset;
13325 rel[1].r_addend = rel->r_addend;
13328 bfd_put_32 (output_bfd, insn1,
13329 contents + rel->r_offset - d_offset);
13330 if (offset != (bfd_vma) -1)
13332 insn3 = bfd_get_32 (output_bfd,
13333 contents + offset + 4);
13335 || insn3 == CROR_151515 || insn3 == CROR_313131)
13337 rel[1].r_offset += 4;
13338 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13341 bfd_put_32 (output_bfd, insn2, contents + offset);
13343 if ((tls_mask & tls_gd) == 0
13344 && (tls_gd == 0 || toc_symndx != 0))
13346 /* We changed the symbol. Start over in order
13347 to get h, sym, sec etc. right. */
13354 case R_PPC64_TLSGD:
13355 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13357 unsigned int insn2, insn3;
13358 bfd_vma offset = rel->r_offset;
13360 if ((tls_mask & TLS_TPRELGD) != 0)
13363 r_type = R_PPC64_NONE;
13364 insn2 = 0x7c636a14; /* add 3,3,13 */
13369 if (toc_symndx != 0)
13371 r_symndx = toc_symndx;
13372 rel->r_addend = toc_addend;
13374 r_type = R_PPC64_TPREL16_LO;
13375 rel->r_offset = offset + d_offset;
13376 insn2 = 0x38630000; /* addi 3,3,0 */
13378 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379 /* Zap the reloc on the _tls_get_addr call too. */
13380 BFD_ASSERT (offset == rel[1].r_offset);
13381 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13382 insn3 = bfd_get_32 (output_bfd,
13383 contents + offset + 4);
13385 || insn3 == CROR_151515 || insn3 == CROR_313131)
13387 rel->r_offset += 4;
13388 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13391 bfd_put_32 (output_bfd, insn2, contents + offset);
13392 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13400 case R_PPC64_TLSLD:
13401 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13403 unsigned int insn2, insn3;
13404 bfd_vma offset = rel->r_offset;
13407 sec = local_sections[toc_symndx];
13409 r_symndx < symtab_hdr->sh_info;
13411 if (local_sections[r_symndx] == sec)
13413 if (r_symndx >= symtab_hdr->sh_info)
13414 r_symndx = STN_UNDEF;
13415 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13416 if (r_symndx != STN_UNDEF)
13417 rel->r_addend -= (local_syms[r_symndx].st_value
13418 + sec->output_offset
13419 + sec->output_section->vma);
13421 r_type = R_PPC64_TPREL16_LO;
13422 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13423 rel->r_offset = offset + d_offset;
13424 /* Zap the reloc on the _tls_get_addr call too. */
13425 BFD_ASSERT (offset == rel[1].r_offset);
13426 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13427 insn2 = 0x38630000; /* addi 3,3,0 */
13428 insn3 = bfd_get_32 (output_bfd,
13429 contents + offset + 4);
13431 || insn3 == CROR_151515 || insn3 == CROR_313131)
13433 rel->r_offset += 4;
13434 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13437 bfd_put_32 (output_bfd, insn2, contents + offset);
13443 case R_PPC64_DTPMOD64:
13444 if (rel + 1 < relend
13445 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13446 && rel[1].r_offset == rel->r_offset + 8)
13448 if ((tls_mask & TLS_GD) == 0)
13450 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13451 if ((tls_mask & TLS_TPRELGD) != 0)
13452 r_type = R_PPC64_TPREL64;
13455 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13456 r_type = R_PPC64_NONE;
13458 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13463 if ((tls_mask & TLS_LD) == 0)
13465 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13466 r_type = R_PPC64_NONE;
13467 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13472 case R_PPC64_TPREL64:
13473 if ((tls_mask & TLS_TPREL) == 0)
13475 r_type = R_PPC64_NONE;
13476 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13480 case R_PPC64_REL16_HA:
13481 /* If we are generating a non-PIC executable, edit
13482 . 0: addis 2,12,.TOC.-0b@ha
13483 . addi 2,2,.TOC.-0b@l
13484 used by ELFv2 global entry points to set up r2, to
13487 if .TOC. is in range. */
13489 && h != NULL && &h->elf == htab->elf.hgot
13490 && rel + 1 < relend
13491 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13492 && rel[1].r_offset == rel->r_offset + 4
13493 && rel[1].r_addend == rel->r_addend + 4
13494 && relocation + 0x80008000 <= 0xffffffff)
13496 unsigned int insn1, insn2;
13497 bfd_vma offset = rel->r_offset - d_offset;
13498 insn1 = bfd_get_32 (output_bfd, contents + offset);
13499 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13500 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13501 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13503 r_type = R_PPC64_ADDR16_HA;
13504 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13505 rel->r_addend -= d_offset;
13506 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13507 rel[1].r_addend -= d_offset + 4;
13508 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13514 /* Handle other relocations that tweak non-addend part of insn. */
13516 max_br_offset = 1 << 25;
13517 addend = rel->r_addend;
13518 reloc_dest = DEST_NORMAL;
13524 case R_PPC64_TOCSAVE:
13525 if (relocation + addend == (rel->r_offset
13526 + input_section->output_offset
13527 + input_section->output_section->vma)
13528 && tocsave_find (htab, NO_INSERT,
13529 &local_syms, rel, input_bfd))
13531 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13533 || insn == CROR_151515 || insn == CROR_313131)
13534 bfd_put_32 (input_bfd,
13535 STD_R2_0R1 + STK_TOC (htab),
13536 contents + rel->r_offset);
13540 /* Branch taken prediction relocations. */
13541 case R_PPC64_ADDR14_BRTAKEN:
13542 case R_PPC64_REL14_BRTAKEN:
13543 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13546 /* Branch not taken prediction relocations. */
13547 case R_PPC64_ADDR14_BRNTAKEN:
13548 case R_PPC64_REL14_BRNTAKEN:
13549 insn |= bfd_get_32 (output_bfd,
13550 contents + rel->r_offset) & ~(0x01 << 21);
13553 case R_PPC64_REL14:
13554 max_br_offset = 1 << 15;
13557 case R_PPC64_REL24:
13558 /* Calls to functions with a different TOC, such as calls to
13559 shared objects, need to alter the TOC pointer. This is
13560 done using a linkage stub. A REL24 branching to these
13561 linkage stubs needs to be followed by a nop, as the nop
13562 will be replaced with an instruction to restore the TOC
13567 && h->oh->is_func_descriptor)
13568 fdh = ppc_follow_link (h->oh);
13569 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13571 if (stub_entry != NULL
13572 && (stub_entry->stub_type == ppc_stub_plt_call
13573 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13574 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13575 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13577 bfd_boolean can_plt_call = FALSE;
13579 /* All of these stubs will modify r2, so there must be a
13580 branch and link followed by a nop. The nop is
13581 replaced by an insn to restore r2. */
13582 if (rel->r_offset + 8 <= input_section->size)
13586 br = bfd_get_32 (input_bfd,
13587 contents + rel->r_offset);
13592 nop = bfd_get_32 (input_bfd,
13593 contents + rel->r_offset + 4);
13595 || nop == CROR_151515 || nop == CROR_313131)
13598 && (h == htab->tls_get_addr_fd
13599 || h == htab->tls_get_addr)
13600 && !htab->no_tls_get_addr_opt)
13602 /* Special stub used, leave nop alone. */
13605 bfd_put_32 (input_bfd,
13606 LD_R2_0R1 + STK_TOC (htab),
13607 contents + rel->r_offset + 4);
13608 can_plt_call = TRUE;
13613 if (!can_plt_call && h != NULL)
13615 const char *name = h->elf.root.root.string;
13620 if (strncmp (name, "__libc_start_main", 17) == 0
13621 && (name[17] == 0 || name[17] == '@'))
13623 /* Allow crt1 branch to go via a toc adjusting
13624 stub. Other calls that never return could do
13625 the same, if we could detect such. */
13626 can_plt_call = TRUE;
13632 /* g++ as of 20130507 emits self-calls without a
13633 following nop. This is arguably wrong since we
13634 have conflicting information. On the one hand a
13635 global symbol and on the other a local call
13636 sequence, but don't error for this special case.
13637 It isn't possible to cheaply verify we have
13638 exactly such a call. Allow all calls to the same
13640 asection *code_sec = sec;
13642 if (get_opd_info (sec) != NULL)
13644 bfd_vma off = (relocation + addend
13645 - sec->output_section->vma
13646 - sec->output_offset);
13648 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13650 if (code_sec == input_section)
13651 can_plt_call = TRUE;
13656 info->callbacks->einfo
13657 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13658 "recompile with -fPIC\n"),
13659 input_bfd, input_section, rel->r_offset, sym_name);
13661 bfd_set_error (bfd_error_bad_value);
13666 && (stub_entry->stub_type == ppc_stub_plt_call
13667 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13668 unresolved_reloc = FALSE;
13671 if ((stub_entry == NULL
13672 || stub_entry->stub_type == ppc_stub_long_branch
13673 || stub_entry->stub_type == ppc_stub_plt_branch)
13674 && get_opd_info (sec) != NULL)
13676 /* The branch destination is the value of the opd entry. */
13677 bfd_vma off = (relocation + addend
13678 - sec->output_section->vma
13679 - sec->output_offset);
13680 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13681 if (dest != (bfd_vma) -1)
13685 reloc_dest = DEST_OPD;
13689 /* If the branch is out of reach we ought to have a long
13691 from = (rel->r_offset
13692 + input_section->output_offset
13693 + input_section->output_section->vma);
13695 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13699 if (stub_entry != NULL
13700 && (stub_entry->stub_type == ppc_stub_long_branch
13701 || stub_entry->stub_type == ppc_stub_plt_branch)
13702 && (r_type == R_PPC64_ADDR14_BRTAKEN
13703 || r_type == R_PPC64_ADDR14_BRNTAKEN
13704 || (relocation + addend - from + max_br_offset
13705 < 2 * max_br_offset)))
13706 /* Don't use the stub if this branch is in range. */
13709 if (stub_entry != NULL)
13711 /* Munge up the value and addend so that we call the stub
13712 rather than the procedure directly. */
13713 relocation = (stub_entry->stub_offset
13714 + stub_entry->stub_sec->output_offset
13715 + stub_entry->stub_sec->output_section->vma);
13717 reloc_dest = DEST_STUB;
13719 if ((stub_entry->stub_type == ppc_stub_plt_call
13720 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13721 && (ALWAYS_EMIT_R2SAVE
13722 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13723 && rel + 1 < relend
13724 && rel[1].r_offset == rel->r_offset + 4
13725 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13733 /* Set 'a' bit. This is 0b00010 in BO field for branch
13734 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13735 for branch on CTR insns (BO == 1a00t or 1a01t). */
13736 if ((insn & (0x14 << 21)) == (0x04 << 21))
13737 insn |= 0x02 << 21;
13738 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13739 insn |= 0x08 << 21;
13745 /* Invert 'y' bit if not the default. */
13746 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13747 insn ^= 0x01 << 21;
13750 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13753 /* NOP out calls to undefined weak functions.
13754 We can thus call a weak function without first
13755 checking whether the function is defined. */
13757 && h->elf.root.type == bfd_link_hash_undefweak
13758 && h->elf.dynindx == -1
13759 && r_type == R_PPC64_REL24
13763 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13769 /* Set `addend'. */
13774 info->callbacks->einfo
13775 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13776 input_bfd, (int) r_type, sym_name);
13778 bfd_set_error (bfd_error_bad_value);
13784 case R_PPC64_TLSGD:
13785 case R_PPC64_TLSLD:
13786 case R_PPC64_TOCSAVE:
13787 case R_PPC64_GNU_VTINHERIT:
13788 case R_PPC64_GNU_VTENTRY:
13791 /* GOT16 relocations. Like an ADDR16 using the symbol's
13792 address in the GOT as relocation value instead of the
13793 symbol's value itself. Also, create a GOT entry for the
13794 symbol and put the symbol value there. */
13795 case R_PPC64_GOT_TLSGD16:
13796 case R_PPC64_GOT_TLSGD16_LO:
13797 case R_PPC64_GOT_TLSGD16_HI:
13798 case R_PPC64_GOT_TLSGD16_HA:
13799 tls_type = TLS_TLS | TLS_GD;
13802 case R_PPC64_GOT_TLSLD16:
13803 case R_PPC64_GOT_TLSLD16_LO:
13804 case R_PPC64_GOT_TLSLD16_HI:
13805 case R_PPC64_GOT_TLSLD16_HA:
13806 tls_type = TLS_TLS | TLS_LD;
13809 case R_PPC64_GOT_TPREL16_DS:
13810 case R_PPC64_GOT_TPREL16_LO_DS:
13811 case R_PPC64_GOT_TPREL16_HI:
13812 case R_PPC64_GOT_TPREL16_HA:
13813 tls_type = TLS_TLS | TLS_TPREL;
13816 case R_PPC64_GOT_DTPREL16_DS:
13817 case R_PPC64_GOT_DTPREL16_LO_DS:
13818 case R_PPC64_GOT_DTPREL16_HI:
13819 case R_PPC64_GOT_DTPREL16_HA:
13820 tls_type = TLS_TLS | TLS_DTPREL;
13823 case R_PPC64_GOT16:
13824 case R_PPC64_GOT16_LO:
13825 case R_PPC64_GOT16_HI:
13826 case R_PPC64_GOT16_HA:
13827 case R_PPC64_GOT16_DS:
13828 case R_PPC64_GOT16_LO_DS:
13831 /* Relocation is to the entry for this symbol in the global
13836 unsigned long indx = 0;
13837 struct got_entry *ent;
13839 if (tls_type == (TLS_TLS | TLS_LD)
13841 || !h->elf.def_dynamic))
13842 ent = ppc64_tlsld_got (input_bfd);
13848 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13849 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13852 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13853 /* This is actually a static link, or it is a
13854 -Bsymbolic link and the symbol is defined
13855 locally, or the symbol was forced to be local
13856 because of a version file. */
13860 BFD_ASSERT (h->elf.dynindx != -1);
13861 indx = h->elf.dynindx;
13862 unresolved_reloc = FALSE;
13864 ent = h->elf.got.glist;
13868 if (local_got_ents == NULL)
13870 ent = local_got_ents[r_symndx];
13873 for (; ent != NULL; ent = ent->next)
13874 if (ent->addend == orig_rel.r_addend
13875 && ent->owner == input_bfd
13876 && ent->tls_type == tls_type)
13882 if (ent->is_indirect)
13883 ent = ent->got.ent;
13884 offp = &ent->got.offset;
13885 got = ppc64_elf_tdata (ent->owner)->got;
13889 /* The offset must always be a multiple of 8. We use the
13890 least significant bit to record whether we have already
13891 processed this entry. */
13893 if ((off & 1) != 0)
13897 /* Generate relocs for the dynamic linker, except in
13898 the case of TLSLD where we'll use one entry per
13906 ? h->elf.type == STT_GNU_IFUNC
13907 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13909 relgot = htab->elf.irelplt;
13910 else if ((info->shared || indx != 0)
13912 || (tls_type == (TLS_TLS | TLS_LD)
13913 && !h->elf.def_dynamic)
13914 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13915 || h->elf.root.type != bfd_link_hash_undefweak))
13916 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13917 if (relgot != NULL)
13919 outrel.r_offset = (got->output_section->vma
13920 + got->output_offset
13922 outrel.r_addend = addend;
13923 if (tls_type & (TLS_LD | TLS_GD))
13925 outrel.r_addend = 0;
13926 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13927 if (tls_type == (TLS_TLS | TLS_GD))
13929 loc = relgot->contents;
13930 loc += (relgot->reloc_count++
13931 * sizeof (Elf64_External_Rela));
13932 bfd_elf64_swap_reloca_out (output_bfd,
13934 outrel.r_offset += 8;
13935 outrel.r_addend = addend;
13937 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13940 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13941 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13942 else if (tls_type == (TLS_TLS | TLS_TPREL))
13943 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13944 else if (indx != 0)
13945 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13949 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13951 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13953 /* Write the .got section contents for the sake
13955 loc = got->contents + off;
13956 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13960 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13962 outrel.r_addend += relocation;
13963 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13964 outrel.r_addend -= htab->elf.tls_sec->vma;
13966 loc = relgot->contents;
13967 loc += (relgot->reloc_count++
13968 * sizeof (Elf64_External_Rela));
13969 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13972 /* Init the .got section contents here if we're not
13973 emitting a reloc. */
13976 relocation += addend;
13977 if (tls_type == (TLS_TLS | TLS_LD))
13979 else if (tls_type != 0)
13981 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13982 if (tls_type == (TLS_TLS | TLS_TPREL))
13983 relocation += DTP_OFFSET - TP_OFFSET;
13985 if (tls_type == (TLS_TLS | TLS_GD))
13987 bfd_put_64 (output_bfd, relocation,
13988 got->contents + off + 8);
13993 bfd_put_64 (output_bfd, relocation,
13994 got->contents + off);
13998 if (off >= (bfd_vma) -2)
14001 relocation = got->output_section->vma + got->output_offset + off;
14002 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14006 case R_PPC64_PLT16_HA:
14007 case R_PPC64_PLT16_HI:
14008 case R_PPC64_PLT16_LO:
14009 case R_PPC64_PLT32:
14010 case R_PPC64_PLT64:
14011 /* Relocation is to the entry for this symbol in the
14012 procedure linkage table. */
14014 /* Resolve a PLT reloc against a local symbol directly,
14015 without using the procedure linkage table. */
14019 /* It's possible that we didn't make a PLT entry for this
14020 symbol. This happens when statically linking PIC code,
14021 or when using -Bsymbolic. Go find a match if there is a
14023 if (htab->elf.splt != NULL)
14025 struct plt_entry *ent;
14026 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14027 if (ent->plt.offset != (bfd_vma) -1
14028 && ent->addend == orig_rel.r_addend)
14030 relocation = (htab->elf.splt->output_section->vma
14031 + htab->elf.splt->output_offset
14032 + ent->plt.offset);
14033 unresolved_reloc = FALSE;
14040 /* Relocation value is TOC base. */
14041 relocation = TOCstart;
14042 if (r_symndx == STN_UNDEF)
14043 relocation += htab->stub_group[input_section->id].toc_off;
14044 else if (unresolved_reloc)
14046 else if (sec != NULL && sec->id <= htab->top_id)
14047 relocation += htab->stub_group[sec->id].toc_off;
14049 unresolved_reloc = TRUE;
14052 /* TOC16 relocs. We want the offset relative to the TOC base,
14053 which is the address of the start of the TOC plus 0x8000.
14054 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14056 case R_PPC64_TOC16:
14057 case R_PPC64_TOC16_LO:
14058 case R_PPC64_TOC16_HI:
14059 case R_PPC64_TOC16_DS:
14060 case R_PPC64_TOC16_LO_DS:
14061 case R_PPC64_TOC16_HA:
14062 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14065 /* Relocate against the beginning of the section. */
14066 case R_PPC64_SECTOFF:
14067 case R_PPC64_SECTOFF_LO:
14068 case R_PPC64_SECTOFF_HI:
14069 case R_PPC64_SECTOFF_DS:
14070 case R_PPC64_SECTOFF_LO_DS:
14071 case R_PPC64_SECTOFF_HA:
14073 addend -= sec->output_section->vma;
14076 case R_PPC64_REL16:
14077 case R_PPC64_REL16_LO:
14078 case R_PPC64_REL16_HI:
14079 case R_PPC64_REL16_HA:
14082 case R_PPC64_REL14:
14083 case R_PPC64_REL14_BRNTAKEN:
14084 case R_PPC64_REL14_BRTAKEN:
14085 case R_PPC64_REL24:
14088 case R_PPC64_TPREL16:
14089 case R_PPC64_TPREL16_LO:
14090 case R_PPC64_TPREL16_HI:
14091 case R_PPC64_TPREL16_HA:
14092 case R_PPC64_TPREL16_DS:
14093 case R_PPC64_TPREL16_LO_DS:
14094 case R_PPC64_TPREL16_HIGH:
14095 case R_PPC64_TPREL16_HIGHA:
14096 case R_PPC64_TPREL16_HIGHER:
14097 case R_PPC64_TPREL16_HIGHERA:
14098 case R_PPC64_TPREL16_HIGHEST:
14099 case R_PPC64_TPREL16_HIGHESTA:
14101 && h->elf.root.type == bfd_link_hash_undefweak
14102 && h->elf.dynindx == -1)
14104 /* Make this relocation against an undefined weak symbol
14105 resolve to zero. This is really just a tweak, since
14106 code using weak externs ought to check that they are
14107 defined before using them. */
14108 bfd_byte *p = contents + rel->r_offset - d_offset;
14110 insn = bfd_get_32 (output_bfd, p);
14111 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14113 bfd_put_32 (output_bfd, insn, p);
14116 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14118 /* The TPREL16 relocs shouldn't really be used in shared
14119 libs as they will result in DT_TEXTREL being set, but
14120 support them anyway. */
14124 case R_PPC64_DTPREL16:
14125 case R_PPC64_DTPREL16_LO:
14126 case R_PPC64_DTPREL16_HI:
14127 case R_PPC64_DTPREL16_HA:
14128 case R_PPC64_DTPREL16_DS:
14129 case R_PPC64_DTPREL16_LO_DS:
14130 case R_PPC64_DTPREL16_HIGH:
14131 case R_PPC64_DTPREL16_HIGHA:
14132 case R_PPC64_DTPREL16_HIGHER:
14133 case R_PPC64_DTPREL16_HIGHERA:
14134 case R_PPC64_DTPREL16_HIGHEST:
14135 case R_PPC64_DTPREL16_HIGHESTA:
14136 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14139 case R_PPC64_DTPMOD64:
14144 case R_PPC64_TPREL64:
14145 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14148 case R_PPC64_DTPREL64:
14149 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14152 /* Relocations that may need to be propagated if this is a
14154 case R_PPC64_REL30:
14155 case R_PPC64_REL32:
14156 case R_PPC64_REL64:
14157 case R_PPC64_ADDR14:
14158 case R_PPC64_ADDR14_BRNTAKEN:
14159 case R_PPC64_ADDR14_BRTAKEN:
14160 case R_PPC64_ADDR16:
14161 case R_PPC64_ADDR16_DS:
14162 case R_PPC64_ADDR16_HA:
14163 case R_PPC64_ADDR16_HI:
14164 case R_PPC64_ADDR16_HIGH:
14165 case R_PPC64_ADDR16_HIGHA:
14166 case R_PPC64_ADDR16_HIGHER:
14167 case R_PPC64_ADDR16_HIGHERA:
14168 case R_PPC64_ADDR16_HIGHEST:
14169 case R_PPC64_ADDR16_HIGHESTA:
14170 case R_PPC64_ADDR16_LO:
14171 case R_PPC64_ADDR16_LO_DS:
14172 case R_PPC64_ADDR24:
14173 case R_PPC64_ADDR32:
14174 case R_PPC64_ADDR64:
14175 case R_PPC64_UADDR16:
14176 case R_PPC64_UADDR32:
14177 case R_PPC64_UADDR64:
14179 if ((input_section->flags & SEC_ALLOC) == 0)
14182 if (NO_OPD_RELOCS && is_opd)
14187 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14188 || h->elf.root.type != bfd_link_hash_undefweak)
14189 && (must_be_dyn_reloc (info, r_type)
14190 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14191 || (ELIMINATE_COPY_RELOCS
14194 && h->elf.dynindx != -1
14195 && !h->elf.non_got_ref
14196 && !h->elf.def_regular)
14199 ? h->elf.type == STT_GNU_IFUNC
14200 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14202 bfd_boolean skip, relocate;
14206 /* When generating a dynamic object, these relocations
14207 are copied into the output file to be resolved at run
14213 out_off = _bfd_elf_section_offset (output_bfd, info,
14214 input_section, rel->r_offset);
14215 if (out_off == (bfd_vma) -1)
14217 else if (out_off == (bfd_vma) -2)
14218 skip = TRUE, relocate = TRUE;
14219 out_off += (input_section->output_section->vma
14220 + input_section->output_offset);
14221 outrel.r_offset = out_off;
14222 outrel.r_addend = rel->r_addend;
14224 /* Optimize unaligned reloc use. */
14225 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14226 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14227 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14228 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14229 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14230 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14231 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14232 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14233 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14236 memset (&outrel, 0, sizeof outrel);
14237 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14239 && r_type != R_PPC64_TOC)
14241 BFD_ASSERT (h->elf.dynindx != -1);
14242 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14246 /* This symbol is local, or marked to become local,
14247 or this is an opd section reloc which must point
14248 at a local function. */
14249 outrel.r_addend += relocation;
14250 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14252 if (is_opd && h != NULL)
14254 /* Lie about opd entries. This case occurs
14255 when building shared libraries and we
14256 reference a function in another shared
14257 lib. The same thing happens for a weak
14258 definition in an application that's
14259 overridden by a strong definition in a
14260 shared lib. (I believe this is a generic
14261 bug in binutils handling of weak syms.)
14262 In these cases we won't use the opd
14263 entry in this lib. */
14264 unresolved_reloc = FALSE;
14267 && r_type == R_PPC64_ADDR64
14269 ? h->elf.type == STT_GNU_IFUNC
14270 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14271 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14274 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14276 /* We need to relocate .opd contents for ld.so.
14277 Prelink also wants simple and consistent rules
14278 for relocs. This make all RELATIVE relocs have
14279 *r_offset equal to r_addend. */
14288 ? h->elf.type == STT_GNU_IFUNC
14289 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14291 info->callbacks->einfo
14292 (_("%P: %H: %s for indirect "
14293 "function `%T' unsupported\n"),
14294 input_bfd, input_section, rel->r_offset,
14295 ppc64_elf_howto_table[r_type]->name,
14299 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14301 else if (sec == NULL || sec->owner == NULL)
14303 bfd_set_error (bfd_error_bad_value);
14310 osec = sec->output_section;
14311 indx = elf_section_data (osec)->dynindx;
14315 if ((osec->flags & SEC_READONLY) == 0
14316 && htab->elf.data_index_section != NULL)
14317 osec = htab->elf.data_index_section;
14319 osec = htab->elf.text_index_section;
14320 indx = elf_section_data (osec)->dynindx;
14322 BFD_ASSERT (indx != 0);
14324 /* We are turning this relocation into one
14325 against a section symbol, so subtract out
14326 the output section's address but not the
14327 offset of the input section in the output
14329 outrel.r_addend -= osec->vma;
14332 outrel.r_info = ELF64_R_INFO (indx, r_type);
14336 sreloc = elf_section_data (input_section)->sreloc;
14338 ? h->elf.type == STT_GNU_IFUNC
14339 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14340 sreloc = htab->elf.irelplt;
14341 if (sreloc == NULL)
14344 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14347 loc = sreloc->contents;
14348 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14349 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14351 /* If this reloc is against an external symbol, it will
14352 be computed at runtime, so there's no need to do
14353 anything now. However, for the sake of prelink ensure
14354 that the section contents are a known value. */
14357 unresolved_reloc = FALSE;
14358 /* The value chosen here is quite arbitrary as ld.so
14359 ignores section contents except for the special
14360 case of .opd where the contents might be accessed
14361 before relocation. Choose zero, as that won't
14362 cause reloc overflow. */
14365 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14366 to improve backward compatibility with older
14368 if (r_type == R_PPC64_ADDR64)
14369 addend = outrel.r_addend;
14370 /* Adjust pc_relative relocs to have zero in *r_offset. */
14371 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14372 addend = (input_section->output_section->vma
14373 + input_section->output_offset
14380 case R_PPC64_GLOB_DAT:
14381 case R_PPC64_JMP_SLOT:
14382 case R_PPC64_JMP_IREL:
14383 case R_PPC64_RELATIVE:
14384 /* We shouldn't ever see these dynamic relocs in relocatable
14386 /* Fall through. */
14388 case R_PPC64_PLTGOT16:
14389 case R_PPC64_PLTGOT16_DS:
14390 case R_PPC64_PLTGOT16_HA:
14391 case R_PPC64_PLTGOT16_HI:
14392 case R_PPC64_PLTGOT16_LO:
14393 case R_PPC64_PLTGOT16_LO_DS:
14394 case R_PPC64_PLTREL32:
14395 case R_PPC64_PLTREL64:
14396 /* These ones haven't been implemented yet. */
14398 info->callbacks->einfo
14399 (_("%P: %B: %s is not supported for `%T'\n"),
14401 ppc64_elf_howto_table[r_type]->name, sym_name);
14403 bfd_set_error (bfd_error_invalid_operation);
14408 /* Multi-instruction sequences that access the TOC can be
14409 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14410 to nop; addi rb,r2,x; */
14416 case R_PPC64_GOT_TLSLD16_HI:
14417 case R_PPC64_GOT_TLSGD16_HI:
14418 case R_PPC64_GOT_TPREL16_HI:
14419 case R_PPC64_GOT_DTPREL16_HI:
14420 case R_PPC64_GOT16_HI:
14421 case R_PPC64_TOC16_HI:
14422 /* These relocs would only be useful if building up an
14423 offset to later add to r2, perhaps in an indexed
14424 addressing mode instruction. Don't try to optimize.
14425 Unfortunately, the possibility of someone building up an
14426 offset like this or even with the HA relocs, means that
14427 we need to check the high insn when optimizing the low
14431 case R_PPC64_GOT_TLSLD16_HA:
14432 case R_PPC64_GOT_TLSGD16_HA:
14433 case R_PPC64_GOT_TPREL16_HA:
14434 case R_PPC64_GOT_DTPREL16_HA:
14435 case R_PPC64_GOT16_HA:
14436 case R_PPC64_TOC16_HA:
14437 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14438 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14440 bfd_byte *p = contents + (rel->r_offset & ~3);
14441 bfd_put_32 (input_bfd, NOP, p);
14445 case R_PPC64_GOT_TLSLD16_LO:
14446 case R_PPC64_GOT_TLSGD16_LO:
14447 case R_PPC64_GOT_TPREL16_LO_DS:
14448 case R_PPC64_GOT_DTPREL16_LO_DS:
14449 case R_PPC64_GOT16_LO:
14450 case R_PPC64_GOT16_LO_DS:
14451 case R_PPC64_TOC16_LO:
14452 case R_PPC64_TOC16_LO_DS:
14453 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14454 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14456 bfd_byte *p = contents + (rel->r_offset & ~3);
14457 insn = bfd_get_32 (input_bfd, p);
14458 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14460 /* Transform addic to addi when we change reg. */
14461 insn &= ~((0x3f << 26) | (0x1f << 16));
14462 insn |= (14u << 26) | (2 << 16);
14466 insn &= ~(0x1f << 16);
14469 bfd_put_32 (input_bfd, insn, p);
14474 /* Do any further special processing. */
14480 case R_PPC64_REL16_HA:
14481 case R_PPC64_ADDR16_HA:
14482 case R_PPC64_ADDR16_HIGHA:
14483 case R_PPC64_ADDR16_HIGHERA:
14484 case R_PPC64_ADDR16_HIGHESTA:
14485 case R_PPC64_TOC16_HA:
14486 case R_PPC64_SECTOFF_HA:
14487 case R_PPC64_TPREL16_HA:
14488 case R_PPC64_TPREL16_HIGHA:
14489 case R_PPC64_TPREL16_HIGHERA:
14490 case R_PPC64_TPREL16_HIGHESTA:
14491 case R_PPC64_DTPREL16_HA:
14492 case R_PPC64_DTPREL16_HIGHA:
14493 case R_PPC64_DTPREL16_HIGHERA:
14494 case R_PPC64_DTPREL16_HIGHESTA:
14495 /* It's just possible that this symbol is a weak symbol
14496 that's not actually defined anywhere. In that case,
14497 'sec' would be NULL, and we should leave the symbol
14498 alone (it will be set to zero elsewhere in the link). */
14503 case R_PPC64_GOT16_HA:
14504 case R_PPC64_PLTGOT16_HA:
14505 case R_PPC64_PLT16_HA:
14506 case R_PPC64_GOT_TLSGD16_HA:
14507 case R_PPC64_GOT_TLSLD16_HA:
14508 case R_PPC64_GOT_TPREL16_HA:
14509 case R_PPC64_GOT_DTPREL16_HA:
14510 /* Add 0x10000 if sign bit in 0:15 is set.
14511 Bits 0:15 are not used. */
14515 case R_PPC64_ADDR16_DS:
14516 case R_PPC64_ADDR16_LO_DS:
14517 case R_PPC64_GOT16_DS:
14518 case R_PPC64_GOT16_LO_DS:
14519 case R_PPC64_PLT16_LO_DS:
14520 case R_PPC64_SECTOFF_DS:
14521 case R_PPC64_SECTOFF_LO_DS:
14522 case R_PPC64_TOC16_DS:
14523 case R_PPC64_TOC16_LO_DS:
14524 case R_PPC64_PLTGOT16_DS:
14525 case R_PPC64_PLTGOT16_LO_DS:
14526 case R_PPC64_GOT_TPREL16_DS:
14527 case R_PPC64_GOT_TPREL16_LO_DS:
14528 case R_PPC64_GOT_DTPREL16_DS:
14529 case R_PPC64_GOT_DTPREL16_LO_DS:
14530 case R_PPC64_TPREL16_DS:
14531 case R_PPC64_TPREL16_LO_DS:
14532 case R_PPC64_DTPREL16_DS:
14533 case R_PPC64_DTPREL16_LO_DS:
14534 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14536 /* If this reloc is against an lq insn, then the value must be
14537 a multiple of 16. This is somewhat of a hack, but the
14538 "correct" way to do this by defining _DQ forms of all the
14539 _DS relocs bloats all reloc switches in this file. It
14540 doesn't seem to make much sense to use any of these relocs
14541 in data, so testing the insn should be safe. */
14542 if ((insn & (0x3f << 26)) == (56u << 26))
14544 if (((relocation + addend) & mask) != 0)
14546 info->callbacks->einfo
14547 (_("%P: %H: error: %s not a multiple of %u\n"),
14548 input_bfd, input_section, rel->r_offset,
14549 ppc64_elf_howto_table[r_type]->name,
14551 bfd_set_error (bfd_error_bad_value);
14558 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14559 because such sections are not SEC_ALLOC and thus ld.so will
14560 not process them. */
14561 if (unresolved_reloc
14562 && !((input_section->flags & SEC_DEBUGGING) != 0
14563 && h->elf.def_dynamic)
14564 && _bfd_elf_section_offset (output_bfd, info, input_section,
14565 rel->r_offset) != (bfd_vma) -1)
14567 info->callbacks->einfo
14568 (_("%P: %H: unresolvable %s against `%T'\n"),
14569 input_bfd, input_section, rel->r_offset,
14570 ppc64_elf_howto_table[(int) r_type]->name,
14571 h->elf.root.root.string);
14575 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14583 if (r != bfd_reloc_ok)
14585 char *more_info = NULL;
14586 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14588 if (reloc_dest != DEST_NORMAL)
14590 more_info = bfd_malloc (strlen (reloc_name) + 8);
14591 if (more_info != NULL)
14593 strcpy (more_info, reloc_name);
14594 strcat (more_info, (reloc_dest == DEST_OPD
14595 ? " (OPD)" : " (stub)"));
14596 reloc_name = more_info;
14600 if (r == bfd_reloc_overflow)
14605 && h->elf.root.type == bfd_link_hash_undefweak
14606 && ppc64_elf_howto_table[r_type]->pc_relative)
14608 /* Assume this is a call protected by other code that
14609 detects the symbol is undefined. If this is the case,
14610 we can safely ignore the overflow. If not, the
14611 program is hosed anyway, and a little warning isn't
14617 if (!((*info->callbacks->reloc_overflow)
14618 (info, &h->elf.root, sym_name,
14619 reloc_name, orig_rel.r_addend,
14620 input_bfd, input_section, rel->r_offset)))
14625 info->callbacks->einfo
14626 (_("%P: %H: %s against `%T': error %d\n"),
14627 input_bfd, input_section, rel->r_offset,
14628 reloc_name, sym_name, (int) r);
14631 if (more_info != NULL)
14636 /* If we're emitting relocations, then shortly after this function
14637 returns, reloc offsets and addends for this section will be
14638 adjusted. Worse, reloc symbol indices will be for the output
14639 file rather than the input. Save a copy of the relocs for
14640 opd_entry_value. */
14641 if (is_opd && (info->emitrelocations || info->relocatable))
14644 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14645 rel = bfd_alloc (input_bfd, amt);
14646 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14647 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14650 memcpy (rel, relocs, amt);
14655 /* Adjust the value of any local symbols in opd sections. */
14658 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14659 const char *name ATTRIBUTE_UNUSED,
14660 Elf_Internal_Sym *elfsym,
14661 asection *input_sec,
14662 struct elf_link_hash_entry *h)
14664 struct _opd_sec_data *opd;
14671 opd = get_opd_info (input_sec);
14672 if (opd == NULL || opd->adjust == NULL)
14675 value = elfsym->st_value - input_sec->output_offset;
14676 if (!info->relocatable)
14677 value -= input_sec->output_section->vma;
14679 adjust = opd->adjust[value / 8];
14683 elfsym->st_value += adjust;
14687 /* Finish up dynamic symbol handling. We set the contents of various
14688 dynamic sections here. */
14691 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14692 struct bfd_link_info *info,
14693 struct elf_link_hash_entry *h,
14694 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14696 struct ppc_link_hash_table *htab;
14697 struct plt_entry *ent;
14698 Elf_Internal_Rela rela;
14701 htab = ppc_hash_table (info);
14705 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14706 if (ent->plt.offset != (bfd_vma) -1)
14708 /* This symbol has an entry in the procedure linkage
14709 table. Set it up. */
14710 if (!htab->elf.dynamic_sections_created
14711 || h->dynindx == -1)
14713 BFD_ASSERT (h->type == STT_GNU_IFUNC
14715 && (h->root.type == bfd_link_hash_defined
14716 || h->root.type == bfd_link_hash_defweak));
14717 rela.r_offset = (htab->elf.iplt->output_section->vma
14718 + htab->elf.iplt->output_offset
14719 + ent->plt.offset);
14721 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14723 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14724 rela.r_addend = (h->root.u.def.value
14725 + h->root.u.def.section->output_offset
14726 + h->root.u.def.section->output_section->vma
14728 loc = (htab->elf.irelplt->contents
14729 + (htab->elf.irelplt->reloc_count++
14730 * sizeof (Elf64_External_Rela)));
14734 rela.r_offset = (htab->elf.splt->output_section->vma
14735 + htab->elf.splt->output_offset
14736 + ent->plt.offset);
14737 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14738 rela.r_addend = ent->addend;
14739 loc = (htab->elf.srelplt->contents
14740 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14741 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14743 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14745 if (!htab->opd_abi)
14747 if (!h->def_regular)
14749 /* Mark the symbol as undefined, rather than as
14750 defined in glink. Leave the value if there were
14751 any relocations where pointer equality matters
14752 (this is a clue for the dynamic linker, to make
14753 function pointer comparisons work between an
14754 application and shared library), otherwise set it
14756 sym->st_shndx = SHN_UNDEF;
14757 if (!h->pointer_equality_needed)
14759 else if (!h->ref_regular_nonweak)
14761 /* This breaks function pointer comparisons, but
14762 that is better than breaking tests for a NULL
14763 function pointer. */
14772 /* This symbol needs a copy reloc. Set it up. */
14774 if (h->dynindx == -1
14775 || (h->root.type != bfd_link_hash_defined
14776 && h->root.type != bfd_link_hash_defweak)
14777 || htab->relbss == NULL)
14780 rela.r_offset = (h->root.u.def.value
14781 + h->root.u.def.section->output_section->vma
14782 + h->root.u.def.section->output_offset);
14783 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14785 loc = htab->relbss->contents;
14786 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14787 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14793 /* Used to decide how to sort relocs in an optimal manner for the
14794 dynamic linker, before writing them out. */
14796 static enum elf_reloc_type_class
14797 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14798 const asection *rel_sec,
14799 const Elf_Internal_Rela *rela)
14801 enum elf_ppc64_reloc_type r_type;
14802 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14804 if (rel_sec == htab->elf.irelplt)
14805 return reloc_class_ifunc;
14807 r_type = ELF64_R_TYPE (rela->r_info);
14810 case R_PPC64_RELATIVE:
14811 return reloc_class_relative;
14812 case R_PPC64_JMP_SLOT:
14813 return reloc_class_plt;
14815 return reloc_class_copy;
14817 return reloc_class_normal;
14821 /* Finish up the dynamic sections. */
14824 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14825 struct bfd_link_info *info)
14827 struct ppc_link_hash_table *htab;
14831 htab = ppc_hash_table (info);
14835 dynobj = htab->elf.dynobj;
14836 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14838 if (htab->elf.dynamic_sections_created)
14840 Elf64_External_Dyn *dyncon, *dynconend;
14842 if (sdyn == NULL || htab->elf.sgot == NULL)
14845 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14846 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14847 for (; dyncon < dynconend; dyncon++)
14849 Elf_Internal_Dyn dyn;
14852 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14859 case DT_PPC64_GLINK:
14861 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14862 /* We stupidly defined DT_PPC64_GLINK to be the start
14863 of glink rather than the first entry point, which is
14864 what ld.so needs, and now have a bigger stub to
14865 support automatic multiple TOCs. */
14866 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14870 s = bfd_get_section_by_name (output_bfd, ".opd");
14873 dyn.d_un.d_ptr = s->vma;
14877 if (htab->do_multi_toc && htab->multi_toc_needed)
14878 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14881 case DT_PPC64_OPDSZ:
14882 s = bfd_get_section_by_name (output_bfd, ".opd");
14885 dyn.d_un.d_val = s->size;
14889 s = htab->elf.splt;
14890 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14894 s = htab->elf.srelplt;
14895 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14899 dyn.d_un.d_val = htab->elf.srelplt->size;
14903 /* Don't count procedure linkage table relocs in the
14904 overall reloc count. */
14905 s = htab->elf.srelplt;
14908 dyn.d_un.d_val -= s->size;
14912 /* We may not be using the standard ELF linker script.
14913 If .rela.plt is the first .rela section, we adjust
14914 DT_RELA to not include it. */
14915 s = htab->elf.srelplt;
14918 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14920 dyn.d_un.d_ptr += s->size;
14924 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14928 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14930 /* Fill in the first entry in the global offset table.
14931 We use it to hold the link-time TOCbase. */
14932 bfd_put_64 (output_bfd,
14933 elf_gp (output_bfd) + TOC_BASE_OFF,
14934 htab->elf.sgot->contents);
14936 /* Set .got entry size. */
14937 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14940 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14942 /* Set .plt entry size. */
14943 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14944 = PLT_ENTRY_SIZE (htab);
14947 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14948 brlt ourselves if emitrelocations. */
14949 if (htab->brlt != NULL
14950 && htab->brlt->reloc_count != 0
14951 && !_bfd_elf_link_output_relocs (output_bfd,
14953 elf_section_data (htab->brlt)->rela.hdr,
14954 elf_section_data (htab->brlt)->relocs,
14958 if (htab->glink != NULL
14959 && htab->glink->reloc_count != 0
14960 && !_bfd_elf_link_output_relocs (output_bfd,
14962 elf_section_data (htab->glink)->rela.hdr,
14963 elf_section_data (htab->glink)->relocs,
14968 if (htab->glink_eh_frame != NULL
14969 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14970 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14971 htab->glink_eh_frame,
14972 htab->glink_eh_frame->contents))
14975 /* We need to handle writing out multiple GOT sections ourselves,
14976 since we didn't add them to DYNOBJ. We know dynobj is the first
14978 while ((dynobj = dynobj->link_next) != NULL)
14982 if (!is_ppc64_elf (dynobj))
14985 s = ppc64_elf_tdata (dynobj)->got;
14988 && s->output_section != bfd_abs_section_ptr
14989 && !bfd_set_section_contents (output_bfd, s->output_section,
14990 s->contents, s->output_offset,
14993 s = ppc64_elf_tdata (dynobj)->relgot;
14996 && s->output_section != bfd_abs_section_ptr
14997 && !bfd_set_section_contents (output_bfd, s->output_section,
14998 s->contents, s->output_offset,
15006 #include "elf64-target.h"
15008 /* FreeBSD support */
15010 #undef TARGET_LITTLE_SYM
15011 #undef TARGET_LITTLE_NAME
15013 #undef TARGET_BIG_SYM
15014 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15015 #undef TARGET_BIG_NAME
15016 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15019 #define ELF_OSABI ELFOSABI_FREEBSD
15022 #define elf64_bed elf64_powerpc_fbsd_bed
15024 #include "elf64-target.h"