]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf64-ppc.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Correct elf64-ppc.c linkage stub comment and formatting fixes
[thirdparty/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2018 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
69 #define elf_info_to_howto ppc64_elf_info_to_howto
70
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_want_dynrelro 1
77 #define elf_backend_can_gc_sections 1
78 #define elf_backend_can_refcount 1
79 #define elf_backend_rela_normal 1
80 #define elf_backend_dtrel_excludes_plt 1
81 #define elf_backend_default_execstack 0
82
83 #define bfd_elf64_mkobject ppc64_elf_mkobject
84 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
85 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
86 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
87 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
88 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
89 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
90 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
91 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
92 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
93
94 #define elf_backend_object_p ppc64_elf_object_p
95 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
96 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
97 #define elf_backend_write_core_note ppc64_elf_write_core_note
98 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
99 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
100 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
101 #define elf_backend_check_directives ppc64_elf_before_check_relocs
102 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
103 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
104 #define elf_backend_check_relocs ppc64_elf_check_relocs
105 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
106 #define elf_backend_gc_keep ppc64_elf_gc_keep
107 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
108 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
109 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
110 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
111 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
112 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
113 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
114 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
115 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
116 #define elf_backend_action_discarded ppc64_elf_action_discarded
117 #define elf_backend_relocate_section ppc64_elf_relocate_section
118 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
119 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
120 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
121 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
122 #define elf_backend_special_sections ppc64_elf_special_sections
123 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
124 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
125 #define elf_backend_get_reloc_section bfd_get_section_by_name
126
127 /* The name of the dynamic interpreter. This is put in the .interp
128 section. */
129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
130
131 /* The size in bytes of an entry in the procedure linkage table. */
132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
134
135 /* The initial size of the plt reserved for the dynamic linker. */
136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
137
138 /* Offsets to some stack save slots. */
139 #define STK_LR 16
140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
141 /* This one is dodgy. ELFv2 does not have a linker word, so use the
142 CR save slot. Used only by optimised __tls_get_addr call stub,
143 relying on __tls_get_addr_opt not saving CR.. */
144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
145
146 /* TOC base pointers offset from start of TOC. */
147 #define TOC_BASE_OFF 0x8000
148 /* TOC base alignment. */
149 #define TOC_BASE_ALIGN 256
150
151 /* Offset of tp and dtp pointers from start of TLS block. */
152 #define TP_OFFSET 0x7000
153 #define DTP_OFFSET 0x8000
154
155 /* .plt call stub instructions. The normal stub is like this, but
156 sometimes the .plt entry crosses a 64k boundary and we need to
157 insert an addi to adjust r11. */
158 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
159 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
160 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
161 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
162 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
163 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
164 #define BCTR 0x4e800420 /* bctr */
165
166 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
167 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
168 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
169 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
170 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
171
172 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
173 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
174 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
175 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
176 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
177 #define BNECTR 0x4ca20420 /* bnectr+ */
178 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
179
180 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
181 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
182 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
183
184 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
185 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
186 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
187
188 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
189 #define LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
190 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
191 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
192 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
193 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
194 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
195 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
196 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
197 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
198 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
199 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
200
201 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
202 #define GLINK_PLTRESOLVE_SIZE(htab) \
203 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
204 /* 0: */
205 /* .quad plt0-1f */
206 /* __glink: */
207 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
208 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
209 /* 1: */
210 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
211 /* ld %2,(0b-1b)(%11) */
212 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
213 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
214 /* ld %12,0(%11) */
215 /* ld %2,8(%11) */
216 /* mtctr %12 */
217 /* ld %11,16(%11) */
218 /* bctr */
219 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
220 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
221 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
222 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
223 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
224
225 /* Pad with this. */
226 #define NOP 0x60000000
227
228 /* Some other nops. */
229 #define CROR_151515 0x4def7b82
230 #define CROR_313131 0x4ffffb82
231
232 /* .glink entries for the first 32k functions are two instructions. */
233 #define LI_R0_0 0x38000000 /* li %r0,0 */
234 #define B_DOT 0x48000000 /* b . */
235
236 /* After that, we need two instructions to load the index, followed by
237 a branch. */
238 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
239 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
240
241 /* Instructions used by the save and restore reg functions. */
242 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
243 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
244 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
245 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
246 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
247 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
248 #define LI_R12_0 0x39800000 /* li %r12,0 */
249 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
250 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
251 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
252 #define BLR 0x4e800020 /* blr */
253
254 /* Since .opd is an array of descriptors and each entry will end up
255 with identical R_PPC64_RELATIVE relocs, there is really no need to
256 propagate .opd relocs; The dynamic linker should be taught to
257 relocate .opd without reloc entries. */
258 #ifndef NO_OPD_RELOCS
259 #define NO_OPD_RELOCS 0
260 #endif
261
262 #ifndef ARRAY_SIZE
263 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
264 #endif
265
266 static inline int
267 abiversion (bfd *abfd)
268 {
269 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
270 }
271
272 static inline void
273 set_abiversion (bfd *abfd, int ver)
274 {
275 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
276 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
277 }
278 \f
279 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
280
281 /* Relocation HOWTO's. */
282 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
283
284 static reloc_howto_type ppc64_elf_howto_raw[] =
285 {
286 /* This reloc does nothing. */
287 HOWTO (R_PPC64_NONE, /* type */
288 0, /* rightshift */
289 3, /* size (0 = byte, 1 = short, 2 = long) */
290 0, /* bitsize */
291 FALSE, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_dont, /* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_PPC64_NONE", /* name */
296 FALSE, /* partial_inplace */
297 0, /* src_mask */
298 0, /* dst_mask */
299 FALSE), /* pcrel_offset */
300
301 /* A standard 32 bit relocation. */
302 HOWTO (R_PPC64_ADDR32, /* type */
303 0, /* rightshift */
304 2, /* size (0 = byte, 1 = short, 2 = long) */
305 32, /* bitsize */
306 FALSE, /* pc_relative */
307 0, /* bitpos */
308 complain_overflow_bitfield, /* complain_on_overflow */
309 bfd_elf_generic_reloc, /* special_function */
310 "R_PPC64_ADDR32", /* name */
311 FALSE, /* partial_inplace */
312 0, /* src_mask */
313 0xffffffff, /* dst_mask */
314 FALSE), /* pcrel_offset */
315
316 /* An absolute 26 bit branch; the lower two bits must be zero.
317 FIXME: we don't check that, we just clear them. */
318 HOWTO (R_PPC64_ADDR24, /* type */
319 0, /* rightshift */
320 2, /* size (0 = byte, 1 = short, 2 = long) */
321 26, /* bitsize */
322 FALSE, /* pc_relative */
323 0, /* bitpos */
324 complain_overflow_bitfield, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_PPC64_ADDR24", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0x03fffffc, /* dst_mask */
330 FALSE), /* pcrel_offset */
331
332 /* A standard 16 bit relocation. */
333 HOWTO (R_PPC64_ADDR16, /* type */
334 0, /* rightshift */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
336 16, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_bitfield, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_PPC64_ADDR16", /* name */
342 FALSE, /* partial_inplace */
343 0, /* src_mask */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 /* A 16 bit relocation without overflow. */
348 HOWTO (R_PPC64_ADDR16_LO, /* type */
349 0, /* rightshift */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 FALSE, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_dont,/* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_PPC64_ADDR16_LO", /* name */
357 FALSE, /* partial_inplace */
358 0, /* src_mask */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
361
362 /* Bits 16-31 of an address. */
363 HOWTO (R_PPC64_ADDR16_HI, /* type */
364 16, /* rightshift */
365 1, /* size (0 = byte, 1 = short, 2 = long) */
366 16, /* bitsize */
367 FALSE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_signed, /* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_PPC64_ADDR16_HI", /* name */
372 FALSE, /* partial_inplace */
373 0, /* src_mask */
374 0xffff, /* dst_mask */
375 FALSE), /* pcrel_offset */
376
377 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
378 bits, treated as a signed number, is negative. */
379 HOWTO (R_PPC64_ADDR16_HA, /* type */
380 16, /* rightshift */
381 1, /* size (0 = byte, 1 = short, 2 = long) */
382 16, /* bitsize */
383 FALSE, /* pc_relative */
384 0, /* bitpos */
385 complain_overflow_signed, /* complain_on_overflow */
386 ppc64_elf_ha_reloc, /* special_function */
387 "R_PPC64_ADDR16_HA", /* name */
388 FALSE, /* partial_inplace */
389 0, /* src_mask */
390 0xffff, /* dst_mask */
391 FALSE), /* pcrel_offset */
392
393 /* An absolute 16 bit branch; the lower two bits must be zero.
394 FIXME: we don't check that, we just clear them. */
395 HOWTO (R_PPC64_ADDR14, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
399 FALSE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_signed, /* complain_on_overflow */
402 ppc64_elf_branch_reloc, /* special_function */
403 "R_PPC64_ADDR14", /* name */
404 FALSE, /* partial_inplace */
405 0, /* src_mask */
406 0x0000fffc, /* dst_mask */
407 FALSE), /* pcrel_offset */
408
409 /* An absolute 16 bit branch, for which bit 10 should be set to
410 indicate that the branch is expected to be taken. The lower two
411 bits must be zero. */
412 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
416 FALSE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_signed, /* complain_on_overflow */
419 ppc64_elf_brtaken_reloc, /* special_function */
420 "R_PPC64_ADDR14_BRTAKEN",/* name */
421 FALSE, /* partial_inplace */
422 0, /* src_mask */
423 0x0000fffc, /* dst_mask */
424 FALSE), /* pcrel_offset */
425
426 /* An absolute 16 bit branch, for which bit 10 should be set to
427 indicate that the branch is not expected to be taken. The lower
428 two bits must be zero. */
429 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
430 0, /* rightshift */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
432 16, /* bitsize */
433 FALSE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_signed, /* complain_on_overflow */
436 ppc64_elf_brtaken_reloc, /* special_function */
437 "R_PPC64_ADDR14_BRNTAKEN",/* name */
438 FALSE, /* partial_inplace */
439 0, /* src_mask */
440 0x0000fffc, /* dst_mask */
441 FALSE), /* pcrel_offset */
442
443 /* A relative 26 bit branch; the lower two bits must be zero. */
444 HOWTO (R_PPC64_REL24, /* type */
445 0, /* rightshift */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
447 26, /* bitsize */
448 TRUE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_signed, /* complain_on_overflow */
451 ppc64_elf_branch_reloc, /* special_function */
452 "R_PPC64_REL24", /* name */
453 FALSE, /* partial_inplace */
454 0, /* src_mask */
455 0x03fffffc, /* dst_mask */
456 TRUE), /* pcrel_offset */
457
458 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
459 HOWTO (R_PPC64_REL24_NOTOC, /* type */
460 0, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 26, /* bitsize */
463 TRUE, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_signed, /* complain_on_overflow */
466 ppc64_elf_branch_reloc, /* special_function */
467 "R_PPC64_REL24_NOTOC", /* name */
468 FALSE, /* partial_inplace */
469 0, /* src_mask */
470 0x03fffffc, /* dst_mask */
471 TRUE), /* pcrel_offset */
472
473 /* A relative 16 bit branch; the lower two bits must be zero. */
474 HOWTO (R_PPC64_REL14, /* type */
475 0, /* rightshift */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
477 16, /* bitsize */
478 TRUE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_signed, /* complain_on_overflow */
481 ppc64_elf_branch_reloc, /* special_function */
482 "R_PPC64_REL14", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0x0000fffc, /* dst_mask */
486 TRUE), /* pcrel_offset */
487
488 /* A relative 16 bit branch. Bit 10 should be set to indicate that
489 the branch is expected to be taken. The lower two bits must be
490 zero. */
491 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
492 0, /* rightshift */
493 2, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 TRUE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_brtaken_reloc, /* special_function */
499 "R_PPC64_REL14_BRTAKEN", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0x0000fffc, /* dst_mask */
503 TRUE), /* pcrel_offset */
504
505 /* A relative 16 bit branch. Bit 10 should be set to indicate that
506 the branch is not expected to be taken. The lower two bits must
507 be zero. */
508 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
509 0, /* rightshift */
510 2, /* size (0 = byte, 1 = short, 2 = long) */
511 16, /* bitsize */
512 TRUE, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_signed, /* complain_on_overflow */
515 ppc64_elf_brtaken_reloc, /* special_function */
516 "R_PPC64_REL14_BRNTAKEN",/* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0x0000fffc, /* dst_mask */
520 TRUE), /* pcrel_offset */
521
522 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
523 symbol. */
524 HOWTO (R_PPC64_GOT16, /* type */
525 0, /* rightshift */
526 1, /* size (0 = byte, 1 = short, 2 = long) */
527 16, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_signed, /* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GOT16", /* name */
533 FALSE, /* partial_inplace */
534 0, /* src_mask */
535 0xffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
539 the symbol. */
540 HOWTO (R_PPC64_GOT16_LO, /* type */
541 0, /* rightshift */
542 1, /* size (0 = byte, 1 = short, 2 = long) */
543 16, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont, /* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_GOT16_LO", /* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0xffff, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
555 the symbol. */
556 HOWTO (R_PPC64_GOT16_HI, /* type */
557 16, /* rightshift */
558 1, /* size (0 = byte, 1 = short, 2 = long) */
559 16, /* bitsize */
560 FALSE, /* pc_relative */
561 0, /* bitpos */
562 complain_overflow_signed,/* complain_on_overflow */
563 ppc64_elf_unhandled_reloc, /* special_function */
564 "R_PPC64_GOT16_HI", /* name */
565 FALSE, /* partial_inplace */
566 0, /* src_mask */
567 0xffff, /* dst_mask */
568 FALSE), /* pcrel_offset */
569
570 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
571 the symbol. */
572 HOWTO (R_PPC64_GOT16_HA, /* type */
573 16, /* rightshift */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
575 16, /* bitsize */
576 FALSE, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_signed,/* complain_on_overflow */
579 ppc64_elf_unhandled_reloc, /* special_function */
580 "R_PPC64_GOT16_HA", /* name */
581 FALSE, /* partial_inplace */
582 0, /* src_mask */
583 0xffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
585
586 /* This is used only by the dynamic linker. The symbol should exist
587 both in the object being run and in some shared library. The
588 dynamic linker copies the data addressed by the symbol from the
589 shared library into the object, because the object being
590 run has to have the data at some particular address. */
591 HOWTO (R_PPC64_COPY, /* type */
592 0, /* rightshift */
593 0, /* this one is variable size */
594 0, /* bitsize */
595 FALSE, /* pc_relative */
596 0, /* bitpos */
597 complain_overflow_dont, /* complain_on_overflow */
598 ppc64_elf_unhandled_reloc, /* special_function */
599 "R_PPC64_COPY", /* name */
600 FALSE, /* partial_inplace */
601 0, /* src_mask */
602 0, /* dst_mask */
603 FALSE), /* pcrel_offset */
604
605 /* Like R_PPC64_ADDR64, but used when setting global offset table
606 entries. */
607 HOWTO (R_PPC64_GLOB_DAT, /* type */
608 0, /* rightshift */
609 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
610 64, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_dont, /* complain_on_overflow */
614 ppc64_elf_unhandled_reloc, /* special_function */
615 "R_PPC64_GLOB_DAT", /* name */
616 FALSE, /* partial_inplace */
617 0, /* src_mask */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Created by the link editor. Marks a procedure linkage table
622 entry for a symbol. */
623 HOWTO (R_PPC64_JMP_SLOT, /* type */
624 0, /* rightshift */
625 0, /* size (0 = byte, 1 = short, 2 = long) */
626 0, /* bitsize */
627 FALSE, /* pc_relative */
628 0, /* bitpos */
629 complain_overflow_dont, /* complain_on_overflow */
630 ppc64_elf_unhandled_reloc, /* special_function */
631 "R_PPC64_JMP_SLOT", /* name */
632 FALSE, /* partial_inplace */
633 0, /* src_mask */
634 0, /* dst_mask */
635 FALSE), /* pcrel_offset */
636
637 /* Used only by the dynamic linker. When the object is run, this
638 doubleword64 is set to the load address of the object, plus the
639 addend. */
640 HOWTO (R_PPC64_RELATIVE, /* type */
641 0, /* rightshift */
642 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
643 64, /* bitsize */
644 FALSE, /* pc_relative */
645 0, /* bitpos */
646 complain_overflow_dont, /* complain_on_overflow */
647 bfd_elf_generic_reloc, /* special_function */
648 "R_PPC64_RELATIVE", /* name */
649 FALSE, /* partial_inplace */
650 0, /* src_mask */
651 ONES (64), /* dst_mask */
652 FALSE), /* pcrel_offset */
653
654 /* Like R_PPC64_ADDR32, but may be unaligned. */
655 HOWTO (R_PPC64_UADDR32, /* type */
656 0, /* rightshift */
657 2, /* size (0 = byte, 1 = short, 2 = long) */
658 32, /* bitsize */
659 FALSE, /* pc_relative */
660 0, /* bitpos */
661 complain_overflow_bitfield, /* complain_on_overflow */
662 bfd_elf_generic_reloc, /* special_function */
663 "R_PPC64_UADDR32", /* name */
664 FALSE, /* partial_inplace */
665 0, /* src_mask */
666 0xffffffff, /* dst_mask */
667 FALSE), /* pcrel_offset */
668
669 /* Like R_PPC64_ADDR16, but may be unaligned. */
670 HOWTO (R_PPC64_UADDR16, /* type */
671 0, /* rightshift */
672 1, /* size (0 = byte, 1 = short, 2 = long) */
673 16, /* bitsize */
674 FALSE, /* pc_relative */
675 0, /* bitpos */
676 complain_overflow_bitfield, /* complain_on_overflow */
677 bfd_elf_generic_reloc, /* special_function */
678 "R_PPC64_UADDR16", /* name */
679 FALSE, /* partial_inplace */
680 0, /* src_mask */
681 0xffff, /* dst_mask */
682 FALSE), /* pcrel_offset */
683
684 /* 32-bit PC relative. */
685 HOWTO (R_PPC64_REL32, /* type */
686 0, /* rightshift */
687 2, /* size (0 = byte, 1 = short, 2 = long) */
688 32, /* bitsize */
689 TRUE, /* pc_relative */
690 0, /* bitpos */
691 complain_overflow_signed, /* complain_on_overflow */
692 bfd_elf_generic_reloc, /* special_function */
693 "R_PPC64_REL32", /* name */
694 FALSE, /* partial_inplace */
695 0, /* src_mask */
696 0xffffffff, /* dst_mask */
697 TRUE), /* pcrel_offset */
698
699 /* 32-bit relocation to the symbol's procedure linkage table. */
700 HOWTO (R_PPC64_PLT32, /* type */
701 0, /* rightshift */
702 2, /* size (0 = byte, 1 = short, 2 = long) */
703 32, /* bitsize */
704 FALSE, /* pc_relative */
705 0, /* bitpos */
706 complain_overflow_bitfield, /* complain_on_overflow */
707 ppc64_elf_unhandled_reloc, /* special_function */
708 "R_PPC64_PLT32", /* name */
709 FALSE, /* partial_inplace */
710 0, /* src_mask */
711 0xffffffff, /* dst_mask */
712 FALSE), /* pcrel_offset */
713
714 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
715 FIXME: R_PPC64_PLTREL32 not supported. */
716 HOWTO (R_PPC64_PLTREL32, /* type */
717 0, /* rightshift */
718 2, /* size (0 = byte, 1 = short, 2 = long) */
719 32, /* bitsize */
720 TRUE, /* pc_relative */
721 0, /* bitpos */
722 complain_overflow_signed, /* complain_on_overflow */
723 ppc64_elf_unhandled_reloc, /* special_function */
724 "R_PPC64_PLTREL32", /* name */
725 FALSE, /* partial_inplace */
726 0, /* src_mask */
727 0xffffffff, /* dst_mask */
728 TRUE), /* pcrel_offset */
729
730 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
731 the symbol. */
732 HOWTO (R_PPC64_PLT16_LO, /* type */
733 0, /* rightshift */
734 1, /* size (0 = byte, 1 = short, 2 = long) */
735 16, /* bitsize */
736 FALSE, /* pc_relative */
737 0, /* bitpos */
738 complain_overflow_dont, /* complain_on_overflow */
739 ppc64_elf_unhandled_reloc, /* special_function */
740 "R_PPC64_PLT16_LO", /* name */
741 FALSE, /* partial_inplace */
742 0, /* src_mask */
743 0xffff, /* dst_mask */
744 FALSE), /* pcrel_offset */
745
746 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
747 the symbol. */
748 HOWTO (R_PPC64_PLT16_HI, /* type */
749 16, /* rightshift */
750 1, /* size (0 = byte, 1 = short, 2 = long) */
751 16, /* bitsize */
752 FALSE, /* pc_relative */
753 0, /* bitpos */
754 complain_overflow_signed, /* complain_on_overflow */
755 ppc64_elf_unhandled_reloc, /* special_function */
756 "R_PPC64_PLT16_HI", /* name */
757 FALSE, /* partial_inplace */
758 0, /* src_mask */
759 0xffff, /* dst_mask */
760 FALSE), /* pcrel_offset */
761
762 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
763 the symbol. */
764 HOWTO (R_PPC64_PLT16_HA, /* type */
765 16, /* rightshift */
766 1, /* size (0 = byte, 1 = short, 2 = long) */
767 16, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_signed, /* complain_on_overflow */
771 ppc64_elf_unhandled_reloc, /* special_function */
772 "R_PPC64_PLT16_HA", /* name */
773 FALSE, /* partial_inplace */
774 0, /* src_mask */
775 0xffff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 /* 16-bit section relative relocation. */
779 HOWTO (R_PPC64_SECTOFF, /* type */
780 0, /* rightshift */
781 1, /* size (0 = byte, 1 = short, 2 = long) */
782 16, /* bitsize */
783 FALSE, /* pc_relative */
784 0, /* bitpos */
785 complain_overflow_signed, /* complain_on_overflow */
786 ppc64_elf_sectoff_reloc, /* special_function */
787 "R_PPC64_SECTOFF", /* name */
788 FALSE, /* partial_inplace */
789 0, /* src_mask */
790 0xffff, /* dst_mask */
791 FALSE), /* pcrel_offset */
792
793 /* Like R_PPC64_SECTOFF, but no overflow warning. */
794 HOWTO (R_PPC64_SECTOFF_LO, /* type */
795 0, /* rightshift */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
797 16, /* bitsize */
798 FALSE, /* pc_relative */
799 0, /* bitpos */
800 complain_overflow_dont, /* complain_on_overflow */
801 ppc64_elf_sectoff_reloc, /* special_function */
802 "R_PPC64_SECTOFF_LO", /* name */
803 FALSE, /* partial_inplace */
804 0, /* src_mask */
805 0xffff, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 /* 16-bit upper half section relative relocation. */
809 HOWTO (R_PPC64_SECTOFF_HI, /* type */
810 16, /* rightshift */
811 1, /* size (0 = byte, 1 = short, 2 = long) */
812 16, /* bitsize */
813 FALSE, /* pc_relative */
814 0, /* bitpos */
815 complain_overflow_signed, /* complain_on_overflow */
816 ppc64_elf_sectoff_reloc, /* special_function */
817 "R_PPC64_SECTOFF_HI", /* name */
818 FALSE, /* partial_inplace */
819 0, /* src_mask */
820 0xffff, /* dst_mask */
821 FALSE), /* pcrel_offset */
822
823 /* 16-bit upper half adjusted section relative relocation. */
824 HOWTO (R_PPC64_SECTOFF_HA, /* type */
825 16, /* rightshift */
826 1, /* size (0 = byte, 1 = short, 2 = long) */
827 16, /* bitsize */
828 FALSE, /* pc_relative */
829 0, /* bitpos */
830 complain_overflow_signed, /* complain_on_overflow */
831 ppc64_elf_sectoff_ha_reloc, /* special_function */
832 "R_PPC64_SECTOFF_HA", /* name */
833 FALSE, /* partial_inplace */
834 0, /* src_mask */
835 0xffff, /* dst_mask */
836 FALSE), /* pcrel_offset */
837
838 /* Like R_PPC64_REL24 without touching the two least significant bits. */
839 HOWTO (R_PPC64_REL30, /* type */
840 2, /* rightshift */
841 2, /* size (0 = byte, 1 = short, 2 = long) */
842 30, /* bitsize */
843 TRUE, /* pc_relative */
844 0, /* bitpos */
845 complain_overflow_dont, /* complain_on_overflow */
846 bfd_elf_generic_reloc, /* special_function */
847 "R_PPC64_REL30", /* name */
848 FALSE, /* partial_inplace */
849 0, /* src_mask */
850 0xfffffffc, /* dst_mask */
851 TRUE), /* pcrel_offset */
852
853 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
854
855 /* A standard 64-bit relocation. */
856 HOWTO (R_PPC64_ADDR64, /* type */
857 0, /* rightshift */
858 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
859 64, /* bitsize */
860 FALSE, /* pc_relative */
861 0, /* bitpos */
862 complain_overflow_dont, /* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_PPC64_ADDR64", /* name */
865 FALSE, /* partial_inplace */
866 0, /* src_mask */
867 ONES (64), /* dst_mask */
868 FALSE), /* pcrel_offset */
869
870 /* The bits 32-47 of an address. */
871 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
872 32, /* rightshift */
873 1, /* size (0 = byte, 1 = short, 2 = long) */
874 16, /* bitsize */
875 FALSE, /* pc_relative */
876 0, /* bitpos */
877 complain_overflow_dont, /* complain_on_overflow */
878 bfd_elf_generic_reloc, /* special_function */
879 "R_PPC64_ADDR16_HIGHER", /* name */
880 FALSE, /* partial_inplace */
881 0, /* src_mask */
882 0xffff, /* dst_mask */
883 FALSE), /* pcrel_offset */
884
885 /* The bits 32-47 of an address, plus 1 if the contents of the low
886 16 bits, treated as a signed number, is negative. */
887 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
888 32, /* rightshift */
889 1, /* size (0 = byte, 1 = short, 2 = long) */
890 16, /* bitsize */
891 FALSE, /* pc_relative */
892 0, /* bitpos */
893 complain_overflow_dont, /* complain_on_overflow */
894 ppc64_elf_ha_reloc, /* special_function */
895 "R_PPC64_ADDR16_HIGHERA", /* name */
896 FALSE, /* partial_inplace */
897 0, /* src_mask */
898 0xffff, /* dst_mask */
899 FALSE), /* pcrel_offset */
900
901 /* The bits 48-63 of an address. */
902 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
903 48, /* rightshift */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
905 16, /* bitsize */
906 FALSE, /* pc_relative */
907 0, /* bitpos */
908 complain_overflow_dont, /* complain_on_overflow */
909 bfd_elf_generic_reloc, /* special_function */
910 "R_PPC64_ADDR16_HIGHEST", /* name */
911 FALSE, /* partial_inplace */
912 0, /* src_mask */
913 0xffff, /* dst_mask */
914 FALSE), /* pcrel_offset */
915
916 /* The bits 48-63 of an address, plus 1 if the contents of the low
917 16 bits, treated as a signed number, is negative. */
918 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
919 48, /* rightshift */
920 1, /* size (0 = byte, 1 = short, 2 = long) */
921 16, /* bitsize */
922 FALSE, /* pc_relative */
923 0, /* bitpos */
924 complain_overflow_dont, /* complain_on_overflow */
925 ppc64_elf_ha_reloc, /* special_function */
926 "R_PPC64_ADDR16_HIGHESTA", /* name */
927 FALSE, /* partial_inplace */
928 0, /* src_mask */
929 0xffff, /* dst_mask */
930 FALSE), /* pcrel_offset */
931
932 /* Like ADDR64, but may be unaligned. */
933 HOWTO (R_PPC64_UADDR64, /* type */
934 0, /* rightshift */
935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
936 64, /* bitsize */
937 FALSE, /* pc_relative */
938 0, /* bitpos */
939 complain_overflow_dont, /* complain_on_overflow */
940 bfd_elf_generic_reloc, /* special_function */
941 "R_PPC64_UADDR64", /* name */
942 FALSE, /* partial_inplace */
943 0, /* src_mask */
944 ONES (64), /* dst_mask */
945 FALSE), /* pcrel_offset */
946
947 /* 64-bit relative relocation. */
948 HOWTO (R_PPC64_REL64, /* type */
949 0, /* rightshift */
950 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
951 64, /* bitsize */
952 TRUE, /* pc_relative */
953 0, /* bitpos */
954 complain_overflow_dont, /* complain_on_overflow */
955 bfd_elf_generic_reloc, /* special_function */
956 "R_PPC64_REL64", /* name */
957 FALSE, /* partial_inplace */
958 0, /* src_mask */
959 ONES (64), /* dst_mask */
960 TRUE), /* pcrel_offset */
961
962 /* 64-bit relocation to the symbol's procedure linkage table. */
963 HOWTO (R_PPC64_PLT64, /* type */
964 0, /* rightshift */
965 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
966 64, /* bitsize */
967 FALSE, /* pc_relative */
968 0, /* bitpos */
969 complain_overflow_dont, /* complain_on_overflow */
970 ppc64_elf_unhandled_reloc, /* special_function */
971 "R_PPC64_PLT64", /* name */
972 FALSE, /* partial_inplace */
973 0, /* src_mask */
974 ONES (64), /* dst_mask */
975 FALSE), /* pcrel_offset */
976
977 /* 64-bit PC relative relocation to the symbol's procedure linkage
978 table. */
979 /* FIXME: R_PPC64_PLTREL64 not supported. */
980 HOWTO (R_PPC64_PLTREL64, /* type */
981 0, /* rightshift */
982 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
983 64, /* bitsize */
984 TRUE, /* pc_relative */
985 0, /* bitpos */
986 complain_overflow_dont, /* complain_on_overflow */
987 ppc64_elf_unhandled_reloc, /* special_function */
988 "R_PPC64_PLTREL64", /* name */
989 FALSE, /* partial_inplace */
990 0, /* src_mask */
991 ONES (64), /* dst_mask */
992 TRUE), /* pcrel_offset */
993
994 /* 16 bit TOC-relative relocation. */
995
996 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
997 HOWTO (R_PPC64_TOC16, /* type */
998 0, /* rightshift */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 16, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_signed, /* complain_on_overflow */
1004 ppc64_elf_toc_reloc, /* special_function */
1005 "R_PPC64_TOC16", /* name */
1006 FALSE, /* partial_inplace */
1007 0, /* src_mask */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 /* 16 bit TOC-relative relocation without overflow. */
1012
1013 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
1014 HOWTO (R_PPC64_TOC16_LO, /* type */
1015 0, /* rightshift */
1016 1, /* size (0 = byte, 1 = short, 2 = long) */
1017 16, /* bitsize */
1018 FALSE, /* pc_relative */
1019 0, /* bitpos */
1020 complain_overflow_dont, /* complain_on_overflow */
1021 ppc64_elf_toc_reloc, /* special_function */
1022 "R_PPC64_TOC16_LO", /* name */
1023 FALSE, /* partial_inplace */
1024 0, /* src_mask */
1025 0xffff, /* dst_mask */
1026 FALSE), /* pcrel_offset */
1027
1028 /* 16 bit TOC-relative relocation, high 16 bits. */
1029
1030 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1031 HOWTO (R_PPC64_TOC16_HI, /* type */
1032 16, /* rightshift */
1033 1, /* size (0 = byte, 1 = short, 2 = long) */
1034 16, /* bitsize */
1035 FALSE, /* pc_relative */
1036 0, /* bitpos */
1037 complain_overflow_signed, /* complain_on_overflow */
1038 ppc64_elf_toc_reloc, /* special_function */
1039 "R_PPC64_TOC16_HI", /* name */
1040 FALSE, /* partial_inplace */
1041 0, /* src_mask */
1042 0xffff, /* dst_mask */
1043 FALSE), /* pcrel_offset */
1044
1045 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1046 contents of the low 16 bits, treated as a signed number, is
1047 negative. */
1048
1049 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1050 HOWTO (R_PPC64_TOC16_HA, /* type */
1051 16, /* rightshift */
1052 1, /* size (0 = byte, 1 = short, 2 = long) */
1053 16, /* bitsize */
1054 FALSE, /* pc_relative */
1055 0, /* bitpos */
1056 complain_overflow_signed, /* complain_on_overflow */
1057 ppc64_elf_toc_ha_reloc, /* special_function */
1058 "R_PPC64_TOC16_HA", /* name */
1059 FALSE, /* partial_inplace */
1060 0, /* src_mask */
1061 0xffff, /* dst_mask */
1062 FALSE), /* pcrel_offset */
1063
1064 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1065
1066 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1067 HOWTO (R_PPC64_TOC, /* type */
1068 0, /* rightshift */
1069 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1070 64, /* bitsize */
1071 FALSE, /* pc_relative */
1072 0, /* bitpos */
1073 complain_overflow_dont, /* complain_on_overflow */
1074 ppc64_elf_toc64_reloc, /* special_function */
1075 "R_PPC64_TOC", /* name */
1076 FALSE, /* partial_inplace */
1077 0, /* src_mask */
1078 ONES (64), /* dst_mask */
1079 FALSE), /* pcrel_offset */
1080
1081 /* Like R_PPC64_GOT16, but also informs the link editor that the
1082 value to relocate may (!) refer to a PLT entry which the link
1083 editor (a) may replace with the symbol value. If the link editor
1084 is unable to fully resolve the symbol, it may (b) create a PLT
1085 entry and store the address to the new PLT entry in the GOT.
1086 This permits lazy resolution of function symbols at run time.
1087 The link editor may also skip all of this and just (c) emit a
1088 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1089 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1090 HOWTO (R_PPC64_PLTGOT16, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_PLTGOT16", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xffff, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_PLTGOT16, but without overflow. */
1105 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1106 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1107 0, /* rightshift */
1108 1, /* size (0 = byte, 1 = short, 2 = long) */
1109 16, /* bitsize */
1110 FALSE, /* pc_relative */
1111 0, /* bitpos */
1112 complain_overflow_dont, /* complain_on_overflow */
1113 ppc64_elf_unhandled_reloc, /* special_function */
1114 "R_PPC64_PLTGOT16_LO", /* name */
1115 FALSE, /* partial_inplace */
1116 0, /* src_mask */
1117 0xffff, /* dst_mask */
1118 FALSE), /* pcrel_offset */
1119
1120 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1121 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1122 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1123 16, /* rightshift */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1125 16, /* bitsize */
1126 FALSE, /* pc_relative */
1127 0, /* bitpos */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 ppc64_elf_unhandled_reloc, /* special_function */
1130 "R_PPC64_PLTGOT16_HI", /* name */
1131 FALSE, /* partial_inplace */
1132 0, /* src_mask */
1133 0xffff, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1135
1136 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1137 1 if the contents of the low 16 bits, treated as a signed number,
1138 is negative. */
1139 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1140 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1141 16, /* rightshift */
1142 1, /* size (0 = byte, 1 = short, 2 = long) */
1143 16, /* bitsize */
1144 FALSE, /* pc_relative */
1145 0, /* bitpos */
1146 complain_overflow_signed, /* complain_on_overflow */
1147 ppc64_elf_unhandled_reloc, /* special_function */
1148 "R_PPC64_PLTGOT16_HA", /* name */
1149 FALSE, /* partial_inplace */
1150 0, /* src_mask */
1151 0xffff, /* dst_mask */
1152 FALSE), /* pcrel_offset */
1153
1154 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1155 HOWTO (R_PPC64_ADDR16_DS, /* type */
1156 0, /* rightshift */
1157 1, /* size (0 = byte, 1 = short, 2 = long) */
1158 16, /* bitsize */
1159 FALSE, /* pc_relative */
1160 0, /* bitpos */
1161 complain_overflow_signed, /* complain_on_overflow */
1162 bfd_elf_generic_reloc, /* special_function */
1163 "R_PPC64_ADDR16_DS", /* name */
1164 FALSE, /* partial_inplace */
1165 0, /* src_mask */
1166 0xfffc, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1168
1169 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1170 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1171 0, /* rightshift */
1172 1, /* size (0 = byte, 1 = short, 2 = long) */
1173 16, /* bitsize */
1174 FALSE, /* pc_relative */
1175 0, /* bitpos */
1176 complain_overflow_dont,/* complain_on_overflow */
1177 bfd_elf_generic_reloc, /* special_function */
1178 "R_PPC64_ADDR16_LO_DS",/* name */
1179 FALSE, /* partial_inplace */
1180 0, /* src_mask */
1181 0xfffc, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1183
1184 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1185 HOWTO (R_PPC64_GOT16_DS, /* type */
1186 0, /* rightshift */
1187 1, /* size (0 = byte, 1 = short, 2 = long) */
1188 16, /* bitsize */
1189 FALSE, /* pc_relative */
1190 0, /* bitpos */
1191 complain_overflow_signed, /* complain_on_overflow */
1192 ppc64_elf_unhandled_reloc, /* special_function */
1193 "R_PPC64_GOT16_DS", /* name */
1194 FALSE, /* partial_inplace */
1195 0, /* src_mask */
1196 0xfffc, /* dst_mask */
1197 FALSE), /* pcrel_offset */
1198
1199 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1200 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1201 0, /* rightshift */
1202 1, /* size (0 = byte, 1 = short, 2 = long) */
1203 16, /* bitsize */
1204 FALSE, /* pc_relative */
1205 0, /* bitpos */
1206 complain_overflow_dont, /* complain_on_overflow */
1207 ppc64_elf_unhandled_reloc, /* special_function */
1208 "R_PPC64_GOT16_LO_DS", /* name */
1209 FALSE, /* partial_inplace */
1210 0, /* src_mask */
1211 0xfffc, /* dst_mask */
1212 FALSE), /* pcrel_offset */
1213
1214 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1215 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1216 0, /* rightshift */
1217 1, /* size (0 = byte, 1 = short, 2 = long) */
1218 16, /* bitsize */
1219 FALSE, /* pc_relative */
1220 0, /* bitpos */
1221 complain_overflow_dont, /* complain_on_overflow */
1222 ppc64_elf_unhandled_reloc, /* special_function */
1223 "R_PPC64_PLT16_LO_DS", /* name */
1224 FALSE, /* partial_inplace */
1225 0, /* src_mask */
1226 0xfffc, /* dst_mask */
1227 FALSE), /* pcrel_offset */
1228
1229 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1230 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1231 0, /* rightshift */
1232 1, /* size (0 = byte, 1 = short, 2 = long) */
1233 16, /* bitsize */
1234 FALSE, /* pc_relative */
1235 0, /* bitpos */
1236 complain_overflow_signed, /* complain_on_overflow */
1237 ppc64_elf_sectoff_reloc, /* special_function */
1238 "R_PPC64_SECTOFF_DS", /* name */
1239 FALSE, /* partial_inplace */
1240 0, /* src_mask */
1241 0xfffc, /* dst_mask */
1242 FALSE), /* pcrel_offset */
1243
1244 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1245 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1246 0, /* rightshift */
1247 1, /* size (0 = byte, 1 = short, 2 = long) */
1248 16, /* bitsize */
1249 FALSE, /* pc_relative */
1250 0, /* bitpos */
1251 complain_overflow_dont, /* complain_on_overflow */
1252 ppc64_elf_sectoff_reloc, /* special_function */
1253 "R_PPC64_SECTOFF_LO_DS",/* name */
1254 FALSE, /* partial_inplace */
1255 0, /* src_mask */
1256 0xfffc, /* dst_mask */
1257 FALSE), /* pcrel_offset */
1258
1259 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1260 HOWTO (R_PPC64_TOC16_DS, /* type */
1261 0, /* rightshift */
1262 1, /* size (0 = byte, 1 = short, 2 = long) */
1263 16, /* bitsize */
1264 FALSE, /* pc_relative */
1265 0, /* bitpos */
1266 complain_overflow_signed, /* complain_on_overflow */
1267 ppc64_elf_toc_reloc, /* special_function */
1268 "R_PPC64_TOC16_DS", /* name */
1269 FALSE, /* partial_inplace */
1270 0, /* src_mask */
1271 0xfffc, /* dst_mask */
1272 FALSE), /* pcrel_offset */
1273
1274 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1275 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1276 0, /* rightshift */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 16, /* bitsize */
1279 FALSE, /* pc_relative */
1280 0, /* bitpos */
1281 complain_overflow_dont, /* complain_on_overflow */
1282 ppc64_elf_toc_reloc, /* special_function */
1283 "R_PPC64_TOC16_LO_DS", /* name */
1284 FALSE, /* partial_inplace */
1285 0, /* src_mask */
1286 0xfffc, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1288
1289 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1290 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1291 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1292 0, /* rightshift */
1293 1, /* size (0 = byte, 1 = short, 2 = long) */
1294 16, /* bitsize */
1295 FALSE, /* pc_relative */
1296 0, /* bitpos */
1297 complain_overflow_signed, /* complain_on_overflow */
1298 ppc64_elf_unhandled_reloc, /* special_function */
1299 "R_PPC64_PLTGOT16_DS", /* name */
1300 FALSE, /* partial_inplace */
1301 0, /* src_mask */
1302 0xfffc, /* dst_mask */
1303 FALSE), /* pcrel_offset */
1304
1305 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1306 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1307 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1308 0, /* rightshift */
1309 1, /* size (0 = byte, 1 = short, 2 = long) */
1310 16, /* bitsize */
1311 FALSE, /* pc_relative */
1312 0, /* bitpos */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 ppc64_elf_unhandled_reloc, /* special_function */
1315 "R_PPC64_PLTGOT16_LO_DS",/* name */
1316 FALSE, /* partial_inplace */
1317 0, /* src_mask */
1318 0xfffc, /* dst_mask */
1319 FALSE), /* pcrel_offset */
1320
1321 /* Marker relocs for TLS. */
1322 HOWTO (R_PPC64_TLS,
1323 0, /* rightshift */
1324 2, /* size (0 = byte, 1 = short, 2 = long) */
1325 32, /* bitsize */
1326 FALSE, /* pc_relative */
1327 0, /* bitpos */
1328 complain_overflow_dont, /* complain_on_overflow */
1329 bfd_elf_generic_reloc, /* special_function */
1330 "R_PPC64_TLS", /* name */
1331 FALSE, /* partial_inplace */
1332 0, /* src_mask */
1333 0, /* dst_mask */
1334 FALSE), /* pcrel_offset */
1335
1336 HOWTO (R_PPC64_TLSGD,
1337 0, /* rightshift */
1338 2, /* size (0 = byte, 1 = short, 2 = long) */
1339 32, /* bitsize */
1340 FALSE, /* pc_relative */
1341 0, /* bitpos */
1342 complain_overflow_dont, /* complain_on_overflow */
1343 bfd_elf_generic_reloc, /* special_function */
1344 "R_PPC64_TLSGD", /* name */
1345 FALSE, /* partial_inplace */
1346 0, /* src_mask */
1347 0, /* dst_mask */
1348 FALSE), /* pcrel_offset */
1349
1350 HOWTO (R_PPC64_TLSLD,
1351 0, /* rightshift */
1352 2, /* size (0 = byte, 1 = short, 2 = long) */
1353 32, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 bfd_elf_generic_reloc, /* special_function */
1358 "R_PPC64_TLSLD", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 0, /* dst_mask */
1362 FALSE), /* pcrel_offset */
1363
1364 /* Marker reloc for optimizing r2 save in prologue rather than on
1365 each plt call stub. */
1366 HOWTO (R_PPC64_TOCSAVE,
1367 0, /* rightshift */
1368 2, /* size (0 = byte, 1 = short, 2 = long) */
1369 32, /* bitsize */
1370 FALSE, /* pc_relative */
1371 0, /* bitpos */
1372 complain_overflow_dont, /* complain_on_overflow */
1373 bfd_elf_generic_reloc, /* special_function */
1374 "R_PPC64_TOCSAVE", /* name */
1375 FALSE, /* partial_inplace */
1376 0, /* src_mask */
1377 0, /* dst_mask */
1378 FALSE), /* pcrel_offset */
1379
1380 /* Marker relocs on inline plt call instructions. */
1381 HOWTO (R_PPC64_PLTSEQ,
1382 0, /* rightshift */
1383 2, /* size (0 = byte, 1 = short, 2 = long) */
1384 32, /* bitsize */
1385 FALSE, /* pc_relative */
1386 0, /* bitpos */
1387 complain_overflow_dont, /* complain_on_overflow */
1388 bfd_elf_generic_reloc, /* special_function */
1389 "R_PPC64_PLTSEQ", /* name */
1390 FALSE, /* partial_inplace */
1391 0, /* src_mask */
1392 0, /* dst_mask */
1393 FALSE), /* pcrel_offset */
1394
1395 HOWTO (R_PPC64_PLTCALL,
1396 0, /* rightshift */
1397 2, /* size (0 = byte, 1 = short, 2 = long) */
1398 32, /* bitsize */
1399 FALSE, /* pc_relative */
1400 0, /* bitpos */
1401 complain_overflow_dont, /* complain_on_overflow */
1402 bfd_elf_generic_reloc, /* special_function */
1403 "R_PPC64_PLTCALL", /* name */
1404 FALSE, /* partial_inplace */
1405 0, /* src_mask */
1406 0, /* dst_mask */
1407 FALSE), /* pcrel_offset */
1408
1409 /* Computes the load module index of the load module that contains the
1410 definition of its TLS sym. */
1411 HOWTO (R_PPC64_DTPMOD64,
1412 0, /* rightshift */
1413 4, /* size (0 = byte, 1 = short, 2 = long) */
1414 64, /* bitsize */
1415 FALSE, /* pc_relative */
1416 0, /* bitpos */
1417 complain_overflow_dont, /* complain_on_overflow */
1418 ppc64_elf_unhandled_reloc, /* special_function */
1419 "R_PPC64_DTPMOD64", /* name */
1420 FALSE, /* partial_inplace */
1421 0, /* src_mask */
1422 ONES (64), /* dst_mask */
1423 FALSE), /* pcrel_offset */
1424
1425 /* Computes a dtv-relative displacement, the difference between the value
1426 of sym+add and the base address of the thread-local storage block that
1427 contains the definition of sym, minus 0x8000. */
1428 HOWTO (R_PPC64_DTPREL64,
1429 0, /* rightshift */
1430 4, /* size (0 = byte, 1 = short, 2 = long) */
1431 64, /* bitsize */
1432 FALSE, /* pc_relative */
1433 0, /* bitpos */
1434 complain_overflow_dont, /* complain_on_overflow */
1435 ppc64_elf_unhandled_reloc, /* special_function */
1436 "R_PPC64_DTPREL64", /* name */
1437 FALSE, /* partial_inplace */
1438 0, /* src_mask */
1439 ONES (64), /* dst_mask */
1440 FALSE), /* pcrel_offset */
1441
1442 /* A 16 bit dtprel reloc. */
1443 HOWTO (R_PPC64_DTPREL16,
1444 0, /* rightshift */
1445 1, /* size (0 = byte, 1 = short, 2 = long) */
1446 16, /* bitsize */
1447 FALSE, /* pc_relative */
1448 0, /* bitpos */
1449 complain_overflow_signed, /* complain_on_overflow */
1450 ppc64_elf_unhandled_reloc, /* special_function */
1451 "R_PPC64_DTPREL16", /* name */
1452 FALSE, /* partial_inplace */
1453 0, /* src_mask */
1454 0xffff, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1456
1457 /* Like DTPREL16, but no overflow. */
1458 HOWTO (R_PPC64_DTPREL16_LO,
1459 0, /* rightshift */
1460 1, /* size (0 = byte, 1 = short, 2 = long) */
1461 16, /* bitsize */
1462 FALSE, /* pc_relative */
1463 0, /* bitpos */
1464 complain_overflow_dont, /* complain_on_overflow */
1465 ppc64_elf_unhandled_reloc, /* special_function */
1466 "R_PPC64_DTPREL16_LO", /* name */
1467 FALSE, /* partial_inplace */
1468 0, /* src_mask */
1469 0xffff, /* dst_mask */
1470 FALSE), /* pcrel_offset */
1471
1472 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1473 HOWTO (R_PPC64_DTPREL16_HI,
1474 16, /* rightshift */
1475 1, /* size (0 = byte, 1 = short, 2 = long) */
1476 16, /* bitsize */
1477 FALSE, /* pc_relative */
1478 0, /* bitpos */
1479 complain_overflow_signed, /* complain_on_overflow */
1480 ppc64_elf_unhandled_reloc, /* special_function */
1481 "R_PPC64_DTPREL16_HI", /* name */
1482 FALSE, /* partial_inplace */
1483 0, /* src_mask */
1484 0xffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1486
1487 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1488 HOWTO (R_PPC64_DTPREL16_HA,
1489 16, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1491 16, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_signed, /* complain_on_overflow */
1495 ppc64_elf_unhandled_reloc, /* special_function */
1496 "R_PPC64_DTPREL16_HA", /* name */
1497 FALSE, /* partial_inplace */
1498 0, /* src_mask */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501
1502 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1503 HOWTO (R_PPC64_DTPREL16_HIGHER,
1504 32, /* rightshift */
1505 1, /* size (0 = byte, 1 = short, 2 = long) */
1506 16, /* bitsize */
1507 FALSE, /* pc_relative */
1508 0, /* bitpos */
1509 complain_overflow_dont, /* complain_on_overflow */
1510 ppc64_elf_unhandled_reloc, /* special_function */
1511 "R_PPC64_DTPREL16_HIGHER", /* name */
1512 FALSE, /* partial_inplace */
1513 0, /* src_mask */
1514 0xffff, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1516
1517 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1518 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1519 32, /* rightshift */
1520 1, /* size (0 = byte, 1 = short, 2 = long) */
1521 16, /* bitsize */
1522 FALSE, /* pc_relative */
1523 0, /* bitpos */
1524 complain_overflow_dont, /* complain_on_overflow */
1525 ppc64_elf_unhandled_reloc, /* special_function */
1526 "R_PPC64_DTPREL16_HIGHERA", /* name */
1527 FALSE, /* partial_inplace */
1528 0, /* src_mask */
1529 0xffff, /* dst_mask */
1530 FALSE), /* pcrel_offset */
1531
1532 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1533 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1534 48, /* rightshift */
1535 1, /* size (0 = byte, 1 = short, 2 = long) */
1536 16, /* bitsize */
1537 FALSE, /* pc_relative */
1538 0, /* bitpos */
1539 complain_overflow_dont, /* complain_on_overflow */
1540 ppc64_elf_unhandled_reloc, /* special_function */
1541 "R_PPC64_DTPREL16_HIGHEST", /* name */
1542 FALSE, /* partial_inplace */
1543 0, /* src_mask */
1544 0xffff, /* dst_mask */
1545 FALSE), /* pcrel_offset */
1546
1547 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1548 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1549 48, /* rightshift */
1550 1, /* size (0 = byte, 1 = short, 2 = long) */
1551 16, /* bitsize */
1552 FALSE, /* pc_relative */
1553 0, /* bitpos */
1554 complain_overflow_dont, /* complain_on_overflow */
1555 ppc64_elf_unhandled_reloc, /* special_function */
1556 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1557 FALSE, /* partial_inplace */
1558 0, /* src_mask */
1559 0xffff, /* dst_mask */
1560 FALSE), /* pcrel_offset */
1561
1562 /* Like DTPREL16, but for insns with a DS field. */
1563 HOWTO (R_PPC64_DTPREL16_DS,
1564 0, /* rightshift */
1565 1, /* size (0 = byte, 1 = short, 2 = long) */
1566 16, /* bitsize */
1567 FALSE, /* pc_relative */
1568 0, /* bitpos */
1569 complain_overflow_signed, /* complain_on_overflow */
1570 ppc64_elf_unhandled_reloc, /* special_function */
1571 "R_PPC64_DTPREL16_DS", /* name */
1572 FALSE, /* partial_inplace */
1573 0, /* src_mask */
1574 0xfffc, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1576
1577 /* Like DTPREL16_DS, but no overflow. */
1578 HOWTO (R_PPC64_DTPREL16_LO_DS,
1579 0, /* rightshift */
1580 1, /* size (0 = byte, 1 = short, 2 = long) */
1581 16, /* bitsize */
1582 FALSE, /* pc_relative */
1583 0, /* bitpos */
1584 complain_overflow_dont, /* complain_on_overflow */
1585 ppc64_elf_unhandled_reloc, /* special_function */
1586 "R_PPC64_DTPREL16_LO_DS", /* name */
1587 FALSE, /* partial_inplace */
1588 0, /* src_mask */
1589 0xfffc, /* dst_mask */
1590 FALSE), /* pcrel_offset */
1591
1592 /* Computes a tp-relative displacement, the difference between the value of
1593 sym+add and the value of the thread pointer (r13). */
1594 HOWTO (R_PPC64_TPREL64,
1595 0, /* rightshift */
1596 4, /* size (0 = byte, 1 = short, 2 = long) */
1597 64, /* bitsize */
1598 FALSE, /* pc_relative */
1599 0, /* bitpos */
1600 complain_overflow_dont, /* complain_on_overflow */
1601 ppc64_elf_unhandled_reloc, /* special_function */
1602 "R_PPC64_TPREL64", /* name */
1603 FALSE, /* partial_inplace */
1604 0, /* src_mask */
1605 ONES (64), /* dst_mask */
1606 FALSE), /* pcrel_offset */
1607
1608 /* A 16 bit tprel reloc. */
1609 HOWTO (R_PPC64_TPREL16,
1610 0, /* rightshift */
1611 1, /* size (0 = byte, 1 = short, 2 = long) */
1612 16, /* bitsize */
1613 FALSE, /* pc_relative */
1614 0, /* bitpos */
1615 complain_overflow_signed, /* complain_on_overflow */
1616 ppc64_elf_unhandled_reloc, /* special_function */
1617 "R_PPC64_TPREL16", /* name */
1618 FALSE, /* partial_inplace */
1619 0, /* src_mask */
1620 0xffff, /* dst_mask */
1621 FALSE), /* pcrel_offset */
1622
1623 /* Like TPREL16, but no overflow. */
1624 HOWTO (R_PPC64_TPREL16_LO,
1625 0, /* rightshift */
1626 1, /* size (0 = byte, 1 = short, 2 = long) */
1627 16, /* bitsize */
1628 FALSE, /* pc_relative */
1629 0, /* bitpos */
1630 complain_overflow_dont, /* complain_on_overflow */
1631 ppc64_elf_unhandled_reloc, /* special_function */
1632 "R_PPC64_TPREL16_LO", /* name */
1633 FALSE, /* partial_inplace */
1634 0, /* src_mask */
1635 0xffff, /* dst_mask */
1636 FALSE), /* pcrel_offset */
1637
1638 /* Like TPREL16_LO, but next higher group of 16 bits. */
1639 HOWTO (R_PPC64_TPREL16_HI,
1640 16, /* rightshift */
1641 1, /* size (0 = byte, 1 = short, 2 = long) */
1642 16, /* bitsize */
1643 FALSE, /* pc_relative */
1644 0, /* bitpos */
1645 complain_overflow_signed, /* complain_on_overflow */
1646 ppc64_elf_unhandled_reloc, /* special_function */
1647 "R_PPC64_TPREL16_HI", /* name */
1648 FALSE, /* partial_inplace */
1649 0, /* src_mask */
1650 0xffff, /* dst_mask */
1651 FALSE), /* pcrel_offset */
1652
1653 /* Like TPREL16_HI, but adjust for low 16 bits. */
1654 HOWTO (R_PPC64_TPREL16_HA,
1655 16, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1657 16, /* bitsize */
1658 FALSE, /* pc_relative */
1659 0, /* bitpos */
1660 complain_overflow_signed, /* complain_on_overflow */
1661 ppc64_elf_unhandled_reloc, /* special_function */
1662 "R_PPC64_TPREL16_HA", /* name */
1663 FALSE, /* partial_inplace */
1664 0, /* src_mask */
1665 0xffff, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1667
1668 /* Like TPREL16_HI, but next higher group of 16 bits. */
1669 HOWTO (R_PPC64_TPREL16_HIGHER,
1670 32, /* rightshift */
1671 1, /* size (0 = byte, 1 = short, 2 = long) */
1672 16, /* bitsize */
1673 FALSE, /* pc_relative */
1674 0, /* bitpos */
1675 complain_overflow_dont, /* complain_on_overflow */
1676 ppc64_elf_unhandled_reloc, /* special_function */
1677 "R_PPC64_TPREL16_HIGHER", /* name */
1678 FALSE, /* partial_inplace */
1679 0, /* src_mask */
1680 0xffff, /* dst_mask */
1681 FALSE), /* pcrel_offset */
1682
1683 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1684 HOWTO (R_PPC64_TPREL16_HIGHERA,
1685 32, /* rightshift */
1686 1, /* size (0 = byte, 1 = short, 2 = long) */
1687 16, /* bitsize */
1688 FALSE, /* pc_relative */
1689 0, /* bitpos */
1690 complain_overflow_dont, /* complain_on_overflow */
1691 ppc64_elf_unhandled_reloc, /* special_function */
1692 "R_PPC64_TPREL16_HIGHERA", /* name */
1693 FALSE, /* partial_inplace */
1694 0, /* src_mask */
1695 0xffff, /* dst_mask */
1696 FALSE), /* pcrel_offset */
1697
1698 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1699 HOWTO (R_PPC64_TPREL16_HIGHEST,
1700 48, /* rightshift */
1701 1, /* size (0 = byte, 1 = short, 2 = long) */
1702 16, /* bitsize */
1703 FALSE, /* pc_relative */
1704 0, /* bitpos */
1705 complain_overflow_dont, /* complain_on_overflow */
1706 ppc64_elf_unhandled_reloc, /* special_function */
1707 "R_PPC64_TPREL16_HIGHEST", /* name */
1708 FALSE, /* partial_inplace */
1709 0, /* src_mask */
1710 0xffff, /* dst_mask */
1711 FALSE), /* pcrel_offset */
1712
1713 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1714 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1715 48, /* rightshift */
1716 1, /* size (0 = byte, 1 = short, 2 = long) */
1717 16, /* bitsize */
1718 FALSE, /* pc_relative */
1719 0, /* bitpos */
1720 complain_overflow_dont, /* complain_on_overflow */
1721 ppc64_elf_unhandled_reloc, /* special_function */
1722 "R_PPC64_TPREL16_HIGHESTA", /* name */
1723 FALSE, /* partial_inplace */
1724 0, /* src_mask */
1725 0xffff, /* dst_mask */
1726 FALSE), /* pcrel_offset */
1727
1728 /* Like TPREL16, but for insns with a DS field. */
1729 HOWTO (R_PPC64_TPREL16_DS,
1730 0, /* rightshift */
1731 1, /* size (0 = byte, 1 = short, 2 = long) */
1732 16, /* bitsize */
1733 FALSE, /* pc_relative */
1734 0, /* bitpos */
1735 complain_overflow_signed, /* complain_on_overflow */
1736 ppc64_elf_unhandled_reloc, /* special_function */
1737 "R_PPC64_TPREL16_DS", /* name */
1738 FALSE, /* partial_inplace */
1739 0, /* src_mask */
1740 0xfffc, /* dst_mask */
1741 FALSE), /* pcrel_offset */
1742
1743 /* Like TPREL16_DS, but no overflow. */
1744 HOWTO (R_PPC64_TPREL16_LO_DS,
1745 0, /* rightshift */
1746 1, /* size (0 = byte, 1 = short, 2 = long) */
1747 16, /* bitsize */
1748 FALSE, /* pc_relative */
1749 0, /* bitpos */
1750 complain_overflow_dont, /* complain_on_overflow */
1751 ppc64_elf_unhandled_reloc, /* special_function */
1752 "R_PPC64_TPREL16_LO_DS", /* name */
1753 FALSE, /* partial_inplace */
1754 0, /* src_mask */
1755 0xfffc, /* dst_mask */
1756 FALSE), /* pcrel_offset */
1757
1758 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1759 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1760 to the first entry relative to the TOC base (r2). */
1761 HOWTO (R_PPC64_GOT_TLSGD16,
1762 0, /* rightshift */
1763 1, /* size (0 = byte, 1 = short, 2 = long) */
1764 16, /* bitsize */
1765 FALSE, /* pc_relative */
1766 0, /* bitpos */
1767 complain_overflow_signed, /* complain_on_overflow */
1768 ppc64_elf_unhandled_reloc, /* special_function */
1769 "R_PPC64_GOT_TLSGD16", /* name */
1770 FALSE, /* partial_inplace */
1771 0, /* src_mask */
1772 0xffff, /* dst_mask */
1773 FALSE), /* pcrel_offset */
1774
1775 /* Like GOT_TLSGD16, but no overflow. */
1776 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1777 0, /* rightshift */
1778 1, /* size (0 = byte, 1 = short, 2 = long) */
1779 16, /* bitsize */
1780 FALSE, /* pc_relative */
1781 0, /* bitpos */
1782 complain_overflow_dont, /* complain_on_overflow */
1783 ppc64_elf_unhandled_reloc, /* special_function */
1784 "R_PPC64_GOT_TLSGD16_LO", /* name */
1785 FALSE, /* partial_inplace */
1786 0, /* src_mask */
1787 0xffff, /* dst_mask */
1788 FALSE), /* pcrel_offset */
1789
1790 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1791 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1792 16, /* rightshift */
1793 1, /* size (0 = byte, 1 = short, 2 = long) */
1794 16, /* bitsize */
1795 FALSE, /* pc_relative */
1796 0, /* bitpos */
1797 complain_overflow_signed, /* complain_on_overflow */
1798 ppc64_elf_unhandled_reloc, /* special_function */
1799 "R_PPC64_GOT_TLSGD16_HI", /* name */
1800 FALSE, /* partial_inplace */
1801 0, /* src_mask */
1802 0xffff, /* dst_mask */
1803 FALSE), /* pcrel_offset */
1804
1805 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1806 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1807 16, /* rightshift */
1808 1, /* size (0 = byte, 1 = short, 2 = long) */
1809 16, /* bitsize */
1810 FALSE, /* pc_relative */
1811 0, /* bitpos */
1812 complain_overflow_signed, /* complain_on_overflow */
1813 ppc64_elf_unhandled_reloc, /* special_function */
1814 "R_PPC64_GOT_TLSGD16_HA", /* name */
1815 FALSE, /* partial_inplace */
1816 0, /* src_mask */
1817 0xffff, /* dst_mask */
1818 FALSE), /* pcrel_offset */
1819
1820 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1821 with values (sym+add)@dtpmod and zero, and computes the offset to the
1822 first entry relative to the TOC base (r2). */
1823 HOWTO (R_PPC64_GOT_TLSLD16,
1824 0, /* rightshift */
1825 1, /* size (0 = byte, 1 = short, 2 = long) */
1826 16, /* bitsize */
1827 FALSE, /* pc_relative */
1828 0, /* bitpos */
1829 complain_overflow_signed, /* complain_on_overflow */
1830 ppc64_elf_unhandled_reloc, /* special_function */
1831 "R_PPC64_GOT_TLSLD16", /* name */
1832 FALSE, /* partial_inplace */
1833 0, /* src_mask */
1834 0xffff, /* dst_mask */
1835 FALSE), /* pcrel_offset */
1836
1837 /* Like GOT_TLSLD16, but no overflow. */
1838 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1839 0, /* rightshift */
1840 1, /* size (0 = byte, 1 = short, 2 = long) */
1841 16, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_dont, /* complain_on_overflow */
1845 ppc64_elf_unhandled_reloc, /* special_function */
1846 "R_PPC64_GOT_TLSLD16_LO", /* name */
1847 FALSE, /* partial_inplace */
1848 0, /* src_mask */
1849 0xffff, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1853 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1854 16, /* rightshift */
1855 1, /* size (0 = byte, 1 = short, 2 = long) */
1856 16, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_signed, /* complain_on_overflow */
1860 ppc64_elf_unhandled_reloc, /* special_function */
1861 "R_PPC64_GOT_TLSLD16_HI", /* name */
1862 FALSE, /* partial_inplace */
1863 0, /* src_mask */
1864 0xffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1868 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1869 16, /* rightshift */
1870 1, /* size (0 = byte, 1 = short, 2 = long) */
1871 16, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 ppc64_elf_unhandled_reloc, /* special_function */
1876 "R_PPC64_GOT_TLSLD16_HA", /* name */
1877 FALSE, /* partial_inplace */
1878 0, /* src_mask */
1879 0xffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1883 the offset to the entry relative to the TOC base (r2). */
1884 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1885 0, /* rightshift */
1886 1, /* size (0 = byte, 1 = short, 2 = long) */
1887 16, /* bitsize */
1888 FALSE, /* pc_relative */
1889 0, /* bitpos */
1890 complain_overflow_signed, /* complain_on_overflow */
1891 ppc64_elf_unhandled_reloc, /* special_function */
1892 "R_PPC64_GOT_DTPREL16_DS", /* name */
1893 FALSE, /* partial_inplace */
1894 0, /* src_mask */
1895 0xfffc, /* dst_mask */
1896 FALSE), /* pcrel_offset */
1897
1898 /* Like GOT_DTPREL16_DS, but no overflow. */
1899 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1900 0, /* rightshift */
1901 1, /* size (0 = byte, 1 = short, 2 = long) */
1902 16, /* bitsize */
1903 FALSE, /* pc_relative */
1904 0, /* bitpos */
1905 complain_overflow_dont, /* complain_on_overflow */
1906 ppc64_elf_unhandled_reloc, /* special_function */
1907 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1908 FALSE, /* partial_inplace */
1909 0, /* src_mask */
1910 0xfffc, /* dst_mask */
1911 FALSE), /* pcrel_offset */
1912
1913 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1914 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1915 16, /* rightshift */
1916 1, /* size (0 = byte, 1 = short, 2 = long) */
1917 16, /* bitsize */
1918 FALSE, /* pc_relative */
1919 0, /* bitpos */
1920 complain_overflow_signed, /* complain_on_overflow */
1921 ppc64_elf_unhandled_reloc, /* special_function */
1922 "R_PPC64_GOT_DTPREL16_HI", /* name */
1923 FALSE, /* partial_inplace */
1924 0, /* src_mask */
1925 0xffff, /* dst_mask */
1926 FALSE), /* pcrel_offset */
1927
1928 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1929 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1930 16, /* rightshift */
1931 1, /* size (0 = byte, 1 = short, 2 = long) */
1932 16, /* bitsize */
1933 FALSE, /* pc_relative */
1934 0, /* bitpos */
1935 complain_overflow_signed, /* complain_on_overflow */
1936 ppc64_elf_unhandled_reloc, /* special_function */
1937 "R_PPC64_GOT_DTPREL16_HA", /* name */
1938 FALSE, /* partial_inplace */
1939 0, /* src_mask */
1940 0xffff, /* dst_mask */
1941 FALSE), /* pcrel_offset */
1942
1943 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1944 offset to the entry relative to the TOC base (r2). */
1945 HOWTO (R_PPC64_GOT_TPREL16_DS,
1946 0, /* rightshift */
1947 1, /* size (0 = byte, 1 = short, 2 = long) */
1948 16, /* bitsize */
1949 FALSE, /* pc_relative */
1950 0, /* bitpos */
1951 complain_overflow_signed, /* complain_on_overflow */
1952 ppc64_elf_unhandled_reloc, /* special_function */
1953 "R_PPC64_GOT_TPREL16_DS", /* name */
1954 FALSE, /* partial_inplace */
1955 0, /* src_mask */
1956 0xfffc, /* dst_mask */
1957 FALSE), /* pcrel_offset */
1958
1959 /* Like GOT_TPREL16_DS, but no overflow. */
1960 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1961 0, /* rightshift */
1962 1, /* size (0 = byte, 1 = short, 2 = long) */
1963 16, /* bitsize */
1964 FALSE, /* pc_relative */
1965 0, /* bitpos */
1966 complain_overflow_dont, /* complain_on_overflow */
1967 ppc64_elf_unhandled_reloc, /* special_function */
1968 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1969 FALSE, /* partial_inplace */
1970 0, /* src_mask */
1971 0xfffc, /* dst_mask */
1972 FALSE), /* pcrel_offset */
1973
1974 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1975 HOWTO (R_PPC64_GOT_TPREL16_HI,
1976 16, /* rightshift */
1977 1, /* size (0 = byte, 1 = short, 2 = long) */
1978 16, /* bitsize */
1979 FALSE, /* pc_relative */
1980 0, /* bitpos */
1981 complain_overflow_signed, /* complain_on_overflow */
1982 ppc64_elf_unhandled_reloc, /* special_function */
1983 "R_PPC64_GOT_TPREL16_HI", /* name */
1984 FALSE, /* partial_inplace */
1985 0, /* src_mask */
1986 0xffff, /* dst_mask */
1987 FALSE), /* pcrel_offset */
1988
1989 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1990 HOWTO (R_PPC64_GOT_TPREL16_HA,
1991 16, /* rightshift */
1992 1, /* size (0 = byte, 1 = short, 2 = long) */
1993 16, /* bitsize */
1994 FALSE, /* pc_relative */
1995 0, /* bitpos */
1996 complain_overflow_signed, /* complain_on_overflow */
1997 ppc64_elf_unhandled_reloc, /* special_function */
1998 "R_PPC64_GOT_TPREL16_HA", /* name */
1999 FALSE, /* partial_inplace */
2000 0, /* src_mask */
2001 0xffff, /* dst_mask */
2002 FALSE), /* pcrel_offset */
2003
2004 HOWTO (R_PPC64_JMP_IREL, /* type */
2005 0, /* rightshift */
2006 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2007 0, /* bitsize */
2008 FALSE, /* pc_relative */
2009 0, /* bitpos */
2010 complain_overflow_dont, /* complain_on_overflow */
2011 ppc64_elf_unhandled_reloc, /* special_function */
2012 "R_PPC64_JMP_IREL", /* name */
2013 FALSE, /* partial_inplace */
2014 0, /* src_mask */
2015 0, /* dst_mask */
2016 FALSE), /* pcrel_offset */
2017
2018 HOWTO (R_PPC64_IRELATIVE, /* type */
2019 0, /* rightshift */
2020 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2021 64, /* bitsize */
2022 FALSE, /* pc_relative */
2023 0, /* bitpos */
2024 complain_overflow_dont, /* complain_on_overflow */
2025 bfd_elf_generic_reloc, /* special_function */
2026 "R_PPC64_IRELATIVE", /* name */
2027 FALSE, /* partial_inplace */
2028 0, /* src_mask */
2029 ONES (64), /* dst_mask */
2030 FALSE), /* pcrel_offset */
2031
2032 /* A 16 bit relative relocation. */
2033 HOWTO (R_PPC64_REL16, /* type */
2034 0, /* rightshift */
2035 1, /* size (0 = byte, 1 = short, 2 = long) */
2036 16, /* bitsize */
2037 TRUE, /* pc_relative */
2038 0, /* bitpos */
2039 complain_overflow_signed, /* complain_on_overflow */
2040 bfd_elf_generic_reloc, /* special_function */
2041 "R_PPC64_REL16", /* name */
2042 FALSE, /* partial_inplace */
2043 0, /* src_mask */
2044 0xffff, /* dst_mask */
2045 TRUE), /* pcrel_offset */
2046
2047 /* A 16 bit relative relocation without overflow. */
2048 HOWTO (R_PPC64_REL16_LO, /* type */
2049 0, /* rightshift */
2050 1, /* size (0 = byte, 1 = short, 2 = long) */
2051 16, /* bitsize */
2052 TRUE, /* pc_relative */
2053 0, /* bitpos */
2054 complain_overflow_dont,/* complain_on_overflow */
2055 bfd_elf_generic_reloc, /* special_function */
2056 "R_PPC64_REL16_LO", /* name */
2057 FALSE, /* partial_inplace */
2058 0, /* src_mask */
2059 0xffff, /* dst_mask */
2060 TRUE), /* pcrel_offset */
2061
2062 /* The high order 16 bits of a relative address. */
2063 HOWTO (R_PPC64_REL16_HI, /* type */
2064 16, /* rightshift */
2065 1, /* size (0 = byte, 1 = short, 2 = long) */
2066 16, /* bitsize */
2067 TRUE, /* pc_relative */
2068 0, /* bitpos */
2069 complain_overflow_signed, /* complain_on_overflow */
2070 bfd_elf_generic_reloc, /* special_function */
2071 "R_PPC64_REL16_HI", /* name */
2072 FALSE, /* partial_inplace */
2073 0, /* src_mask */
2074 0xffff, /* dst_mask */
2075 TRUE), /* pcrel_offset */
2076
2077 /* The high order 16 bits of a relative address, plus 1 if the contents of
2078 the low 16 bits, treated as a signed number, is negative. */
2079 HOWTO (R_PPC64_REL16_HA, /* type */
2080 16, /* rightshift */
2081 1, /* size (0 = byte, 1 = short, 2 = long) */
2082 16, /* bitsize */
2083 TRUE, /* pc_relative */
2084 0, /* bitpos */
2085 complain_overflow_signed, /* complain_on_overflow */
2086 ppc64_elf_ha_reloc, /* special_function */
2087 "R_PPC64_REL16_HA", /* name */
2088 FALSE, /* partial_inplace */
2089 0, /* src_mask */
2090 0xffff, /* dst_mask */
2091 TRUE), /* pcrel_offset */
2092
2093 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2094 HOWTO (R_PPC64_REL16DX_HA, /* type */
2095 16, /* rightshift */
2096 2, /* size (0 = byte, 1 = short, 2 = long) */
2097 16, /* bitsize */
2098 TRUE, /* pc_relative */
2099 0, /* bitpos */
2100 complain_overflow_signed, /* complain_on_overflow */
2101 ppc64_elf_ha_reloc, /* special_function */
2102 "R_PPC64_REL16DX_HA", /* name */
2103 FALSE, /* partial_inplace */
2104 0, /* src_mask */
2105 0x1fffc1, /* dst_mask */
2106 TRUE), /* pcrel_offset */
2107
2108 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2109 HOWTO (R_PPC64_16DX_HA, /* type */
2110 16, /* rightshift */
2111 2, /* size (0 = byte, 1 = short, 2 = long) */
2112 16, /* bitsize */
2113 FALSE, /* pc_relative */
2114 0, /* bitpos */
2115 complain_overflow_signed, /* complain_on_overflow */
2116 ppc64_elf_ha_reloc, /* special_function */
2117 "R_PPC64_16DX_HA", /* name */
2118 FALSE, /* partial_inplace */
2119 0, /* src_mask */
2120 0x1fffc1, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2122
2123 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2124 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2125 16, /* rightshift */
2126 1, /* size (0 = byte, 1 = short, 2 = long) */
2127 16, /* bitsize */
2128 FALSE, /* pc_relative */
2129 0, /* bitpos */
2130 complain_overflow_dont, /* complain_on_overflow */
2131 bfd_elf_generic_reloc, /* special_function */
2132 "R_PPC64_ADDR16_HIGH", /* name */
2133 FALSE, /* partial_inplace */
2134 0, /* src_mask */
2135 0xffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2137
2138 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2139 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2140 16, /* rightshift */
2141 1, /* size (0 = byte, 1 = short, 2 = long) */
2142 16, /* bitsize */
2143 FALSE, /* pc_relative */
2144 0, /* bitpos */
2145 complain_overflow_dont, /* complain_on_overflow */
2146 ppc64_elf_ha_reloc, /* special_function */
2147 "R_PPC64_ADDR16_HIGHA", /* name */
2148 FALSE, /* partial_inplace */
2149 0, /* src_mask */
2150 0xffff, /* dst_mask */
2151 FALSE), /* pcrel_offset */
2152
2153 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2154 HOWTO (R_PPC64_DTPREL16_HIGH,
2155 16, /* rightshift */
2156 1, /* size (0 = byte, 1 = short, 2 = long) */
2157 16, /* bitsize */
2158 FALSE, /* pc_relative */
2159 0, /* bitpos */
2160 complain_overflow_dont, /* complain_on_overflow */
2161 ppc64_elf_unhandled_reloc, /* special_function */
2162 "R_PPC64_DTPREL16_HIGH", /* name */
2163 FALSE, /* partial_inplace */
2164 0, /* src_mask */
2165 0xffff, /* dst_mask */
2166 FALSE), /* pcrel_offset */
2167
2168 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2169 HOWTO (R_PPC64_DTPREL16_HIGHA,
2170 16, /* rightshift */
2171 1, /* size (0 = byte, 1 = short, 2 = long) */
2172 16, /* bitsize */
2173 FALSE, /* pc_relative */
2174 0, /* bitpos */
2175 complain_overflow_dont, /* complain_on_overflow */
2176 ppc64_elf_unhandled_reloc, /* special_function */
2177 "R_PPC64_DTPREL16_HIGHA", /* name */
2178 FALSE, /* partial_inplace */
2179 0, /* src_mask */
2180 0xffff, /* dst_mask */
2181 FALSE), /* pcrel_offset */
2182
2183 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2184 HOWTO (R_PPC64_TPREL16_HIGH,
2185 16, /* rightshift */
2186 1, /* size (0 = byte, 1 = short, 2 = long) */
2187 16, /* bitsize */
2188 FALSE, /* pc_relative */
2189 0, /* bitpos */
2190 complain_overflow_dont, /* complain_on_overflow */
2191 ppc64_elf_unhandled_reloc, /* special_function */
2192 "R_PPC64_TPREL16_HIGH", /* name */
2193 FALSE, /* partial_inplace */
2194 0, /* src_mask */
2195 0xffff, /* dst_mask */
2196 FALSE), /* pcrel_offset */
2197
2198 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2199 HOWTO (R_PPC64_TPREL16_HIGHA,
2200 16, /* rightshift */
2201 1, /* size (0 = byte, 1 = short, 2 = long) */
2202 16, /* bitsize */
2203 FALSE, /* pc_relative */
2204 0, /* bitpos */
2205 complain_overflow_dont, /* complain_on_overflow */
2206 ppc64_elf_unhandled_reloc, /* special_function */
2207 "R_PPC64_TPREL16_HIGHA", /* name */
2208 FALSE, /* partial_inplace */
2209 0, /* src_mask */
2210 0xffff, /* dst_mask */
2211 FALSE), /* pcrel_offset */
2212
2213 /* Marker reloc on ELFv2 large-model function entry. */
2214 HOWTO (R_PPC64_ENTRY,
2215 0, /* rightshift */
2216 2, /* size (0 = byte, 1 = short, 2 = long) */
2217 32, /* bitsize */
2218 FALSE, /* pc_relative */
2219 0, /* bitpos */
2220 complain_overflow_dont, /* complain_on_overflow */
2221 bfd_elf_generic_reloc, /* special_function */
2222 "R_PPC64_ENTRY", /* name */
2223 FALSE, /* partial_inplace */
2224 0, /* src_mask */
2225 0, /* dst_mask */
2226 FALSE), /* pcrel_offset */
2227
2228 /* Like ADDR64, but use local entry point of function. */
2229 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2230 0, /* rightshift */
2231 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2232 64, /* bitsize */
2233 FALSE, /* pc_relative */
2234 0, /* bitpos */
2235 complain_overflow_dont, /* complain_on_overflow */
2236 bfd_elf_generic_reloc, /* special_function */
2237 "R_PPC64_ADDR64_LOCAL", /* name */
2238 FALSE, /* partial_inplace */
2239 0, /* src_mask */
2240 ONES (64), /* dst_mask */
2241 FALSE), /* pcrel_offset */
2242
2243 /* GNU extension to record C++ vtable hierarchy. */
2244 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2245 0, /* rightshift */
2246 0, /* size (0 = byte, 1 = short, 2 = long) */
2247 0, /* bitsize */
2248 FALSE, /* pc_relative */
2249 0, /* bitpos */
2250 complain_overflow_dont, /* complain_on_overflow */
2251 NULL, /* special_function */
2252 "R_PPC64_GNU_VTINHERIT", /* name */
2253 FALSE, /* partial_inplace */
2254 0, /* src_mask */
2255 0, /* dst_mask */
2256 FALSE), /* pcrel_offset */
2257
2258 /* GNU extension to record C++ vtable member usage. */
2259 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2260 0, /* rightshift */
2261 0, /* size (0 = byte, 1 = short, 2 = long) */
2262 0, /* bitsize */
2263 FALSE, /* pc_relative */
2264 0, /* bitpos */
2265 complain_overflow_dont, /* complain_on_overflow */
2266 NULL, /* special_function */
2267 "R_PPC64_GNU_VTENTRY", /* name */
2268 FALSE, /* partial_inplace */
2269 0, /* src_mask */
2270 0, /* dst_mask */
2271 FALSE), /* pcrel_offset */
2272 };
2273
2274 \f
2275 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2276 be done. */
2277
2278 static void
2279 ppc_howto_init (void)
2280 {
2281 unsigned int i, type;
2282
2283 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2284 {
2285 type = ppc64_elf_howto_raw[i].type;
2286 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2287 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2288 }
2289 }
2290
2291 static reloc_howto_type *
2292 ppc64_elf_reloc_type_lookup (bfd *abfd,
2293 bfd_reloc_code_real_type code)
2294 {
2295 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2296
2297 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2298 /* Initialize howto table if needed. */
2299 ppc_howto_init ();
2300
2301 switch (code)
2302 {
2303 default:
2304 /* xgettext:c-format */
2305 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd,
2306 (int) code);
2307 bfd_set_error (bfd_error_bad_value);
2308 return NULL;
2309
2310 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2311 break;
2312 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2313 break;
2314 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2315 break;
2316 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2317 break;
2318 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2319 break;
2320 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2321 break;
2322 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2323 break;
2324 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2325 break;
2326 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2327 break;
2328 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2329 break;
2330 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2331 break;
2332 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2333 break;
2334 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2335 break;
2336 case BFD_RELOC_PPC64_REL24_NOTOC: r = R_PPC64_REL24_NOTOC;
2337 break;
2338 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2339 break;
2340 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2341 break;
2342 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2343 break;
2344 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2345 break;
2346 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2347 break;
2348 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2349 break;
2350 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2351 break;
2352 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2353 break;
2354 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2355 break;
2356 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2357 break;
2358 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2359 break;
2360 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2361 break;
2362 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2363 break;
2364 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2365 break;
2366 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2367 break;
2368 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2369 break;
2370 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2371 break;
2372 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2373 break;
2374 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2375 break;
2376 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2377 break;
2378 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2379 break;
2380 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2381 break;
2382 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2383 break;
2384 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2385 break;
2386 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2387 break;
2388 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2389 break;
2390 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2391 break;
2392 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2393 break;
2394 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2395 break;
2396 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2397 break;
2398 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2399 break;
2400 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2401 break;
2402 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2403 break;
2404 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2405 break;
2406 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2407 break;
2408 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2409 break;
2410 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2411 break;
2412 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2413 break;
2414 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2415 break;
2416 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2417 break;
2418 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2419 break;
2420 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2421 break;
2422 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2423 break;
2424 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2425 break;
2426 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2427 break;
2428 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2429 break;
2430 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2431 break;
2432 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2433 break;
2434 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2435 break;
2436 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2437 break;
2438 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2439 break;
2440 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2441 break;
2442 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2443 break;
2444 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2445 break;
2446 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2447 break;
2448 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2449 break;
2450 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2451 break;
2452 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2453 break;
2454 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2455 break;
2456 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2457 break;
2458 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2459 break;
2460 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2461 break;
2462 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2463 break;
2464 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2465 break;
2466 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2467 break;
2468 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2469 break;
2470 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2471 break;
2472 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2473 break;
2474 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2475 break;
2476 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2477 break;
2478 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2479 break;
2480 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2481 break;
2482 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2483 break;
2484 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2485 break;
2486 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2487 break;
2488 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2489 break;
2490 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2491 break;
2492 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2493 break;
2494 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2495 break;
2496 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2497 break;
2498 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2499 break;
2500 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2501 break;
2502 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2503 break;
2504 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2505 break;
2506 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2507 break;
2508 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2509 break;
2510 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2511 break;
2512 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2513 break;
2514 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2515 break;
2516 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2517 break;
2518 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2519 break;
2520 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2521 break;
2522 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2523 break;
2524 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2525 break;
2526 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2527 break;
2528 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2529 break;
2530 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2531 break;
2532 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2533 break;
2534 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2535 break;
2536 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2537 break;
2538 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2539 break;
2540 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2541 break;
2542 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2543 break;
2544 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2545 break;
2546 }
2547
2548 return ppc64_elf_howto_table[r];
2549 };
2550
2551 static reloc_howto_type *
2552 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2553 const char *r_name)
2554 {
2555 unsigned int i;
2556
2557 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2558 if (ppc64_elf_howto_raw[i].name != NULL
2559 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2560 return &ppc64_elf_howto_raw[i];
2561
2562 return NULL;
2563 }
2564
2565 /* Set the howto pointer for a PowerPC ELF reloc. */
2566
2567 static bfd_boolean
2568 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2569 Elf_Internal_Rela *dst)
2570 {
2571 unsigned int type;
2572
2573 /* Initialize howto table if needed. */
2574 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2575 ppc_howto_init ();
2576
2577 type = ELF64_R_TYPE (dst->r_info);
2578 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2579 {
2580 /* xgettext:c-format */
2581 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2582 abfd, type);
2583 bfd_set_error (bfd_error_bad_value);
2584 return FALSE;
2585 }
2586 cache_ptr->howto = ppc64_elf_howto_table[type];
2587 if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2588 {
2589 /* xgettext:c-format */
2590 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2591 abfd, type);
2592 bfd_set_error (bfd_error_bad_value);
2593 return FALSE;
2594 }
2595
2596 return TRUE;
2597 }
2598
2599 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 void *data, asection *input_section,
2604 bfd *output_bfd, char **error_message)
2605 {
2606 enum elf_ppc64_reloc_type r_type;
2607 long insn;
2608 bfd_size_type octets;
2609 bfd_vma value;
2610
2611 /* If this is a relocatable link (output_bfd test tells us), just
2612 call the generic function. Any adjustment will be done at final
2613 link time. */
2614 if (output_bfd != NULL)
2615 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2616 input_section, output_bfd, error_message);
2617
2618 /* Adjust the addend for sign extension of the low 16 bits.
2619 We won't actually be using the low 16 bits, so trashing them
2620 doesn't matter. */
2621 reloc_entry->addend += 0x8000;
2622 r_type = reloc_entry->howto->type;
2623 if (r_type != R_PPC64_REL16DX_HA)
2624 return bfd_reloc_continue;
2625
2626 value = 0;
2627 if (!bfd_is_com_section (symbol->section))
2628 value = symbol->value;
2629 value += (reloc_entry->addend
2630 + symbol->section->output_offset
2631 + symbol->section->output_section->vma);
2632 value -= (reloc_entry->address
2633 + input_section->output_offset
2634 + input_section->output_section->vma);
2635 value = (bfd_signed_vma) value >> 16;
2636
2637 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2638 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2639 insn &= ~0x1fffc1;
2640 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2641 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2642 if (value + 0x8000 > 0xffff)
2643 return bfd_reloc_overflow;
2644 return bfd_reloc_ok;
2645 }
2646
2647 static bfd_reloc_status_type
2648 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2649 void *data, asection *input_section,
2650 bfd *output_bfd, char **error_message)
2651 {
2652 if (output_bfd != NULL)
2653 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2654 input_section, output_bfd, error_message);
2655
2656 if (strcmp (symbol->section->name, ".opd") == 0
2657 && (symbol->section->owner->flags & DYNAMIC) == 0)
2658 {
2659 bfd_vma dest = opd_entry_value (symbol->section,
2660 symbol->value + reloc_entry->addend,
2661 NULL, NULL, FALSE);
2662 if (dest != (bfd_vma) -1)
2663 reloc_entry->addend = dest - (symbol->value
2664 + symbol->section->output_section->vma
2665 + symbol->section->output_offset);
2666 }
2667 else
2668 {
2669 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2670
2671 if (symbol->section->owner != abfd
2672 && symbol->section->owner != NULL
2673 && abiversion (symbol->section->owner) >= 2)
2674 {
2675 unsigned int i;
2676
2677 for (i = 0; i < symbol->section->owner->symcount; ++i)
2678 {
2679 asymbol *symdef = symbol->section->owner->outsymbols[i];
2680
2681 if (strcmp (symdef->name, symbol->name) == 0)
2682 {
2683 elfsym = (elf_symbol_type *) symdef;
2684 break;
2685 }
2686 }
2687 }
2688 reloc_entry->addend
2689 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2690 }
2691 return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696 void *data, asection *input_section,
2697 bfd *output_bfd, char **error_message)
2698 {
2699 long insn;
2700 enum elf_ppc64_reloc_type r_type;
2701 bfd_size_type octets;
2702 /* Assume 'at' branch hints. */
2703 bfd_boolean is_isa_v2 = TRUE;
2704
2705 /* If this is a relocatable link (output_bfd test tells us), just
2706 call the generic function. Any adjustment will be done at final
2707 link time. */
2708 if (output_bfd != NULL)
2709 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2710 input_section, output_bfd, error_message);
2711
2712 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2713 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2714 insn &= ~(0x01 << 21);
2715 r_type = reloc_entry->howto->type;
2716 if (r_type == R_PPC64_ADDR14_BRTAKEN
2717 || r_type == R_PPC64_REL14_BRTAKEN)
2718 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2719
2720 if (is_isa_v2)
2721 {
2722 /* Set 'a' bit. This is 0b00010 in BO field for branch
2723 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2724 for branch on CTR insns (BO == 1a00t or 1a01t). */
2725 if ((insn & (0x14 << 21)) == (0x04 << 21))
2726 insn |= 0x02 << 21;
2727 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2728 insn |= 0x08 << 21;
2729 else
2730 goto out;
2731 }
2732 else
2733 {
2734 bfd_vma target = 0;
2735 bfd_vma from;
2736
2737 if (!bfd_is_com_section (symbol->section))
2738 target = symbol->value;
2739 target += symbol->section->output_section->vma;
2740 target += symbol->section->output_offset;
2741 target += reloc_entry->addend;
2742
2743 from = (reloc_entry->address
2744 + input_section->output_offset
2745 + input_section->output_section->vma);
2746
2747 /* Invert 'y' bit if not the default. */
2748 if ((bfd_signed_vma) (target - from) < 0)
2749 insn ^= 0x01 << 21;
2750 }
2751 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2752 out:
2753 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2754 input_section, output_bfd, error_message);
2755 }
2756
2757 static bfd_reloc_status_type
2758 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2759 void *data, asection *input_section,
2760 bfd *output_bfd, char **error_message)
2761 {
2762 /* If this is a relocatable link (output_bfd test tells us), just
2763 call the generic function. Any adjustment will be done at final
2764 link time. */
2765 if (output_bfd != NULL)
2766 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2767 input_section, output_bfd, error_message);
2768
2769 /* Subtract the symbol section base address. */
2770 reloc_entry->addend -= symbol->section->output_section->vma;
2771 return bfd_reloc_continue;
2772 }
2773
2774 static bfd_reloc_status_type
2775 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2776 void *data, asection *input_section,
2777 bfd *output_bfd, char **error_message)
2778 {
2779 /* If this is a relocatable link (output_bfd test tells us), just
2780 call the generic function. Any adjustment will be done at final
2781 link time. */
2782 if (output_bfd != NULL)
2783 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2784 input_section, output_bfd, error_message);
2785
2786 /* Subtract the symbol section base address. */
2787 reloc_entry->addend -= symbol->section->output_section->vma;
2788
2789 /* Adjust the addend for sign extension of the low 16 bits. */
2790 reloc_entry->addend += 0x8000;
2791 return bfd_reloc_continue;
2792 }
2793
2794 static bfd_reloc_status_type
2795 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2796 void *data, asection *input_section,
2797 bfd *output_bfd, char **error_message)
2798 {
2799 bfd_vma TOCstart;
2800
2801 /* If this is a relocatable link (output_bfd test tells us), just
2802 call the generic function. Any adjustment will be done at final
2803 link time. */
2804 if (output_bfd != NULL)
2805 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2806 input_section, output_bfd, error_message);
2807
2808 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2809 if (TOCstart == 0)
2810 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2811
2812 /* Subtract the TOC base address. */
2813 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2814 return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819 void *data, asection *input_section,
2820 bfd *output_bfd, char **error_message)
2821 {
2822 bfd_vma TOCstart;
2823
2824 /* If this is a relocatable link (output_bfd test tells us), just
2825 call the generic function. Any adjustment will be done at final
2826 link time. */
2827 if (output_bfd != NULL)
2828 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2829 input_section, output_bfd, error_message);
2830
2831 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2832 if (TOCstart == 0)
2833 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2834
2835 /* Subtract the TOC base address. */
2836 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2837
2838 /* Adjust the addend for sign extension of the low 16 bits. */
2839 reloc_entry->addend += 0x8000;
2840 return bfd_reloc_continue;
2841 }
2842
2843 static bfd_reloc_status_type
2844 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2845 void *data, asection *input_section,
2846 bfd *output_bfd, char **error_message)
2847 {
2848 bfd_vma TOCstart;
2849 bfd_size_type octets;
2850
2851 /* If this is a relocatable link (output_bfd test tells us), just
2852 call the generic function. Any adjustment will be done at final
2853 link time. */
2854 if (output_bfd != NULL)
2855 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2856 input_section, output_bfd, error_message);
2857
2858 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2859 if (TOCstart == 0)
2860 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2861
2862 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2863 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2864 return bfd_reloc_ok;
2865 }
2866
2867 static bfd_reloc_status_type
2868 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2869 void *data, asection *input_section,
2870 bfd *output_bfd, char **error_message)
2871 {
2872 /* If this is a relocatable link (output_bfd test tells us), just
2873 call the generic function. Any adjustment will be done at final
2874 link time. */
2875 if (output_bfd != NULL)
2876 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2877 input_section, output_bfd, error_message);
2878
2879 if (error_message != NULL)
2880 {
2881 static char buf[60];
2882 sprintf (buf, "generic linker can't handle %s",
2883 reloc_entry->howto->name);
2884 *error_message = buf;
2885 }
2886 return bfd_reloc_dangerous;
2887 }
2888
2889 /* Track GOT entries needed for a given symbol. We might need more
2890 than one got entry per symbol. */
2891 struct got_entry
2892 {
2893 struct got_entry *next;
2894
2895 /* The symbol addend that we'll be placing in the GOT. */
2896 bfd_vma addend;
2897
2898 /* Unlike other ELF targets, we use separate GOT entries for the same
2899 symbol referenced from different input files. This is to support
2900 automatic multiple TOC/GOT sections, where the TOC base can vary
2901 from one input file to another. After partitioning into TOC groups
2902 we merge entries within the group.
2903
2904 Point to the BFD owning this GOT entry. */
2905 bfd *owner;
2906
2907 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2908 TLS_TPREL or TLS_DTPREL for tls entries. */
2909 unsigned char tls_type;
2910
2911 /* Non-zero if got.ent points to real entry. */
2912 unsigned char is_indirect;
2913
2914 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2915 union
2916 {
2917 bfd_signed_vma refcount;
2918 bfd_vma offset;
2919 struct got_entry *ent;
2920 } got;
2921 };
2922
2923 /* The same for PLT. */
2924 struct plt_entry
2925 {
2926 struct plt_entry *next;
2927
2928 bfd_vma addend;
2929
2930 union
2931 {
2932 bfd_signed_vma refcount;
2933 bfd_vma offset;
2934 } plt;
2935 };
2936
2937 struct ppc64_elf_obj_tdata
2938 {
2939 struct elf_obj_tdata elf;
2940
2941 /* Shortcuts to dynamic linker sections. */
2942 asection *got;
2943 asection *relgot;
2944
2945 /* Used during garbage collection. We attach global symbols defined
2946 on removed .opd entries to this section so that the sym is removed. */
2947 asection *deleted_section;
2948
2949 /* TLS local dynamic got entry handling. Support for multiple GOT
2950 sections means we potentially need one of these for each input bfd. */
2951 struct got_entry tlsld_got;
2952
2953 union
2954 {
2955 /* A copy of relocs before they are modified for --emit-relocs. */
2956 Elf_Internal_Rela *relocs;
2957
2958 /* Section contents. */
2959 bfd_byte *contents;
2960 } opd;
2961
2962 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2963 the reloc to be in the range -32768 to 32767. */
2964 unsigned int has_small_toc_reloc : 1;
2965
2966 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2967 instruction not one we handle. */
2968 unsigned int unexpected_toc_insn : 1;
2969 };
2970
2971 #define ppc64_elf_tdata(bfd) \
2972 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2973
2974 #define ppc64_tlsld_got(bfd) \
2975 (&ppc64_elf_tdata (bfd)->tlsld_got)
2976
2977 #define is_ppc64_elf(bfd) \
2978 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2979 && elf_object_id (bfd) == PPC64_ELF_DATA)
2980
2981 /* Override the generic function because we store some extras. */
2982
2983 static bfd_boolean
2984 ppc64_elf_mkobject (bfd *abfd)
2985 {
2986 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2987 PPC64_ELF_DATA);
2988 }
2989
2990 /* Fix bad default arch selected for a 64 bit input bfd when the
2991 default is 32 bit. Also select arch based on apuinfo. */
2992
2993 static bfd_boolean
2994 ppc64_elf_object_p (bfd *abfd)
2995 {
2996 if (!abfd->arch_info->the_default)
2997 return TRUE;
2998
2999 if (abfd->arch_info->bits_per_word == 32)
3000 {
3001 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
3002
3003 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
3004 {
3005 /* Relies on arch after 32 bit default being 64 bit default. */
3006 abfd->arch_info = abfd->arch_info->next;
3007 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
3008 }
3009 }
3010 return _bfd_elf_ppc_set_arch (abfd);
3011 }
3012
3013 /* Support for core dump NOTE sections. */
3014
3015 static bfd_boolean
3016 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3017 {
3018 size_t offset, size;
3019
3020 if (note->descsz != 504)
3021 return FALSE;
3022
3023 /* pr_cursig */
3024 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3025
3026 /* pr_pid */
3027 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3028
3029 /* pr_reg */
3030 offset = 112;
3031 size = 384;
3032
3033 /* Make a ".reg/999" section. */
3034 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3035 size, note->descpos + offset);
3036 }
3037
3038 static bfd_boolean
3039 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3040 {
3041 if (note->descsz != 136)
3042 return FALSE;
3043
3044 elf_tdata (abfd)->core->pid
3045 = bfd_get_32 (abfd, note->descdata + 24);
3046 elf_tdata (abfd)->core->program
3047 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3048 elf_tdata (abfd)->core->command
3049 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3050
3051 return TRUE;
3052 }
3053
3054 static char *
3055 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3056 ...)
3057 {
3058 switch (note_type)
3059 {
3060 default:
3061 return NULL;
3062
3063 case NT_PRPSINFO:
3064 {
3065 char data[136] ATTRIBUTE_NONSTRING;
3066 va_list ap;
3067
3068 va_start (ap, note_type);
3069 memset (data, 0, sizeof (data));
3070 strncpy (data + 40, va_arg (ap, const char *), 16);
3071 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3072 DIAGNOSTIC_PUSH;
3073 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3074 -Wstringop-truncation:
3075 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3076 */
3077 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3078 #endif
3079 strncpy (data + 56, va_arg (ap, const char *), 80);
3080 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3081 DIAGNOSTIC_POP;
3082 #endif
3083 va_end (ap);
3084 return elfcore_write_note (abfd, buf, bufsiz,
3085 "CORE", note_type, data, sizeof (data));
3086 }
3087
3088 case NT_PRSTATUS:
3089 {
3090 char data[504];
3091 va_list ap;
3092 long pid;
3093 int cursig;
3094 const void *greg;
3095
3096 va_start (ap, note_type);
3097 memset (data, 0, 112);
3098 pid = va_arg (ap, long);
3099 bfd_put_32 (abfd, pid, data + 32);
3100 cursig = va_arg (ap, int);
3101 bfd_put_16 (abfd, cursig, data + 12);
3102 greg = va_arg (ap, const void *);
3103 memcpy (data + 112, greg, 384);
3104 memset (data + 496, 0, 8);
3105 va_end (ap);
3106 return elfcore_write_note (abfd, buf, bufsiz,
3107 "CORE", note_type, data, sizeof (data));
3108 }
3109 }
3110 }
3111
3112 /* Add extra PPC sections. */
3113
3114 static const struct bfd_elf_special_section ppc64_elf_special_sections[] =
3115 {
3116 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3117 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3118 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3119 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3120 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3121 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3122 { NULL, 0, 0, 0, 0 }
3123 };
3124
3125 enum _ppc64_sec_type {
3126 sec_normal = 0,
3127 sec_opd = 1,
3128 sec_toc = 2
3129 };
3130
3131 struct _ppc64_elf_section_data
3132 {
3133 struct bfd_elf_section_data elf;
3134
3135 union
3136 {
3137 /* An array with one entry for each opd function descriptor,
3138 and some spares since opd entries may be either 16 or 24 bytes. */
3139 #define OPD_NDX(OFF) ((OFF) >> 4)
3140 struct _opd_sec_data
3141 {
3142 /* Points to the function code section for local opd entries. */
3143 asection **func_sec;
3144
3145 /* After editing .opd, adjust references to opd local syms. */
3146 long *adjust;
3147 } opd;
3148
3149 /* An array for toc sections, indexed by offset/8. */
3150 struct _toc_sec_data
3151 {
3152 /* Specifies the relocation symbol index used at a given toc offset. */
3153 unsigned *symndx;
3154
3155 /* And the relocation addend. */
3156 bfd_vma *add;
3157 } toc;
3158 } u;
3159
3160 enum _ppc64_sec_type sec_type:2;
3161
3162 /* Flag set when small branches are detected. Used to
3163 select suitable defaults for the stub group size. */
3164 unsigned int has_14bit_branch:1;
3165
3166 /* Flag set when PLTCALL relocs are detected. */
3167 unsigned int has_pltcall:1;
3168 };
3169
3170 #define ppc64_elf_section_data(sec) \
3171 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3172
3173 static bfd_boolean
3174 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3175 {
3176 if (!sec->used_by_bfd)
3177 {
3178 struct _ppc64_elf_section_data *sdata;
3179 bfd_size_type amt = sizeof (*sdata);
3180
3181 sdata = bfd_zalloc (abfd, amt);
3182 if (sdata == NULL)
3183 return FALSE;
3184 sec->used_by_bfd = sdata;
3185 }
3186
3187 return _bfd_elf_new_section_hook (abfd, sec);
3188 }
3189
3190 static struct _opd_sec_data *
3191 get_opd_info (asection * sec)
3192 {
3193 if (sec != NULL
3194 && ppc64_elf_section_data (sec) != NULL
3195 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3196 return &ppc64_elf_section_data (sec)->u.opd;
3197 return NULL;
3198 }
3199 \f
3200 /* Parameters for the qsort hook. */
3201 static bfd_boolean synthetic_relocatable;
3202 static asection *synthetic_opd;
3203
3204 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3205
3206 static int
3207 compare_symbols (const void *ap, const void *bp)
3208 {
3209 const asymbol *a = *(const asymbol **) ap;
3210 const asymbol *b = *(const asymbol **) bp;
3211
3212 /* Section symbols first. */
3213 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3214 return -1;
3215 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3216 return 1;
3217
3218 /* then .opd symbols. */
3219 if (synthetic_opd != NULL)
3220 {
3221 if (strcmp (a->section->name, ".opd") == 0
3222 && strcmp (b->section->name, ".opd") != 0)
3223 return -1;
3224 if (strcmp (a->section->name, ".opd") != 0
3225 && strcmp (b->section->name, ".opd") == 0)
3226 return 1;
3227 }
3228
3229 /* then other code symbols. */
3230 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3231 == (SEC_CODE | SEC_ALLOC))
3232 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3233 != (SEC_CODE | SEC_ALLOC)))
3234 return -1;
3235
3236 if (((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3237 != (SEC_CODE | SEC_ALLOC))
3238 && ((b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3239 == (SEC_CODE | SEC_ALLOC)))
3240 return 1;
3241
3242 if (synthetic_relocatable)
3243 {
3244 if (a->section->id < b->section->id)
3245 return -1;
3246
3247 if (a->section->id > b->section->id)
3248 return 1;
3249 }
3250
3251 if (a->value + a->section->vma < b->value + b->section->vma)
3252 return -1;
3253
3254 if (a->value + a->section->vma > b->value + b->section->vma)
3255 return 1;
3256
3257 /* For syms with the same value, prefer strong dynamic global function
3258 syms over other syms. */
3259 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3260 return -1;
3261
3262 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3263 return 1;
3264
3265 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3266 return -1;
3267
3268 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3269 return 1;
3270
3271 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3272 return -1;
3273
3274 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3275 return 1;
3276
3277 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3278 return -1;
3279
3280 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3281 return 1;
3282
3283 return a > b;
3284 }
3285
3286 /* Search SYMS for a symbol of the given VALUE. */
3287
3288 static asymbol *
3289 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3290 {
3291 long mid;
3292
3293 if (id == (unsigned) -1)
3294 {
3295 while (lo < hi)
3296 {
3297 mid = (lo + hi) >> 1;
3298 if (syms[mid]->value + syms[mid]->section->vma < value)
3299 lo = mid + 1;
3300 else if (syms[mid]->value + syms[mid]->section->vma > value)
3301 hi = mid;
3302 else
3303 return syms[mid];
3304 }
3305 }
3306 else
3307 {
3308 while (lo < hi)
3309 {
3310 mid = (lo + hi) >> 1;
3311 if (syms[mid]->section->id < id)
3312 lo = mid + 1;
3313 else if (syms[mid]->section->id > id)
3314 hi = mid;
3315 else if (syms[mid]->value < value)
3316 lo = mid + 1;
3317 else if (syms[mid]->value > value)
3318 hi = mid;
3319 else
3320 return syms[mid];
3321 }
3322 }
3323 return NULL;
3324 }
3325
3326 static bfd_boolean
3327 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3328 {
3329 bfd_vma vma = *(bfd_vma *) ptr;
3330 return ((section->flags & SEC_ALLOC) != 0
3331 && section->vma <= vma
3332 && vma < section->vma + section->size);
3333 }
3334
3335 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3336 entry syms. Also generate @plt symbols for the glink branch table.
3337 Returns count of synthetic symbols in RET or -1 on error. */
3338
3339 static long
3340 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3341 long static_count, asymbol **static_syms,
3342 long dyn_count, asymbol **dyn_syms,
3343 asymbol **ret)
3344 {
3345 asymbol *s;
3346 size_t i, j, count;
3347 char *names;
3348 size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3349 asection *opd = NULL;
3350 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3351 asymbol **syms;
3352 int abi = abiversion (abfd);
3353
3354 *ret = NULL;
3355
3356 if (abi < 2)
3357 {
3358 opd = bfd_get_section_by_name (abfd, ".opd");
3359 if (opd == NULL && abi == 1)
3360 return 0;
3361 }
3362
3363 syms = NULL;
3364 codesecsym = 0;
3365 codesecsymend = 0;
3366 secsymend = 0;
3367 opdsymend = 0;
3368 symcount = 0;
3369 if (opd != NULL)
3370 {
3371 symcount = static_count;
3372 if (!relocatable)
3373 symcount += dyn_count;
3374 if (symcount == 0)
3375 return 0;
3376
3377 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3378 if (syms == NULL)
3379 return -1;
3380
3381 if (!relocatable && static_count != 0 && dyn_count != 0)
3382 {
3383 /* Use both symbol tables. */
3384 memcpy (syms, static_syms, static_count * sizeof (*syms));
3385 memcpy (syms + static_count, dyn_syms,
3386 (dyn_count + 1) * sizeof (*syms));
3387 }
3388 else if (!relocatable && static_count == 0)
3389 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3390 else
3391 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3392
3393 /* Trim uninteresting symbols. Interesting symbols are section,
3394 function, and notype symbols. */
3395 for (i = 0, j = 0; i < symcount; ++i)
3396 if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3397 | BSF_RELC | BSF_SRELC)) == 0)
3398 syms[j++] = syms[i];
3399 symcount = j;
3400
3401 synthetic_relocatable = relocatable;
3402 synthetic_opd = opd;
3403 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3404
3405 if (!relocatable && symcount > 1)
3406 {
3407 /* Trim duplicate syms, since we may have merged the normal
3408 and dynamic symbols. Actually, we only care about syms
3409 that have different values, so trim any with the same
3410 value. Don't consider ifunc and ifunc resolver symbols
3411 duplicates however, because GDB wants to know whether a
3412 text symbol is an ifunc resolver. */
3413 for (i = 1, j = 1; i < symcount; ++i)
3414 {
3415 const asymbol *s0 = syms[i - 1];
3416 const asymbol *s1 = syms[i];
3417
3418 if ((s0->value + s0->section->vma
3419 != s1->value + s1->section->vma)
3420 || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3421 != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3422 syms[j++] = syms[i];
3423 }
3424 symcount = j;
3425 }
3426
3427 i = 0;
3428 /* Note that here and in compare_symbols we can't compare opd and
3429 sym->section directly. With separate debug info files, the
3430 symbols will be extracted from the debug file while abfd passed
3431 to this function is the real binary. */
3432 if (strcmp (syms[i]->section->name, ".opd") == 0)
3433 ++i;
3434 codesecsym = i;
3435
3436 for (; i < symcount; ++i)
3437 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3438 | SEC_THREAD_LOCAL))
3439 != (SEC_CODE | SEC_ALLOC))
3440 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3441 break;
3442 codesecsymend = i;
3443
3444 for (; i < symcount; ++i)
3445 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3446 break;
3447 secsymend = i;
3448
3449 for (; i < symcount; ++i)
3450 if (strcmp (syms[i]->section->name, ".opd") != 0)
3451 break;
3452 opdsymend = i;
3453
3454 for (; i < symcount; ++i)
3455 if (((syms[i]->section->flags
3456 & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL)))
3457 != (SEC_CODE | SEC_ALLOC))
3458 break;
3459 symcount = i;
3460 }
3461 count = 0;
3462
3463 if (relocatable)
3464 {
3465 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3466 arelent *r;
3467 size_t size;
3468 size_t relcount;
3469
3470 if (opdsymend == secsymend)
3471 goto done;
3472
3473 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3474 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3475 if (relcount == 0)
3476 goto done;
3477
3478 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3479 {
3480 count = -1;
3481 goto done;
3482 }
3483
3484 size = 0;
3485 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3486 {
3487 asymbol *sym;
3488
3489 while (r < opd->relocation + relcount
3490 && r->address < syms[i]->value + opd->vma)
3491 ++r;
3492
3493 if (r == opd->relocation + relcount)
3494 break;
3495
3496 if (r->address != syms[i]->value + opd->vma)
3497 continue;
3498
3499 if (r->howto->type != R_PPC64_ADDR64)
3500 continue;
3501
3502 sym = *r->sym_ptr_ptr;
3503 if (!sym_exists_at (syms, opdsymend, symcount,
3504 sym->section->id, sym->value + r->addend))
3505 {
3506 ++count;
3507 size += sizeof (asymbol);
3508 size += strlen (syms[i]->name) + 2;
3509 }
3510 }
3511
3512 if (size == 0)
3513 goto done;
3514 s = *ret = bfd_malloc (size);
3515 if (s == NULL)
3516 {
3517 count = -1;
3518 goto done;
3519 }
3520
3521 names = (char *) (s + count);
3522
3523 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3524 {
3525 asymbol *sym;
3526
3527 while (r < opd->relocation + relcount
3528 && r->address < syms[i]->value + opd->vma)
3529 ++r;
3530
3531 if (r == opd->relocation + relcount)
3532 break;
3533
3534 if (r->address != syms[i]->value + opd->vma)
3535 continue;
3536
3537 if (r->howto->type != R_PPC64_ADDR64)
3538 continue;
3539
3540 sym = *r->sym_ptr_ptr;
3541 if (!sym_exists_at (syms, opdsymend, symcount,
3542 sym->section->id, sym->value + r->addend))
3543 {
3544 size_t len;
3545
3546 *s = *syms[i];
3547 s->flags |= BSF_SYNTHETIC;
3548 s->section = sym->section;
3549 s->value = sym->value + r->addend;
3550 s->name = names;
3551 *names++ = '.';
3552 len = strlen (syms[i]->name);
3553 memcpy (names, syms[i]->name, len + 1);
3554 names += len + 1;
3555 /* Have udata.p point back to the original symbol this
3556 synthetic symbol was derived from. */
3557 s->udata.p = syms[i];
3558 s++;
3559 }
3560 }
3561 }
3562 else
3563 {
3564 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3565 bfd_byte *contents = NULL;
3566 size_t size;
3567 size_t plt_count = 0;
3568 bfd_vma glink_vma = 0, resolv_vma = 0;
3569 asection *dynamic, *glink = NULL, *relplt = NULL;
3570 arelent *p;
3571
3572 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3573 {
3574 free_contents_and_exit_err:
3575 count = -1;
3576 free_contents_and_exit:
3577 if (contents)
3578 free (contents);
3579 goto done;
3580 }
3581
3582 size = 0;
3583 for (i = secsymend; i < opdsymend; ++i)
3584 {
3585 bfd_vma ent;
3586
3587 /* Ignore bogus symbols. */
3588 if (syms[i]->value > opd->size - 8)
3589 continue;
3590
3591 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3592 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3593 {
3594 ++count;
3595 size += sizeof (asymbol);
3596 size += strlen (syms[i]->name) + 2;
3597 }
3598 }
3599
3600 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3601 if (dyn_count != 0
3602 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3603 {
3604 bfd_byte *dynbuf, *extdyn, *extdynend;
3605 size_t extdynsize;
3606 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3607
3608 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3609 goto free_contents_and_exit_err;
3610
3611 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3612 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3613
3614 extdyn = dynbuf;
3615 extdynend = extdyn + dynamic->size;
3616 for (; extdyn < extdynend; extdyn += extdynsize)
3617 {
3618 Elf_Internal_Dyn dyn;
3619 (*swap_dyn_in) (abfd, extdyn, &dyn);
3620
3621 if (dyn.d_tag == DT_NULL)
3622 break;
3623
3624 if (dyn.d_tag == DT_PPC64_GLINK)
3625 {
3626 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3627 See comment in ppc64_elf_finish_dynamic_sections. */
3628 glink_vma = dyn.d_un.d_val + 8 * 4;
3629 /* The .glink section usually does not survive the final
3630 link; search for the section (usually .text) where the
3631 glink stubs now reside. */
3632 glink = bfd_sections_find_if (abfd, section_covers_vma,
3633 &glink_vma);
3634 break;
3635 }
3636 }
3637
3638 free (dynbuf);
3639 }
3640
3641 if (glink != NULL)
3642 {
3643 /* Determine __glink trampoline by reading the relative branch
3644 from the first glink stub. */
3645 bfd_byte buf[4];
3646 unsigned int off = 0;
3647
3648 while (bfd_get_section_contents (abfd, glink, buf,
3649 glink_vma + off - glink->vma, 4))
3650 {
3651 unsigned int insn = bfd_get_32 (abfd, buf);
3652 insn ^= B_DOT;
3653 if ((insn & ~0x3fffffc) == 0)
3654 {
3655 resolv_vma
3656 = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3657 break;
3658 }
3659 off += 4;
3660 if (off > 4)
3661 break;
3662 }
3663
3664 if (resolv_vma)
3665 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3666
3667 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3668 if (relplt != NULL)
3669 {
3670 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3671 if (!(*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3672 goto free_contents_and_exit_err;
3673
3674 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3675 size += plt_count * sizeof (asymbol);
3676
3677 p = relplt->relocation;
3678 for (i = 0; i < plt_count; i++, p++)
3679 {
3680 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3681 if (p->addend != 0)
3682 size += sizeof ("+0x") - 1 + 16;
3683 }
3684 }
3685 }
3686
3687 if (size == 0)
3688 goto free_contents_and_exit;
3689 s = *ret = bfd_malloc (size);
3690 if (s == NULL)
3691 goto free_contents_and_exit_err;
3692
3693 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3694
3695 for (i = secsymend; i < opdsymend; ++i)
3696 {
3697 bfd_vma ent;
3698
3699 if (syms[i]->value > opd->size - 8)
3700 continue;
3701
3702 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3703 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3704 {
3705 size_t lo, hi;
3706 size_t len;
3707 asection *sec = abfd->sections;
3708
3709 *s = *syms[i];
3710 lo = codesecsym;
3711 hi = codesecsymend;
3712 while (lo < hi)
3713 {
3714 size_t mid = (lo + hi) >> 1;
3715 if (syms[mid]->section->vma < ent)
3716 lo = mid + 1;
3717 else if (syms[mid]->section->vma > ent)
3718 hi = mid;
3719 else
3720 {
3721 sec = syms[mid]->section;
3722 break;
3723 }
3724 }
3725
3726 if (lo >= hi && lo > codesecsym)
3727 sec = syms[lo - 1]->section;
3728
3729 for (; sec != NULL; sec = sec->next)
3730 {
3731 if (sec->vma > ent)
3732 break;
3733 /* SEC_LOAD may not be set if SEC is from a separate debug
3734 info file. */
3735 if ((sec->flags & SEC_ALLOC) == 0)
3736 break;
3737 if ((sec->flags & SEC_CODE) != 0)
3738 s->section = sec;
3739 }
3740 s->flags |= BSF_SYNTHETIC;
3741 s->value = ent - s->section->vma;
3742 s->name = names;
3743 *names++ = '.';
3744 len = strlen (syms[i]->name);
3745 memcpy (names, syms[i]->name, len + 1);
3746 names += len + 1;
3747 /* Have udata.p point back to the original symbol this
3748 synthetic symbol was derived from. */
3749 s->udata.p = syms[i];
3750 s++;
3751 }
3752 }
3753 free (contents);
3754
3755 if (glink != NULL && relplt != NULL)
3756 {
3757 if (resolv_vma)
3758 {
3759 /* Add a symbol for the main glink trampoline. */
3760 memset (s, 0, sizeof *s);
3761 s->the_bfd = abfd;
3762 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3763 s->section = glink;
3764 s->value = resolv_vma - glink->vma;
3765 s->name = names;
3766 memcpy (names, "__glink_PLTresolve",
3767 sizeof ("__glink_PLTresolve"));
3768 names += sizeof ("__glink_PLTresolve");
3769 s++;
3770 count++;
3771 }
3772
3773 /* FIXME: It would be very much nicer to put sym@plt on the
3774 stub rather than on the glink branch table entry. The
3775 objdump disassembler would then use a sensible symbol
3776 name on plt calls. The difficulty in doing so is
3777 a) finding the stubs, and,
3778 b) matching stubs against plt entries, and,
3779 c) there can be multiple stubs for a given plt entry.
3780
3781 Solving (a) could be done by code scanning, but older
3782 ppc64 binaries used different stubs to current code.
3783 (b) is the tricky one since you need to known the toc
3784 pointer for at least one function that uses a pic stub to
3785 be able to calculate the plt address referenced.
3786 (c) means gdb would need to set multiple breakpoints (or
3787 find the glink branch itself) when setting breakpoints
3788 for pending shared library loads. */
3789 p = relplt->relocation;
3790 for (i = 0; i < plt_count; i++, p++)
3791 {
3792 size_t len;
3793
3794 *s = **p->sym_ptr_ptr;
3795 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3796 we are defining a symbol, ensure one of them is set. */
3797 if ((s->flags & BSF_LOCAL) == 0)
3798 s->flags |= BSF_GLOBAL;
3799 s->flags |= BSF_SYNTHETIC;
3800 s->section = glink;
3801 s->value = glink_vma - glink->vma;
3802 s->name = names;
3803 s->udata.p = NULL;
3804 len = strlen ((*p->sym_ptr_ptr)->name);
3805 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3806 names += len;
3807 if (p->addend != 0)
3808 {
3809 memcpy (names, "+0x", sizeof ("+0x") - 1);
3810 names += sizeof ("+0x") - 1;
3811 bfd_sprintf_vma (abfd, names, p->addend);
3812 names += strlen (names);
3813 }
3814 memcpy (names, "@plt", sizeof ("@plt"));
3815 names += sizeof ("@plt");
3816 s++;
3817 if (abi < 2)
3818 {
3819 glink_vma += 8;
3820 if (i >= 0x8000)
3821 glink_vma += 4;
3822 }
3823 else
3824 glink_vma += 4;
3825 }
3826 count += plt_count;
3827 }
3828 }
3829
3830 done:
3831 free (syms);
3832 return count;
3833 }
3834 \f
3835 /* The following functions are specific to the ELF linker, while
3836 functions above are used generally. Those named ppc64_elf_* are
3837 called by the main ELF linker code. They appear in this file more
3838 or less in the order in which they are called. eg.
3839 ppc64_elf_check_relocs is called early in the link process,
3840 ppc64_elf_finish_dynamic_sections is one of the last functions
3841 called.
3842
3843 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3844 functions have both a function code symbol and a function descriptor
3845 symbol. A call to foo in a relocatable object file looks like:
3846
3847 . .text
3848 . x:
3849 . bl .foo
3850 . nop
3851
3852 The function definition in another object file might be:
3853
3854 . .section .opd
3855 . foo: .quad .foo
3856 . .quad .TOC.@tocbase
3857 . .quad 0
3858 .
3859 . .text
3860 . .foo: blr
3861
3862 When the linker resolves the call during a static link, the branch
3863 unsurprisingly just goes to .foo and the .opd information is unused.
3864 If the function definition is in a shared library, things are a little
3865 different: The call goes via a plt call stub, the opd information gets
3866 copied to the plt, and the linker patches the nop.
3867
3868 . x:
3869 . bl .foo_stub
3870 . ld 2,40(1)
3871 .
3872 .
3873 . .foo_stub:
3874 . std 2,40(1) # in practice, the call stub
3875 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3876 . addi 11,11,Lfoo@toc@l # this is the general idea
3877 . ld 12,0(11)
3878 . ld 2,8(11)
3879 . mtctr 12
3880 . ld 11,16(11)
3881 . bctr
3882 .
3883 . .section .plt
3884 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3885
3886 The "reloc ()" notation is supposed to indicate that the linker emits
3887 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3888 copying.
3889
3890 What are the difficulties here? Well, firstly, the relocations
3891 examined by the linker in check_relocs are against the function code
3892 sym .foo, while the dynamic relocation in the plt is emitted against
3893 the function descriptor symbol, foo. Somewhere along the line, we need
3894 to carefully copy dynamic link information from one symbol to the other.
3895 Secondly, the generic part of the elf linker will make .foo a dynamic
3896 symbol as is normal for most other backends. We need foo dynamic
3897 instead, at least for an application final link. However, when
3898 creating a shared library containing foo, we need to have both symbols
3899 dynamic so that references to .foo are satisfied during the early
3900 stages of linking. Otherwise the linker might decide to pull in a
3901 definition from some other object, eg. a static library.
3902
3903 Update: As of August 2004, we support a new convention. Function
3904 calls may use the function descriptor symbol, ie. "bl foo". This
3905 behaves exactly as "bl .foo". */
3906
3907 /* Of those relocs that might be copied as dynamic relocs, this
3908 function selects those that must be copied when linking a shared
3909 library or PIE, even when the symbol is local. */
3910
3911 static int
3912 must_be_dyn_reloc (struct bfd_link_info *info,
3913 enum elf_ppc64_reloc_type r_type)
3914 {
3915 switch (r_type)
3916 {
3917 default:
3918 /* Only relative relocs can be resolved when the object load
3919 address isn't fixed. DTPREL64 is excluded because the
3920 dynamic linker needs to differentiate global dynamic from
3921 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
3922 return 1;
3923
3924 case R_PPC64_REL32:
3925 case R_PPC64_REL64:
3926 case R_PPC64_REL30:
3927 return 0;
3928
3929 case R_PPC64_TPREL16:
3930 case R_PPC64_TPREL16_LO:
3931 case R_PPC64_TPREL16_HI:
3932 case R_PPC64_TPREL16_HA:
3933 case R_PPC64_TPREL16_DS:
3934 case R_PPC64_TPREL16_LO_DS:
3935 case R_PPC64_TPREL16_HIGH:
3936 case R_PPC64_TPREL16_HIGHA:
3937 case R_PPC64_TPREL16_HIGHER:
3938 case R_PPC64_TPREL16_HIGHERA:
3939 case R_PPC64_TPREL16_HIGHEST:
3940 case R_PPC64_TPREL16_HIGHESTA:
3941 case R_PPC64_TPREL64:
3942 /* These relocations are relative but in a shared library the
3943 linker doesn't know the thread pointer base. */
3944 return bfd_link_dll (info);
3945 }
3946 }
3947
3948 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3949 copying dynamic variables from a shared lib into an app's dynbss
3950 section, and instead use a dynamic relocation to point into the
3951 shared lib. With code that gcc generates, it's vital that this be
3952 enabled; In the PowerPC64 ABI, the address of a function is actually
3953 the address of a function descriptor, which resides in the .opd
3954 section. gcc uses the descriptor directly rather than going via the
3955 GOT as some other ABI's do, which means that initialized function
3956 pointers must reference the descriptor. Thus, a function pointer
3957 initialized to the address of a function in a shared library will
3958 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3959 redefines the function descriptor symbol to point to the copy. This
3960 presents a problem as a plt entry for that function is also
3961 initialized from the function descriptor symbol and the copy reloc
3962 may not be initialized first. */
3963 #define ELIMINATE_COPY_RELOCS 1
3964
3965 /* Section name for stubs is the associated section name plus this
3966 string. */
3967 #define STUB_SUFFIX ".stub"
3968
3969 /* Linker stubs.
3970 ppc_stub_long_branch:
3971 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3972 destination, but a 24 bit branch in a stub section will reach.
3973 . b dest
3974
3975 ppc_stub_plt_branch:
3976 Similar to the above, but a 24 bit branch in the stub section won't
3977 reach its destination.
3978 . addis %r11,%r2,xxx@toc@ha
3979 . ld %r12,xxx@toc@l(%r11)
3980 . mtctr %r12
3981 . bctr
3982
3983 ppc_stub_plt_call:
3984 Used to call a function in a shared library. If it so happens that
3985 the plt entry referenced crosses a 64k boundary, then an extra
3986 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3987 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
3988 . addis %r11,%r2,xxx@toc@ha
3989 . ld %r12,xxx+0@toc@l(%r11)
3990 . mtctr %r12
3991 . ld %r2,xxx+8@toc@l(%r11)
3992 . ld %r11,xxx+16@toc@l(%r11)
3993 . bctr
3994
3995 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3996 code to adjust the value and save r2 to support multiple toc sections.
3997 A ppc_stub_long_branch with an r2 offset looks like:
3998 . std %r2,40(%r1)
3999 . addis %r2,%r2,off@ha
4000 . addi %r2,%r2,off@l
4001 . b dest
4002
4003 A ppc_stub_plt_branch with an r2 offset looks like:
4004 . std %r2,40(%r1)
4005 . addis %r11,%r2,xxx@toc@ha
4006 . ld %r12,xxx@toc@l(%r11)
4007 . addis %r2,%r2,off@ha
4008 . addi %r2,%r2,off@l
4009 . mtctr %r12
4010 . bctr
4011
4012 All of the above stubs are shown as their ELFv1 variants. ELFv2
4013 variants exist too, simpler for plt calls since a new toc pointer
4014 and static chain are not loaded by the stub. In addition, ELFv2
4015 has some more complex stubs to handle calls marked with NOTOC
4016 relocs from functions where r2 is not a valid toc pointer. These
4017 come in two flavours, the ones shown below, and _both variants that
4018 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
4019 one call is from a function where r2 is used as the toc pointer but
4020 needs a toc adjusting stub for small-model multi-toc, and another
4021 call is from a function where r2 is not valid.
4022 ppc_stub_long_branch_notoc:
4023 . mflr %r12
4024 . bcl 20,31,1f
4025 . 1:
4026 . mflr %r11
4027 . mtlr %r12
4028 . addis %r12,%r11,dest-1b@ha
4029 . addi %r12,%r12,dest-1b@l
4030 . b dest
4031
4032 ppc_stub_plt_branch_notoc:
4033 . mflr %r12
4034 . bcl 20,31,1f
4035 . 1:
4036 . mflr %r11
4037 . mtlr %r12
4038 . lis %r12,xxx-1b@highest
4039 . ori %r12,xxx-1b@higher
4040 . sldi %r12,%r12,32
4041 . oris %r12,%r12,xxx-1b@hi
4042 . ori %r12,%r12,xxx-1b@l
4043 . add %r12,%r11,%r12
4044 . mtctr %r12
4045 . bctr
4046
4047 ppc_stub_plt_call_notoc:
4048 . mflr %r12
4049 . bcl 20,31,1f
4050 . 1:
4051 . mflr %r11
4052 . mtlr %r12
4053 . lis %r12,xxx-1b@highest
4054 . ori %r12,xxx-1b@higher
4055 . sldi %r12,%r12,32
4056 . oris %r12,%r12,xxx-1b@hi
4057 . ori %r12,%r12,xxx-1b@l
4058 . ldx %r12,%r11,%r12
4059 . mtctr %r12
4060 . bctr
4061
4062 In cases where the high instructions would add zero, they are
4063 omitted and following instructions modified in some cases.
4064
4065 For a given stub group (a set of sections all using the same toc
4066 pointer value) there will be just one stub type used for any
4067 particular function symbol. For example, if printf is called from
4068 code with the tocsave optimization (ie. r2 saved in function
4069 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
4070 and from other code without the tocsave optimization requiring a
4071 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
4072 type will be created. Calls with the tocsave optimization will
4073 enter this stub after the instruction saving r2. A similar
4074 situation exists when calls are marked with R_PPC64_REL24_NOTOC
4075 relocations. These require a ppc_stub_plt_call_notoc linkage stub
4076 to call an external function like printf. If other calls to printf
4077 require a ppc_stub_plt_call linkage stub then a single
4078 ppc_stub_plt_call_notoc linkage stub will be used for both types of
4079 call. If other calls to printf require a ppc_stub_plt_call_r2save
4080 linkage stub then a single ppc_stub_plt_call_both linkage stub will
4081 be created and calls not requiring r2 to be saved will enter the
4082 stub after the r2 save instruction. There is an analogous
4083 hierarchy of long branch and plt branch stubs for local call
4084 linkage. */
4085
4086 enum ppc_stub_type
4087 {
4088 ppc_stub_none,
4089 ppc_stub_long_branch,
4090 ppc_stub_long_branch_r2off,
4091 ppc_stub_long_branch_notoc,
4092 ppc_stub_long_branch_both, /* r2off and notoc variants both needed. */
4093 ppc_stub_plt_branch,
4094 ppc_stub_plt_branch_r2off,
4095 ppc_stub_plt_branch_notoc,
4096 ppc_stub_plt_branch_both,
4097 ppc_stub_plt_call,
4098 ppc_stub_plt_call_r2save,
4099 ppc_stub_plt_call_notoc,
4100 ppc_stub_plt_call_both,
4101 ppc_stub_global_entry,
4102 ppc_stub_save_res
4103 };
4104
4105 /* Information on stub grouping. */
4106 struct map_stub
4107 {
4108 /* The stub section. */
4109 asection *stub_sec;
4110 /* This is the section to which stubs in the group will be attached. */
4111 asection *link_sec;
4112 /* Next group. */
4113 struct map_stub *next;
4114 /* Whether to emit a copy of register save/restore functions in this
4115 group. */
4116 int needs_save_res;
4117 /* Current offset within stubs after the insn restoring lr in a
4118 _notoc or _both stub using bcl for pc-relative addressing, or
4119 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
4120 unsigned int lr_restore;
4121 /* Accumulated size of EH info emitted to describe return address
4122 if stubs modify lr. Does not include 17 byte FDE header. */
4123 unsigned int eh_size;
4124 /* Offset in glink_eh_frame to the start of EH info for this group. */
4125 unsigned int eh_base;
4126 };
4127
4128 struct ppc_stub_hash_entry
4129 {
4130 /* Base hash table entry structure. */
4131 struct bfd_hash_entry root;
4132
4133 enum ppc_stub_type stub_type;
4134
4135 /* Group information. */
4136 struct map_stub *group;
4137
4138 /* Offset within stub_sec of the beginning of this stub. */
4139 bfd_vma stub_offset;
4140
4141 /* Given the symbol's value and its section we can determine its final
4142 value when building the stubs (so the stub knows where to jump. */
4143 bfd_vma target_value;
4144 asection *target_section;
4145
4146 /* The symbol table entry, if any, that this was derived from. */
4147 struct ppc_link_hash_entry *h;
4148 struct plt_entry *plt_ent;
4149
4150 /* Symbol type. */
4151 unsigned char symtype;
4152
4153 /* Symbol st_other. */
4154 unsigned char other;
4155 };
4156
4157 struct ppc_branch_hash_entry
4158 {
4159 /* Base hash table entry structure. */
4160 struct bfd_hash_entry root;
4161
4162 /* Offset within branch lookup table. */
4163 unsigned int offset;
4164
4165 /* Generation marker. */
4166 unsigned int iter;
4167 };
4168
4169 /* Used to track dynamic relocations for local symbols. */
4170 struct ppc_dyn_relocs
4171 {
4172 struct ppc_dyn_relocs *next;
4173
4174 /* The input section of the reloc. */
4175 asection *sec;
4176
4177 /* Total number of relocs copied for the input section. */
4178 unsigned int count : 31;
4179
4180 /* Whether this entry is for STT_GNU_IFUNC symbols. */
4181 unsigned int ifunc : 1;
4182 };
4183
4184 struct ppc_link_hash_entry
4185 {
4186 struct elf_link_hash_entry elf;
4187
4188 union
4189 {
4190 /* A pointer to the most recently used stub hash entry against this
4191 symbol. */
4192 struct ppc_stub_hash_entry *stub_cache;
4193
4194 /* A pointer to the next symbol starting with a '.' */
4195 struct ppc_link_hash_entry *next_dot_sym;
4196 } u;
4197
4198 /* Track dynamic relocs copied for this symbol. */
4199 struct elf_dyn_relocs *dyn_relocs;
4200
4201 /* Link between function code and descriptor symbols. */
4202 struct ppc_link_hash_entry *oh;
4203
4204 /* Flag function code and descriptor symbols. */
4205 unsigned int is_func:1;
4206 unsigned int is_func_descriptor:1;
4207 unsigned int fake:1;
4208
4209 /* Whether global opd/toc sym has been adjusted or not.
4210 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4211 should be set for all globals defined in any opd/toc section. */
4212 unsigned int adjust_done:1;
4213
4214 /* Set if this is an out-of-line register save/restore function,
4215 with non-standard calling convention. */
4216 unsigned int save_res:1;
4217
4218 /* Set if a duplicate symbol with non-zero localentry is detected,
4219 even when the duplicate symbol does not provide a definition. */
4220 unsigned int non_zero_localentry:1;
4221
4222 /* Contexts in which symbol is used in the GOT (or TOC).
4223 Bits are or'd into the mask as the corresponding relocs are
4224 encountered during check_relocs, with TLS_TLS being set when any
4225 of the other TLS bits are set. tls_optimize clears bits when
4226 optimizing to indicate the corresponding GOT entry type is not
4227 needed. If set, TLS_TLS is never cleared. tls_optimize may also
4228 set TLS_TPRELGD when a GD reloc turns into a TPREL one. We use a
4229 separate flag rather than setting TPREL just for convenience in
4230 distinguishing the two cases.
4231 These flags are also kept for local symbols. */
4232 #define TLS_TLS 1 /* Any TLS reloc. */
4233 #define TLS_GD 2 /* GD reloc. */
4234 #define TLS_LD 4 /* LD reloc. */
4235 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
4236 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
4237 #define TLS_MARK 32 /* __tls_get_addr call marked. */
4238 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4239 #define TLS_EXPLICIT 128 /* Marks TOC section TLS relocs. */
4240 unsigned char tls_mask;
4241
4242 /* The above field is also used to mark function symbols. In which
4243 case TLS_TLS will be 0. */
4244 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
4245 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
4246 #define NON_GOT 256 /* local symbol plt, not stored. */
4247 };
4248
4249 /* ppc64 ELF linker hash table. */
4250
4251 struct ppc_link_hash_table
4252 {
4253 struct elf_link_hash_table elf;
4254
4255 /* The stub hash table. */
4256 struct bfd_hash_table stub_hash_table;
4257
4258 /* Another hash table for plt_branch stubs. */
4259 struct bfd_hash_table branch_hash_table;
4260
4261 /* Hash table for function prologue tocsave. */
4262 htab_t tocsave_htab;
4263
4264 /* Various options and other info passed from the linker. */
4265 struct ppc64_elf_params *params;
4266
4267 /* The size of sec_info below. */
4268 unsigned int sec_info_arr_size;
4269
4270 /* Per-section array of extra section info. Done this way rather
4271 than as part of ppc64_elf_section_data so we have the info for
4272 non-ppc64 sections. */
4273 struct
4274 {
4275 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4276 bfd_vma toc_off;
4277
4278 union
4279 {
4280 /* The section group that this section belongs to. */
4281 struct map_stub *group;
4282 /* A temp section list pointer. */
4283 asection *list;
4284 } u;
4285 } *sec_info;
4286
4287 /* Linked list of groups. */
4288 struct map_stub *group;
4289
4290 /* Temp used when calculating TOC pointers. */
4291 bfd_vma toc_curr;
4292 bfd *toc_bfd;
4293 asection *toc_first_sec;
4294
4295 /* Used when adding symbols. */
4296 struct ppc_link_hash_entry *dot_syms;
4297
4298 /* Shortcuts to get to dynamic linker sections. */
4299 asection *glink;
4300 asection *global_entry;
4301 asection *sfpr;
4302 asection *pltlocal;
4303 asection *relpltlocal;
4304 asection *brlt;
4305 asection *relbrlt;
4306 asection *glink_eh_frame;
4307
4308 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4309 struct ppc_link_hash_entry *tls_get_addr;
4310 struct ppc_link_hash_entry *tls_get_addr_fd;
4311
4312 /* The size of reliplt used by got entry relocs. */
4313 bfd_size_type got_reli_size;
4314
4315 /* Statistics. */
4316 unsigned long stub_count[ppc_stub_global_entry];
4317
4318 /* Number of stubs against global syms. */
4319 unsigned long stub_globals;
4320
4321 /* Set if we're linking code with function descriptors. */
4322 unsigned int opd_abi:1;
4323
4324 /* Support for multiple toc sections. */
4325 unsigned int do_multi_toc:1;
4326 unsigned int multi_toc_needed:1;
4327 unsigned int second_toc_pass:1;
4328 unsigned int do_toc_opt:1;
4329
4330 /* Set if tls optimization is enabled. */
4331 unsigned int do_tls_opt:1;
4332
4333 /* Set if inline plt calls should be converted to direct calls. */
4334 unsigned int can_convert_all_inline_plt:1;
4335
4336 /* Set on error. */
4337 unsigned int stub_error:1;
4338
4339 /* Whether func_desc_adjust needs to be run over symbols. */
4340 unsigned int need_func_desc_adj:1;
4341
4342 /* Whether there exist local gnu indirect function resolvers,
4343 referenced by dynamic relocations. */
4344 unsigned int local_ifunc_resolver:1;
4345 unsigned int maybe_local_ifunc_resolver:1;
4346
4347 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
4348 unsigned int has_plt_localentry0:1;
4349
4350 /* Incremented every time we size stubs. */
4351 unsigned int stub_iteration;
4352
4353 /* Small local sym cache. */
4354 struct sym_cache sym_cache;
4355 };
4356
4357 /* Rename some of the generic section flags to better document how they
4358 are used here. */
4359
4360 /* Nonzero if this section has TLS related relocations. */
4361 #define has_tls_reloc sec_flg0
4362
4363 /* Nonzero if this section has an old-style call to __tls_get_addr. */
4364 #define has_tls_get_addr_call sec_flg1
4365
4366 /* Nonzero if this section has any toc or got relocs. */
4367 #define has_toc_reloc sec_flg2
4368
4369 /* Nonzero if this section has a call to another section that uses
4370 the toc or got. */
4371 #define makes_toc_func_call sec_flg3
4372
4373 /* Recursion protection when determining above flag. */
4374 #define call_check_in_progress sec_flg4
4375 #define call_check_done sec_flg5
4376
4377 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4378
4379 #define ppc_hash_table(p) \
4380 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4381 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4382
4383 #define ppc_stub_hash_lookup(table, string, create, copy) \
4384 ((struct ppc_stub_hash_entry *) \
4385 bfd_hash_lookup ((table), (string), (create), (copy)))
4386
4387 #define ppc_branch_hash_lookup(table, string, create, copy) \
4388 ((struct ppc_branch_hash_entry *) \
4389 bfd_hash_lookup ((table), (string), (create), (copy)))
4390
4391 /* Create an entry in the stub hash table. */
4392
4393 static struct bfd_hash_entry *
4394 stub_hash_newfunc (struct bfd_hash_entry *entry,
4395 struct bfd_hash_table *table,
4396 const char *string)
4397 {
4398 /* Allocate the structure if it has not already been allocated by a
4399 subclass. */
4400 if (entry == NULL)
4401 {
4402 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4403 if (entry == NULL)
4404 return entry;
4405 }
4406
4407 /* Call the allocation method of the superclass. */
4408 entry = bfd_hash_newfunc (entry, table, string);
4409 if (entry != NULL)
4410 {
4411 struct ppc_stub_hash_entry *eh;
4412
4413 /* Initialize the local fields. */
4414 eh = (struct ppc_stub_hash_entry *) entry;
4415 eh->stub_type = ppc_stub_none;
4416 eh->group = NULL;
4417 eh->stub_offset = 0;
4418 eh->target_value = 0;
4419 eh->target_section = NULL;
4420 eh->h = NULL;
4421 eh->plt_ent = NULL;
4422 eh->other = 0;
4423 }
4424
4425 return entry;
4426 }
4427
4428 /* Create an entry in the branch hash table. */
4429
4430 static struct bfd_hash_entry *
4431 branch_hash_newfunc (struct bfd_hash_entry *entry,
4432 struct bfd_hash_table *table,
4433 const char *string)
4434 {
4435 /* Allocate the structure if it has not already been allocated by a
4436 subclass. */
4437 if (entry == NULL)
4438 {
4439 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4440 if (entry == NULL)
4441 return entry;
4442 }
4443
4444 /* Call the allocation method of the superclass. */
4445 entry = bfd_hash_newfunc (entry, table, string);
4446 if (entry != NULL)
4447 {
4448 struct ppc_branch_hash_entry *eh;
4449
4450 /* Initialize the local fields. */
4451 eh = (struct ppc_branch_hash_entry *) entry;
4452 eh->offset = 0;
4453 eh->iter = 0;
4454 }
4455
4456 return entry;
4457 }
4458
4459 /* Create an entry in a ppc64 ELF linker hash table. */
4460
4461 static struct bfd_hash_entry *
4462 link_hash_newfunc (struct bfd_hash_entry *entry,
4463 struct bfd_hash_table *table,
4464 const char *string)
4465 {
4466 /* Allocate the structure if it has not already been allocated by a
4467 subclass. */
4468 if (entry == NULL)
4469 {
4470 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4471 if (entry == NULL)
4472 return entry;
4473 }
4474
4475 /* Call the allocation method of the superclass. */
4476 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4477 if (entry != NULL)
4478 {
4479 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4480
4481 memset (&eh->u.stub_cache, 0,
4482 (sizeof (struct ppc_link_hash_entry)
4483 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4484
4485 /* When making function calls, old ABI code references function entry
4486 points (dot symbols), while new ABI code references the function
4487 descriptor symbol. We need to make any combination of reference and
4488 definition work together, without breaking archive linking.
4489
4490 For a defined function "foo" and an undefined call to "bar":
4491 An old object defines "foo" and ".foo", references ".bar" (possibly
4492 "bar" too).
4493 A new object defines "foo" and references "bar".
4494
4495 A new object thus has no problem with its undefined symbols being
4496 satisfied by definitions in an old object. On the other hand, the
4497 old object won't have ".bar" satisfied by a new object.
4498
4499 Keep a list of newly added dot-symbols. */
4500
4501 if (string[0] == '.')
4502 {
4503 struct ppc_link_hash_table *htab;
4504
4505 htab = (struct ppc_link_hash_table *) table;
4506 eh->u.next_dot_sym = htab->dot_syms;
4507 htab->dot_syms = eh;
4508 }
4509 }
4510
4511 return entry;
4512 }
4513
4514 struct tocsave_entry
4515 {
4516 asection *sec;
4517 bfd_vma offset;
4518 };
4519
4520 static hashval_t
4521 tocsave_htab_hash (const void *p)
4522 {
4523 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4524 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4525 }
4526
4527 static int
4528 tocsave_htab_eq (const void *p1, const void *p2)
4529 {
4530 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4531 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4532 return e1->sec == e2->sec && e1->offset == e2->offset;
4533 }
4534
4535 /* Destroy a ppc64 ELF linker hash table. */
4536
4537 static void
4538 ppc64_elf_link_hash_table_free (bfd *obfd)
4539 {
4540 struct ppc_link_hash_table *htab;
4541
4542 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4543 if (htab->tocsave_htab)
4544 htab_delete (htab->tocsave_htab);
4545 bfd_hash_table_free (&htab->branch_hash_table);
4546 bfd_hash_table_free (&htab->stub_hash_table);
4547 _bfd_elf_link_hash_table_free (obfd);
4548 }
4549
4550 /* Create a ppc64 ELF linker hash table. */
4551
4552 static struct bfd_link_hash_table *
4553 ppc64_elf_link_hash_table_create (bfd *abfd)
4554 {
4555 struct ppc_link_hash_table *htab;
4556 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4557
4558 htab = bfd_zmalloc (amt);
4559 if (htab == NULL)
4560 return NULL;
4561
4562 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4563 sizeof (struct ppc_link_hash_entry),
4564 PPC64_ELF_DATA))
4565 {
4566 free (htab);
4567 return NULL;
4568 }
4569
4570 /* Init the stub hash table too. */
4571 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4572 sizeof (struct ppc_stub_hash_entry)))
4573 {
4574 _bfd_elf_link_hash_table_free (abfd);
4575 return NULL;
4576 }
4577
4578 /* And the branch hash table. */
4579 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4580 sizeof (struct ppc_branch_hash_entry)))
4581 {
4582 bfd_hash_table_free (&htab->stub_hash_table);
4583 _bfd_elf_link_hash_table_free (abfd);
4584 return NULL;
4585 }
4586
4587 htab->tocsave_htab = htab_try_create (1024,
4588 tocsave_htab_hash,
4589 tocsave_htab_eq,
4590 NULL);
4591 if (htab->tocsave_htab == NULL)
4592 {
4593 ppc64_elf_link_hash_table_free (abfd);
4594 return NULL;
4595 }
4596 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4597
4598 /* Initializing two fields of the union is just cosmetic. We really
4599 only care about glist, but when compiled on a 32-bit host the
4600 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4601 debugger inspection of these fields look nicer. */
4602 htab->elf.init_got_refcount.refcount = 0;
4603 htab->elf.init_got_refcount.glist = NULL;
4604 htab->elf.init_plt_refcount.refcount = 0;
4605 htab->elf.init_plt_refcount.glist = NULL;
4606 htab->elf.init_got_offset.offset = 0;
4607 htab->elf.init_got_offset.glist = NULL;
4608 htab->elf.init_plt_offset.offset = 0;
4609 htab->elf.init_plt_offset.glist = NULL;
4610
4611 return &htab->elf.root;
4612 }
4613
4614 /* Create sections for linker generated code. */
4615
4616 static bfd_boolean
4617 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4618 {
4619 struct ppc_link_hash_table *htab;
4620 flagword flags;
4621
4622 htab = ppc_hash_table (info);
4623
4624 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4625 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4626 if (htab->params->save_restore_funcs)
4627 {
4628 /* Create .sfpr for code to save and restore fp regs. */
4629 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4630 flags);
4631 if (htab->sfpr == NULL
4632 || !bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4633 return FALSE;
4634 }
4635
4636 if (bfd_link_relocatable (info))
4637 return TRUE;
4638
4639 /* Create .glink for lazy dynamic linking support. */
4640 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4641 flags);
4642 if (htab->glink == NULL
4643 || !bfd_set_section_alignment (dynobj, htab->glink, 3))
4644 return FALSE;
4645
4646 /* The part of .glink used by global entry stubs, separate so that
4647 it can be aligned appropriately without affecting htab->glink. */
4648 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4649 flags);
4650 if (htab->global_entry == NULL
4651 || !bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4652 return FALSE;
4653
4654 if (!info->no_ld_generated_unwind_info)
4655 {
4656 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4657 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4658 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4659 ".eh_frame",
4660 flags);
4661 if (htab->glink_eh_frame == NULL
4662 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4663 return FALSE;
4664 }
4665
4666 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4667 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4668 if (htab->elf.iplt == NULL
4669 || !bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4670 return FALSE;
4671
4672 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4673 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4674 htab->elf.irelplt
4675 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4676 if (htab->elf.irelplt == NULL
4677 || !bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4678 return FALSE;
4679
4680 /* Create branch lookup table for plt_branch stubs. */
4681 flags = (SEC_ALLOC | SEC_LOAD
4682 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4683 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4684 flags);
4685 if (htab->brlt == NULL
4686 || !bfd_set_section_alignment (dynobj, htab->brlt, 3))
4687 return FALSE;
4688
4689 /* Local plt entries, put in .branch_lt but a separate section for
4690 convenience. */
4691 htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4692 flags);
4693 if (htab->pltlocal == NULL
4694 || !bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4695 return FALSE;
4696
4697 if (!bfd_link_pic (info))
4698 return TRUE;
4699
4700 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4701 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4702 htab->relbrlt
4703 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4704 if (htab->relbrlt == NULL
4705 || !bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4706 return FALSE;
4707
4708 htab->relpltlocal
4709 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4710 if (htab->relpltlocal == NULL
4711 || !bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4712 return FALSE;
4713
4714 return TRUE;
4715 }
4716
4717 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4718
4719 bfd_boolean
4720 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4721 struct ppc64_elf_params *params)
4722 {
4723 struct ppc_link_hash_table *htab;
4724
4725 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4726
4727 /* Always hook our dynamic sections into the first bfd, which is the
4728 linker created stub bfd. This ensures that the GOT header is at
4729 the start of the output TOC section. */
4730 htab = ppc_hash_table (info);
4731 htab->elf.dynobj = params->stub_bfd;
4732 htab->params = params;
4733
4734 return create_linkage_sections (htab->elf.dynobj, info);
4735 }
4736
4737 /* Build a name for an entry in the stub hash table. */
4738
4739 static char *
4740 ppc_stub_name (const asection *input_section,
4741 const asection *sym_sec,
4742 const struct ppc_link_hash_entry *h,
4743 const Elf_Internal_Rela *rel)
4744 {
4745 char *stub_name;
4746 ssize_t len;
4747
4748 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4749 offsets from a sym as a branch target? In fact, we could
4750 probably assume the addend is always zero. */
4751 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4752
4753 if (h)
4754 {
4755 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4756 stub_name = bfd_malloc (len);
4757 if (stub_name == NULL)
4758 return stub_name;
4759
4760 len = sprintf (stub_name, "%08x.%s+%x",
4761 input_section->id & 0xffffffff,
4762 h->elf.root.root.string,
4763 (int) rel->r_addend & 0xffffffff);
4764 }
4765 else
4766 {
4767 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4768 stub_name = bfd_malloc (len);
4769 if (stub_name == NULL)
4770 return stub_name;
4771
4772 len = sprintf (stub_name, "%08x.%x:%x+%x",
4773 input_section->id & 0xffffffff,
4774 sym_sec->id & 0xffffffff,
4775 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4776 (int) rel->r_addend & 0xffffffff);
4777 }
4778 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4779 stub_name[len - 2] = 0;
4780 return stub_name;
4781 }
4782
4783 /* Look up an entry in the stub hash. Stub entries are cached because
4784 creating the stub name takes a bit of time. */
4785
4786 static struct ppc_stub_hash_entry *
4787 ppc_get_stub_entry (const asection *input_section,
4788 const asection *sym_sec,
4789 struct ppc_link_hash_entry *h,
4790 const Elf_Internal_Rela *rel,
4791 struct ppc_link_hash_table *htab)
4792 {
4793 struct ppc_stub_hash_entry *stub_entry;
4794 struct map_stub *group;
4795
4796 /* If this input section is part of a group of sections sharing one
4797 stub section, then use the id of the first section in the group.
4798 Stub names need to include a section id, as there may well be
4799 more than one stub used to reach say, printf, and we need to
4800 distinguish between them. */
4801 group = htab->sec_info[input_section->id].u.group;
4802 if (group == NULL)
4803 return NULL;
4804
4805 if (h != NULL && h->u.stub_cache != NULL
4806 && h->u.stub_cache->h == h
4807 && h->u.stub_cache->group == group)
4808 {
4809 stub_entry = h->u.stub_cache;
4810 }
4811 else
4812 {
4813 char *stub_name;
4814
4815 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4816 if (stub_name == NULL)
4817 return NULL;
4818
4819 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4820 stub_name, FALSE, FALSE);
4821 if (h != NULL)
4822 h->u.stub_cache = stub_entry;
4823
4824 free (stub_name);
4825 }
4826
4827 return stub_entry;
4828 }
4829
4830 /* Add a new stub entry to the stub hash. Not all fields of the new
4831 stub entry are initialised. */
4832
4833 static struct ppc_stub_hash_entry *
4834 ppc_add_stub (const char *stub_name,
4835 asection *section,
4836 struct bfd_link_info *info)
4837 {
4838 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4839 struct map_stub *group;
4840 asection *link_sec;
4841 asection *stub_sec;
4842 struct ppc_stub_hash_entry *stub_entry;
4843
4844 group = htab->sec_info[section->id].u.group;
4845 link_sec = group->link_sec;
4846 stub_sec = group->stub_sec;
4847 if (stub_sec == NULL)
4848 {
4849 size_t namelen;
4850 bfd_size_type len;
4851 char *s_name;
4852
4853 namelen = strlen (link_sec->name);
4854 len = namelen + sizeof (STUB_SUFFIX);
4855 s_name = bfd_alloc (htab->params->stub_bfd, len);
4856 if (s_name == NULL)
4857 return NULL;
4858
4859 memcpy (s_name, link_sec->name, namelen);
4860 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4861 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4862 if (stub_sec == NULL)
4863 return NULL;
4864 group->stub_sec = stub_sec;
4865 }
4866
4867 /* Enter this entry into the linker stub hash table. */
4868 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4869 TRUE, FALSE);
4870 if (stub_entry == NULL)
4871 {
4872 /* xgettext:c-format */
4873 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4874 section->owner, stub_name);
4875 return NULL;
4876 }
4877
4878 stub_entry->group = group;
4879 stub_entry->stub_offset = 0;
4880 return stub_entry;
4881 }
4882
4883 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4884 not already done. */
4885
4886 static bfd_boolean
4887 create_got_section (bfd *abfd, struct bfd_link_info *info)
4888 {
4889 asection *got, *relgot;
4890 flagword flags;
4891 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4892
4893 if (!is_ppc64_elf (abfd))
4894 return FALSE;
4895 if (htab == NULL)
4896 return FALSE;
4897
4898 if (!htab->elf.sgot
4899 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4900 return FALSE;
4901
4902 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4903 | SEC_LINKER_CREATED);
4904
4905 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4906 if (!got
4907 || !bfd_set_section_alignment (abfd, got, 3))
4908 return FALSE;
4909
4910 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4911 flags | SEC_READONLY);
4912 if (!relgot
4913 || !bfd_set_section_alignment (abfd, relgot, 3))
4914 return FALSE;
4915
4916 ppc64_elf_tdata (abfd)->got = got;
4917 ppc64_elf_tdata (abfd)->relgot = relgot;
4918 return TRUE;
4919 }
4920
4921 /* Follow indirect and warning symbol links. */
4922
4923 static inline struct bfd_link_hash_entry *
4924 follow_link (struct bfd_link_hash_entry *h)
4925 {
4926 while (h->type == bfd_link_hash_indirect
4927 || h->type == bfd_link_hash_warning)
4928 h = h->u.i.link;
4929 return h;
4930 }
4931
4932 static inline struct elf_link_hash_entry *
4933 elf_follow_link (struct elf_link_hash_entry *h)
4934 {
4935 return (struct elf_link_hash_entry *) follow_link (&h->root);
4936 }
4937
4938 static inline struct ppc_link_hash_entry *
4939 ppc_follow_link (struct ppc_link_hash_entry *h)
4940 {
4941 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4942 }
4943
4944 /* Merge PLT info on FROM with that on TO. */
4945
4946 static void
4947 move_plt_plist (struct ppc_link_hash_entry *from,
4948 struct ppc_link_hash_entry *to)
4949 {
4950 if (from->elf.plt.plist != NULL)
4951 {
4952 if (to->elf.plt.plist != NULL)
4953 {
4954 struct plt_entry **entp;
4955 struct plt_entry *ent;
4956
4957 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4958 {
4959 struct plt_entry *dent;
4960
4961 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4962 if (dent->addend == ent->addend)
4963 {
4964 dent->plt.refcount += ent->plt.refcount;
4965 *entp = ent->next;
4966 break;
4967 }
4968 if (dent == NULL)
4969 entp = &ent->next;
4970 }
4971 *entp = to->elf.plt.plist;
4972 }
4973
4974 to->elf.plt.plist = from->elf.plt.plist;
4975 from->elf.plt.plist = NULL;
4976 }
4977 }
4978
4979 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4980
4981 static void
4982 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4983 struct elf_link_hash_entry *dir,
4984 struct elf_link_hash_entry *ind)
4985 {
4986 struct ppc_link_hash_entry *edir, *eind;
4987
4988 edir = (struct ppc_link_hash_entry *) dir;
4989 eind = (struct ppc_link_hash_entry *) ind;
4990
4991 edir->is_func |= eind->is_func;
4992 edir->is_func_descriptor |= eind->is_func_descriptor;
4993 edir->tls_mask |= eind->tls_mask;
4994 if (eind->oh != NULL)
4995 edir->oh = ppc_follow_link (eind->oh);
4996
4997 if (edir->elf.versioned != versioned_hidden)
4998 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4999 edir->elf.ref_regular |= eind->elf.ref_regular;
5000 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
5001 edir->elf.non_got_ref |= eind->elf.non_got_ref;
5002 edir->elf.needs_plt |= eind->elf.needs_plt;
5003 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
5004
5005 /* If we were called to copy over info for a weak sym, don't copy
5006 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
5007 in order to simplify readonly_dynrelocs and save a field in the
5008 symbol hash entry, but that means dyn_relocs can't be used in any
5009 tests about a specific symbol, or affect other symbol flags which
5010 are then tested. */
5011 if (eind->elf.root.type != bfd_link_hash_indirect)
5012 return;
5013
5014 /* Copy over any dynamic relocs we may have on the indirect sym. */
5015 if (eind->dyn_relocs != NULL)
5016 {
5017 if (edir->dyn_relocs != NULL)
5018 {
5019 struct elf_dyn_relocs **pp;
5020 struct elf_dyn_relocs *p;
5021
5022 /* Add reloc counts against the indirect sym to the direct sym
5023 list. Merge any entries against the same section. */
5024 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5025 {
5026 struct elf_dyn_relocs *q;
5027
5028 for (q = edir->dyn_relocs; q != NULL; q = q->next)
5029 if (q->sec == p->sec)
5030 {
5031 q->pc_count += p->pc_count;
5032 q->count += p->count;
5033 *pp = p->next;
5034 break;
5035 }
5036 if (q == NULL)
5037 pp = &p->next;
5038 }
5039 *pp = edir->dyn_relocs;
5040 }
5041
5042 edir->dyn_relocs = eind->dyn_relocs;
5043 eind->dyn_relocs = NULL;
5044 }
5045
5046 /* Copy over got entries that we may have already seen to the
5047 symbol which just became indirect. */
5048 if (eind->elf.got.glist != NULL)
5049 {
5050 if (edir->elf.got.glist != NULL)
5051 {
5052 struct got_entry **entp;
5053 struct got_entry *ent;
5054
5055 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
5056 {
5057 struct got_entry *dent;
5058
5059 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
5060 if (dent->addend == ent->addend
5061 && dent->owner == ent->owner
5062 && dent->tls_type == ent->tls_type)
5063 {
5064 dent->got.refcount += ent->got.refcount;
5065 *entp = ent->next;
5066 break;
5067 }
5068 if (dent == NULL)
5069 entp = &ent->next;
5070 }
5071 *entp = edir->elf.got.glist;
5072 }
5073
5074 edir->elf.got.glist = eind->elf.got.glist;
5075 eind->elf.got.glist = NULL;
5076 }
5077
5078 /* And plt entries. */
5079 move_plt_plist (eind, edir);
5080
5081 if (eind->elf.dynindx != -1)
5082 {
5083 if (edir->elf.dynindx != -1)
5084 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5085 edir->elf.dynstr_index);
5086 edir->elf.dynindx = eind->elf.dynindx;
5087 edir->elf.dynstr_index = eind->elf.dynstr_index;
5088 eind->elf.dynindx = -1;
5089 eind->elf.dynstr_index = 0;
5090 }
5091 }
5092
5093 /* Find the function descriptor hash entry from the given function code
5094 hash entry FH. Link the entries via their OH fields. */
5095
5096 static struct ppc_link_hash_entry *
5097 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
5098 {
5099 struct ppc_link_hash_entry *fdh = fh->oh;
5100
5101 if (fdh == NULL)
5102 {
5103 const char *fd_name = fh->elf.root.root.string + 1;
5104
5105 fdh = (struct ppc_link_hash_entry *)
5106 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
5107 if (fdh == NULL)
5108 return fdh;
5109
5110 fdh->is_func_descriptor = 1;
5111 fdh->oh = fh;
5112 fh->is_func = 1;
5113 fh->oh = fdh;
5114 }
5115
5116 fdh = ppc_follow_link (fdh);
5117 fdh->is_func_descriptor = 1;
5118 fdh->oh = fh;
5119 return fdh;
5120 }
5121
5122 /* Make a fake function descriptor sym for the undefined code sym FH. */
5123
5124 static struct ppc_link_hash_entry *
5125 make_fdh (struct bfd_link_info *info,
5126 struct ppc_link_hash_entry *fh)
5127 {
5128 bfd *abfd = fh->elf.root.u.undef.abfd;
5129 struct bfd_link_hash_entry *bh = NULL;
5130 struct ppc_link_hash_entry *fdh;
5131 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5132 ? BSF_WEAK
5133 : BSF_GLOBAL);
5134
5135 if (!_bfd_generic_link_add_one_symbol (info, abfd,
5136 fh->elf.root.root.string + 1,
5137 flags, bfd_und_section_ptr, 0,
5138 NULL, FALSE, FALSE, &bh))
5139 return NULL;
5140
5141 fdh = (struct ppc_link_hash_entry *) bh;
5142 fdh->elf.non_elf = 0;
5143 fdh->fake = 1;
5144 fdh->is_func_descriptor = 1;
5145 fdh->oh = fh;
5146 fh->is_func = 1;
5147 fh->oh = fdh;
5148 return fdh;
5149 }
5150
5151 /* Fix function descriptor symbols defined in .opd sections to be
5152 function type. */
5153
5154 static bfd_boolean
5155 ppc64_elf_add_symbol_hook (bfd *ibfd,
5156 struct bfd_link_info *info,
5157 Elf_Internal_Sym *isym,
5158 const char **name,
5159 flagword *flags ATTRIBUTE_UNUSED,
5160 asection **sec,
5161 bfd_vma *value)
5162 {
5163 if (*sec != NULL
5164 && strcmp ((*sec)->name, ".opd") == 0)
5165 {
5166 asection *code_sec;
5167
5168 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5169 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5170 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5171
5172 /* If the symbol is a function defined in .opd, and the function
5173 code is in a discarded group, let it appear to be undefined. */
5174 if (!bfd_link_relocatable (info)
5175 && (*sec)->reloc_count != 0
5176 && opd_entry_value (*sec, *value, &code_sec, NULL,
5177 FALSE) != (bfd_vma) -1
5178 && discarded_section (code_sec))
5179 {
5180 *sec = bfd_und_section_ptr;
5181 isym->st_shndx = SHN_UNDEF;
5182 }
5183 }
5184 else if (*sec != NULL
5185 && strcmp ((*sec)->name, ".toc") == 0
5186 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5187 {
5188 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5189 if (htab != NULL)
5190 htab->params->object_in_toc = 1;
5191 }
5192
5193 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5194 {
5195 if (abiversion (ibfd) == 0)
5196 set_abiversion (ibfd, 2);
5197 else if (abiversion (ibfd) == 1)
5198 {
5199 _bfd_error_handler (_("symbol '%s' has invalid st_other"
5200 " for ABI version 1"), *name);
5201 bfd_set_error (bfd_error_bad_value);
5202 return FALSE;
5203 }
5204 }
5205
5206 return TRUE;
5207 }
5208
5209 /* Merge non-visibility st_other attributes: local entry point. */
5210
5211 static void
5212 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5213 const Elf_Internal_Sym *isym,
5214 bfd_boolean definition,
5215 bfd_boolean dynamic)
5216 {
5217 if (definition && (!dynamic || !h->def_regular))
5218 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5219 | ELF_ST_VISIBILITY (h->other));
5220 }
5221
5222 /* Hook called on merging a symbol. We use this to clear "fake" since
5223 we now have a real symbol. */
5224
5225 static bfd_boolean
5226 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5227 const Elf_Internal_Sym *isym,
5228 asection **psec ATTRIBUTE_UNUSED,
5229 bfd_boolean newdef ATTRIBUTE_UNUSED,
5230 bfd_boolean olddef ATTRIBUTE_UNUSED,
5231 bfd *oldbfd ATTRIBUTE_UNUSED,
5232 const asection *oldsec ATTRIBUTE_UNUSED)
5233 {
5234 ((struct ppc_link_hash_entry *) h)->fake = 0;
5235 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5236 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5237 return TRUE;
5238 }
5239
5240 /* This function makes an old ABI object reference to ".bar" cause the
5241 inclusion of a new ABI object archive that defines "bar".
5242 NAME is a symbol defined in an archive. Return a symbol in the hash
5243 table that might be satisfied by the archive symbols. */
5244
5245 static struct elf_link_hash_entry *
5246 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5247 struct bfd_link_info *info,
5248 const char *name)
5249 {
5250 struct elf_link_hash_entry *h;
5251 char *dot_name;
5252 size_t len;
5253
5254 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5255 if (h != NULL
5256 /* Don't return this sym if it is a fake function descriptor
5257 created by add_symbol_adjust. */
5258 && !((struct ppc_link_hash_entry *) h)->fake)
5259 return h;
5260
5261 if (name[0] == '.')
5262 return h;
5263
5264 len = strlen (name);
5265 dot_name = bfd_alloc (abfd, len + 2);
5266 if (dot_name == NULL)
5267 return (struct elf_link_hash_entry *) -1;
5268 dot_name[0] = '.';
5269 memcpy (dot_name + 1, name, len + 1);
5270 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5271 bfd_release (abfd, dot_name);
5272 return h;
5273 }
5274
5275 /* This function satisfies all old ABI object references to ".bar" if a
5276 new ABI object defines "bar". Well, at least, undefined dot symbols
5277 are made weak. This stops later archive searches from including an
5278 object if we already have a function descriptor definition. It also
5279 prevents the linker complaining about undefined symbols.
5280 We also check and correct mismatched symbol visibility here. The
5281 most restrictive visibility of the function descriptor and the
5282 function entry symbol is used. */
5283
5284 static bfd_boolean
5285 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5286 {
5287 struct ppc_link_hash_table *htab;
5288 struct ppc_link_hash_entry *fdh;
5289
5290 if (eh->elf.root.type == bfd_link_hash_warning)
5291 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5292
5293 if (eh->elf.root.type == bfd_link_hash_indirect)
5294 return TRUE;
5295
5296 if (eh->elf.root.root.string[0] != '.')
5297 abort ();
5298
5299 htab = ppc_hash_table (info);
5300 if (htab == NULL)
5301 return FALSE;
5302
5303 fdh = lookup_fdh (eh, htab);
5304 if (fdh == NULL
5305 && !bfd_link_relocatable (info)
5306 && (eh->elf.root.type == bfd_link_hash_undefined
5307 || eh->elf.root.type == bfd_link_hash_undefweak)
5308 && eh->elf.ref_regular)
5309 {
5310 /* Make an undefined function descriptor sym, in order to
5311 pull in an --as-needed shared lib. Archives are handled
5312 elsewhere. */
5313 fdh = make_fdh (info, eh);
5314 if (fdh == NULL)
5315 return FALSE;
5316 }
5317
5318 if (fdh != NULL)
5319 {
5320 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5321 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5322
5323 /* Make both descriptor and entry symbol have the most
5324 constraining visibility of either symbol. */
5325 if (entry_vis < descr_vis)
5326 fdh->elf.other += entry_vis - descr_vis;
5327 else if (entry_vis > descr_vis)
5328 eh->elf.other += descr_vis - entry_vis;
5329
5330 /* Propagate reference flags from entry symbol to function
5331 descriptor symbol. */
5332 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5333 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5334 fdh->elf.ref_regular |= eh->elf.ref_regular;
5335 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5336
5337 if (!fdh->elf.forced_local
5338 && fdh->elf.dynindx == -1
5339 && fdh->elf.versioned != versioned_hidden
5340 && (bfd_link_dll (info)
5341 || fdh->elf.def_dynamic
5342 || fdh->elf.ref_dynamic)
5343 && (eh->elf.ref_regular
5344 || eh->elf.def_regular))
5345 {
5346 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5347 return FALSE;
5348 }
5349 }
5350
5351 return TRUE;
5352 }
5353
5354 /* Set up opd section info and abiversion for IBFD, and process list
5355 of dot-symbols we made in link_hash_newfunc. */
5356
5357 static bfd_boolean
5358 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5359 {
5360 struct ppc_link_hash_table *htab;
5361 struct ppc_link_hash_entry **p, *eh;
5362 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5363
5364 if (opd != NULL && opd->size != 0)
5365 {
5366 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5367 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5368
5369 if (abiversion (ibfd) == 0)
5370 set_abiversion (ibfd, 1);
5371 else if (abiversion (ibfd) >= 2)
5372 {
5373 /* xgettext:c-format */
5374 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5375 ibfd, abiversion (ibfd));
5376 bfd_set_error (bfd_error_bad_value);
5377 return FALSE;
5378 }
5379 }
5380
5381 if (is_ppc64_elf (info->output_bfd))
5382 {
5383 /* For input files without an explicit abiversion in e_flags
5384 we should have flagged any with symbol st_other bits set
5385 as ELFv1 and above flagged those with .opd as ELFv2.
5386 Set the output abiversion if not yet set, and for any input
5387 still ambiguous, take its abiversion from the output.
5388 Differences in ABI are reported later. */
5389 if (abiversion (info->output_bfd) == 0)
5390 set_abiversion (info->output_bfd, abiversion (ibfd));
5391 else if (abiversion (ibfd) == 0)
5392 set_abiversion (ibfd, abiversion (info->output_bfd));
5393 }
5394
5395 htab = ppc_hash_table (info);
5396 if (htab == NULL)
5397 return TRUE;
5398
5399 if (opd != NULL && opd->size != 0
5400 && (ibfd->flags & DYNAMIC) == 0
5401 && (opd->flags & SEC_RELOC) != 0
5402 && opd->reloc_count != 0
5403 && !bfd_is_abs_section (opd->output_section)
5404 && info->gc_sections)
5405 {
5406 /* Garbage collection needs some extra help with .opd sections.
5407 We don't want to necessarily keep everything referenced by
5408 relocs in .opd, as that would keep all functions. Instead,
5409 if we reference an .opd symbol (a function descriptor), we
5410 want to keep the function code symbol's section. This is
5411 easy for global symbols, but for local syms we need to keep
5412 information about the associated function section. */
5413 bfd_size_type amt;
5414 asection **opd_sym_map;
5415 Elf_Internal_Shdr *symtab_hdr;
5416 Elf_Internal_Rela *relocs, *rel_end, *rel;
5417
5418 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5419 opd_sym_map = bfd_zalloc (ibfd, amt);
5420 if (opd_sym_map == NULL)
5421 return FALSE;
5422 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5423 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5424 info->keep_memory);
5425 if (relocs == NULL)
5426 return FALSE;
5427 symtab_hdr = &elf_symtab_hdr (ibfd);
5428 rel_end = relocs + opd->reloc_count - 1;
5429 for (rel = relocs; rel < rel_end; rel++)
5430 {
5431 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5432 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5433
5434 if (r_type == R_PPC64_ADDR64
5435 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5436 && r_symndx < symtab_hdr->sh_info)
5437 {
5438 Elf_Internal_Sym *isym;
5439 asection *s;
5440
5441 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5442 if (isym == NULL)
5443 {
5444 if (elf_section_data (opd)->relocs != relocs)
5445 free (relocs);
5446 return FALSE;
5447 }
5448
5449 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5450 if (s != NULL && s != opd)
5451 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5452 }
5453 }
5454 if (elf_section_data (opd)->relocs != relocs)
5455 free (relocs);
5456 }
5457
5458 p = &htab->dot_syms;
5459 while ((eh = *p) != NULL)
5460 {
5461 *p = NULL;
5462 if (&eh->elf == htab->elf.hgot)
5463 ;
5464 else if (htab->elf.hgot == NULL
5465 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5466 htab->elf.hgot = &eh->elf;
5467 else if (abiversion (ibfd) <= 1)
5468 {
5469 htab->need_func_desc_adj = 1;
5470 if (!add_symbol_adjust (eh, info))
5471 return FALSE;
5472 }
5473 p = &eh->u.next_dot_sym;
5474 }
5475 return TRUE;
5476 }
5477
5478 /* Undo hash table changes when an --as-needed input file is determined
5479 not to be needed. */
5480
5481 static bfd_boolean
5482 ppc64_elf_notice_as_needed (bfd *ibfd,
5483 struct bfd_link_info *info,
5484 enum notice_asneeded_action act)
5485 {
5486 if (act == notice_not_needed)
5487 {
5488 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5489
5490 if (htab == NULL)
5491 return FALSE;
5492
5493 htab->dot_syms = NULL;
5494 }
5495 return _bfd_elf_notice_as_needed (ibfd, info, act);
5496 }
5497
5498 /* If --just-symbols against a final linked binary, then assume we need
5499 toc adjusting stubs when calling functions defined there. */
5500
5501 static void
5502 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5503 {
5504 if ((sec->flags & SEC_CODE) != 0
5505 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5506 && is_ppc64_elf (sec->owner))
5507 {
5508 if (abiversion (sec->owner) >= 2
5509 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5510 sec->has_toc_reloc = 1;
5511 }
5512 _bfd_elf_link_just_syms (sec, info);
5513 }
5514
5515 static struct plt_entry **
5516 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5517 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5518 {
5519 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5520 struct plt_entry **local_plt;
5521 unsigned char *local_got_tls_masks;
5522
5523 if (local_got_ents == NULL)
5524 {
5525 bfd_size_type size = symtab_hdr->sh_info;
5526
5527 size *= (sizeof (*local_got_ents)
5528 + sizeof (*local_plt)
5529 + sizeof (*local_got_tls_masks));
5530 local_got_ents = bfd_zalloc (abfd, size);
5531 if (local_got_ents == NULL)
5532 return NULL;
5533 elf_local_got_ents (abfd) = local_got_ents;
5534 }
5535
5536 if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5537 {
5538 struct got_entry *ent;
5539
5540 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5541 if (ent->addend == r_addend
5542 && ent->owner == abfd
5543 && ent->tls_type == tls_type)
5544 break;
5545 if (ent == NULL)
5546 {
5547 bfd_size_type amt = sizeof (*ent);
5548 ent = bfd_alloc (abfd, amt);
5549 if (ent == NULL)
5550 return FALSE;
5551 ent->next = local_got_ents[r_symndx];
5552 ent->addend = r_addend;
5553 ent->owner = abfd;
5554 ent->tls_type = tls_type;
5555 ent->is_indirect = FALSE;
5556 ent->got.refcount = 0;
5557 local_got_ents[r_symndx] = ent;
5558 }
5559 ent->got.refcount += 1;
5560 }
5561
5562 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5563 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5564 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5565
5566 return local_plt + r_symndx;
5567 }
5568
5569 static bfd_boolean
5570 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5571 {
5572 struct plt_entry *ent;
5573
5574 for (ent = *plist; ent != NULL; ent = ent->next)
5575 if (ent->addend == addend)
5576 break;
5577 if (ent == NULL)
5578 {
5579 bfd_size_type amt = sizeof (*ent);
5580 ent = bfd_alloc (abfd, amt);
5581 if (ent == NULL)
5582 return FALSE;
5583 ent->next = *plist;
5584 ent->addend = addend;
5585 ent->plt.refcount = 0;
5586 *plist = ent;
5587 }
5588 ent->plt.refcount += 1;
5589 return TRUE;
5590 }
5591
5592 static bfd_boolean
5593 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5594 {
5595 return (r_type == R_PPC64_REL24
5596 || r_type == R_PPC64_REL24_NOTOC
5597 || r_type == R_PPC64_REL14
5598 || r_type == R_PPC64_REL14_BRTAKEN
5599 || r_type == R_PPC64_REL14_BRNTAKEN
5600 || r_type == R_PPC64_ADDR24
5601 || r_type == R_PPC64_ADDR14
5602 || r_type == R_PPC64_ADDR14_BRTAKEN
5603 || r_type == R_PPC64_ADDR14_BRNTAKEN
5604 || r_type == R_PPC64_PLTCALL);
5605 }
5606
5607 /* Relocs on inline plt call sequence insns prior to the call. */
5608
5609 static bfd_boolean
5610 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5611 {
5612 return (r_type == R_PPC64_PLT16_HA
5613 || r_type == R_PPC64_PLT16_HI
5614 || r_type == R_PPC64_PLT16_LO
5615 || r_type == R_PPC64_PLT16_LO_DS
5616 || r_type == R_PPC64_PLTSEQ);
5617 }
5618
5619 /* Look through the relocs for a section during the first phase, and
5620 calculate needed space in the global offset table, procedure
5621 linkage table, and dynamic reloc sections. */
5622
5623 static bfd_boolean
5624 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5625 asection *sec, const Elf_Internal_Rela *relocs)
5626 {
5627 struct ppc_link_hash_table *htab;
5628 Elf_Internal_Shdr *symtab_hdr;
5629 struct elf_link_hash_entry **sym_hashes;
5630 const Elf_Internal_Rela *rel;
5631 const Elf_Internal_Rela *rel_end;
5632 asection *sreloc;
5633 struct elf_link_hash_entry *tga, *dottga;
5634 bfd_boolean is_opd;
5635
5636 if (bfd_link_relocatable (info))
5637 return TRUE;
5638
5639 /* Don't do anything special with non-loaded, non-alloced sections.
5640 In particular, any relocs in such sections should not affect GOT
5641 and PLT reference counting (ie. we don't allow them to create GOT
5642 or PLT entries), there's no possibility or desire to optimize TLS
5643 relocs, and there's not much point in propagating relocs to shared
5644 libs that the dynamic linker won't relocate. */
5645 if ((sec->flags & SEC_ALLOC) == 0)
5646 return TRUE;
5647
5648 BFD_ASSERT (is_ppc64_elf (abfd));
5649
5650 htab = ppc_hash_table (info);
5651 if (htab == NULL)
5652 return FALSE;
5653
5654 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5655 FALSE, FALSE, TRUE);
5656 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5657 FALSE, FALSE, TRUE);
5658 symtab_hdr = &elf_symtab_hdr (abfd);
5659 sym_hashes = elf_sym_hashes (abfd);
5660 sreloc = NULL;
5661 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5662 rel_end = relocs + sec->reloc_count;
5663 for (rel = relocs; rel < rel_end; rel++)
5664 {
5665 unsigned long r_symndx;
5666 struct elf_link_hash_entry *h;
5667 enum elf_ppc64_reloc_type r_type;
5668 int tls_type;
5669 struct _ppc64_elf_section_data *ppc64_sec;
5670 struct plt_entry **ifunc, **plt_list;
5671
5672 r_symndx = ELF64_R_SYM (rel->r_info);
5673 if (r_symndx < symtab_hdr->sh_info)
5674 h = NULL;
5675 else
5676 {
5677 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5678 h = elf_follow_link (h);
5679
5680 if (h == htab->elf.hgot)
5681 sec->has_toc_reloc = 1;
5682 }
5683
5684 tls_type = 0;
5685 ifunc = NULL;
5686 if (h != NULL)
5687 {
5688 if (h->type == STT_GNU_IFUNC)
5689 {
5690 h->needs_plt = 1;
5691 ifunc = &h->plt.plist;
5692 }
5693 }
5694 else
5695 {
5696 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5697 abfd, r_symndx);
5698 if (isym == NULL)
5699 return FALSE;
5700
5701 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5702 {
5703 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5704 rel->r_addend,
5705 NON_GOT | PLT_IFUNC);
5706 if (ifunc == NULL)
5707 return FALSE;
5708 }
5709 }
5710
5711 r_type = ELF64_R_TYPE (rel->r_info);
5712 switch (r_type)
5713 {
5714 case R_PPC64_TLSGD:
5715 case R_PPC64_TLSLD:
5716 /* These special tls relocs tie a call to __tls_get_addr with
5717 its parameter symbol. */
5718 if (h != NULL)
5719 ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5720 else
5721 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5722 rel->r_addend,
5723 NON_GOT | TLS_TLS | TLS_MARK))
5724 return FALSE;
5725 sec->has_tls_reloc = 1;
5726 break;
5727
5728 case R_PPC64_GOT_TLSLD16:
5729 case R_PPC64_GOT_TLSLD16_LO:
5730 case R_PPC64_GOT_TLSLD16_HI:
5731 case R_PPC64_GOT_TLSLD16_HA:
5732 tls_type = TLS_TLS | TLS_LD;
5733 goto dogottls;
5734
5735 case R_PPC64_GOT_TLSGD16:
5736 case R_PPC64_GOT_TLSGD16_LO:
5737 case R_PPC64_GOT_TLSGD16_HI:
5738 case R_PPC64_GOT_TLSGD16_HA:
5739 tls_type = TLS_TLS | TLS_GD;
5740 goto dogottls;
5741
5742 case R_PPC64_GOT_TPREL16_DS:
5743 case R_PPC64_GOT_TPREL16_LO_DS:
5744 case R_PPC64_GOT_TPREL16_HI:
5745 case R_PPC64_GOT_TPREL16_HA:
5746 if (bfd_link_dll (info))
5747 info->flags |= DF_STATIC_TLS;
5748 tls_type = TLS_TLS | TLS_TPREL;
5749 goto dogottls;
5750
5751 case R_PPC64_GOT_DTPREL16_DS:
5752 case R_PPC64_GOT_DTPREL16_LO_DS:
5753 case R_PPC64_GOT_DTPREL16_HI:
5754 case R_PPC64_GOT_DTPREL16_HA:
5755 tls_type = TLS_TLS | TLS_DTPREL;
5756 dogottls:
5757 sec->has_tls_reloc = 1;
5758 /* Fall through */
5759
5760 case R_PPC64_GOT16:
5761 case R_PPC64_GOT16_DS:
5762 case R_PPC64_GOT16_HA:
5763 case R_PPC64_GOT16_HI:
5764 case R_PPC64_GOT16_LO:
5765 case R_PPC64_GOT16_LO_DS:
5766 /* This symbol requires a global offset table entry. */
5767 sec->has_toc_reloc = 1;
5768 if (r_type == R_PPC64_GOT_TLSLD16
5769 || r_type == R_PPC64_GOT_TLSGD16
5770 || r_type == R_PPC64_GOT_TPREL16_DS
5771 || r_type == R_PPC64_GOT_DTPREL16_DS
5772 || r_type == R_PPC64_GOT16
5773 || r_type == R_PPC64_GOT16_DS)
5774 {
5775 htab->do_multi_toc = 1;
5776 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5777 }
5778
5779 if (ppc64_elf_tdata (abfd)->got == NULL
5780 && !create_got_section (abfd, info))
5781 return FALSE;
5782
5783 if (h != NULL)
5784 {
5785 struct ppc_link_hash_entry *eh;
5786 struct got_entry *ent;
5787
5788 eh = (struct ppc_link_hash_entry *) h;
5789 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5790 if (ent->addend == rel->r_addend
5791 && ent->owner == abfd
5792 && ent->tls_type == tls_type)
5793 break;
5794 if (ent == NULL)
5795 {
5796 bfd_size_type amt = sizeof (*ent);
5797 ent = bfd_alloc (abfd, amt);
5798 if (ent == NULL)
5799 return FALSE;
5800 ent->next = eh->elf.got.glist;
5801 ent->addend = rel->r_addend;
5802 ent->owner = abfd;
5803 ent->tls_type = tls_type;
5804 ent->is_indirect = FALSE;
5805 ent->got.refcount = 0;
5806 eh->elf.got.glist = ent;
5807 }
5808 ent->got.refcount += 1;
5809 eh->tls_mask |= tls_type;
5810 }
5811 else
5812 /* This is a global offset table entry for a local symbol. */
5813 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5814 rel->r_addend, tls_type))
5815 return FALSE;
5816
5817 /* We may also need a plt entry if the symbol turns out to be
5818 an ifunc. */
5819 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5820 {
5821 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5822 return FALSE;
5823 }
5824 break;
5825
5826 case R_PPC64_PLT16_HA:
5827 case R_PPC64_PLT16_HI:
5828 case R_PPC64_PLT16_LO:
5829 case R_PPC64_PLT16_LO_DS:
5830 case R_PPC64_PLT32:
5831 case R_PPC64_PLT64:
5832 /* This symbol requires a procedure linkage table entry. */
5833 plt_list = ifunc;
5834 if (h != NULL)
5835 {
5836 h->needs_plt = 1;
5837 if (h->root.root.string[0] == '.'
5838 && h->root.root.string[1] != '\0')
5839 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5840 ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5841 plt_list = &h->plt.plist;
5842 }
5843 if (plt_list == NULL)
5844 plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5845 rel->r_addend,
5846 NON_GOT | PLT_KEEP);
5847 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5848 return FALSE;
5849 break;
5850
5851 /* The following relocations don't need to propagate the
5852 relocation if linking a shared object since they are
5853 section relative. */
5854 case R_PPC64_SECTOFF:
5855 case R_PPC64_SECTOFF_LO:
5856 case R_PPC64_SECTOFF_HI:
5857 case R_PPC64_SECTOFF_HA:
5858 case R_PPC64_SECTOFF_DS:
5859 case R_PPC64_SECTOFF_LO_DS:
5860 case R_PPC64_DTPREL16:
5861 case R_PPC64_DTPREL16_LO:
5862 case R_PPC64_DTPREL16_HI:
5863 case R_PPC64_DTPREL16_HA:
5864 case R_PPC64_DTPREL16_DS:
5865 case R_PPC64_DTPREL16_LO_DS:
5866 case R_PPC64_DTPREL16_HIGH:
5867 case R_PPC64_DTPREL16_HIGHA:
5868 case R_PPC64_DTPREL16_HIGHER:
5869 case R_PPC64_DTPREL16_HIGHERA:
5870 case R_PPC64_DTPREL16_HIGHEST:
5871 case R_PPC64_DTPREL16_HIGHESTA:
5872 break;
5873
5874 /* Nor do these. */
5875 case R_PPC64_REL16:
5876 case R_PPC64_REL16_LO:
5877 case R_PPC64_REL16_HI:
5878 case R_PPC64_REL16_HA:
5879 case R_PPC64_REL16DX_HA:
5880 break;
5881
5882 /* Not supported as a dynamic relocation. */
5883 case R_PPC64_ADDR64_LOCAL:
5884 if (bfd_link_pic (info))
5885 {
5886 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5887 ppc_howto_init ();
5888 /* xgettext:c-format */
5889 info->callbacks->einfo (_("%H: %s reloc unsupported "
5890 "in shared libraries and PIEs\n"),
5891 abfd, sec, rel->r_offset,
5892 ppc64_elf_howto_table[r_type]->name);
5893 bfd_set_error (bfd_error_bad_value);
5894 return FALSE;
5895 }
5896 break;
5897
5898 case R_PPC64_TOC16:
5899 case R_PPC64_TOC16_DS:
5900 htab->do_multi_toc = 1;
5901 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5902 /* Fall through. */
5903 case R_PPC64_TOC16_LO:
5904 case R_PPC64_TOC16_HI:
5905 case R_PPC64_TOC16_HA:
5906 case R_PPC64_TOC16_LO_DS:
5907 sec->has_toc_reloc = 1;
5908 break;
5909
5910 /* Marker reloc. */
5911 case R_PPC64_ENTRY:
5912 break;
5913
5914 /* This relocation describes the C++ object vtable hierarchy.
5915 Reconstruct it for later use during GC. */
5916 case R_PPC64_GNU_VTINHERIT:
5917 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5918 return FALSE;
5919 break;
5920
5921 /* This relocation describes which C++ vtable entries are actually
5922 used. Record for later use during GC. */
5923 case R_PPC64_GNU_VTENTRY:
5924 BFD_ASSERT (h != NULL);
5925 if (h != NULL
5926 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5927 return FALSE;
5928 break;
5929
5930 case R_PPC64_REL14:
5931 case R_PPC64_REL14_BRTAKEN:
5932 case R_PPC64_REL14_BRNTAKEN:
5933 {
5934 asection *dest = NULL;
5935
5936 /* Heuristic: If jumping outside our section, chances are
5937 we are going to need a stub. */
5938 if (h != NULL)
5939 {
5940 /* If the sym is weak it may be overridden later, so
5941 don't assume we know where a weak sym lives. */
5942 if (h->root.type == bfd_link_hash_defined)
5943 dest = h->root.u.def.section;
5944 }
5945 else
5946 {
5947 Elf_Internal_Sym *isym;
5948
5949 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5950 abfd, r_symndx);
5951 if (isym == NULL)
5952 return FALSE;
5953
5954 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5955 }
5956
5957 if (dest != sec)
5958 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5959 }
5960 goto rel24;
5961
5962 case R_PPC64_PLTCALL:
5963 ppc64_elf_section_data (sec)->has_pltcall = 1;
5964 /* Fall through. */
5965
5966 case R_PPC64_REL24:
5967 case R_PPC64_REL24_NOTOC:
5968 rel24:
5969 plt_list = ifunc;
5970 if (h != NULL)
5971 {
5972 h->needs_plt = 1;
5973 if (h->root.root.string[0] == '.'
5974 && h->root.root.string[1] != '\0')
5975 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5976
5977 if (h == tga || h == dottga)
5978 {
5979 sec->has_tls_reloc = 1;
5980 if (rel != relocs
5981 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5982 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5983 /* We have a new-style __tls_get_addr call with
5984 a marker reloc. */
5985 ;
5986 else
5987 /* Mark this section as having an old-style call. */
5988 sec->has_tls_get_addr_call = 1;
5989 }
5990 plt_list = &h->plt.plist;
5991 }
5992
5993 /* We may need a .plt entry if the function this reloc
5994 refers to is in a shared lib. */
5995 if (plt_list
5996 && !update_plt_info (abfd, plt_list, rel->r_addend))
5997 return FALSE;
5998 break;
5999
6000 case R_PPC64_ADDR14:
6001 case R_PPC64_ADDR14_BRNTAKEN:
6002 case R_PPC64_ADDR14_BRTAKEN:
6003 case R_PPC64_ADDR24:
6004 goto dodyn;
6005
6006 case R_PPC64_TPREL64:
6007 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
6008 if (bfd_link_dll (info))
6009 info->flags |= DF_STATIC_TLS;
6010 goto dotlstoc;
6011
6012 case R_PPC64_DTPMOD64:
6013 if (rel + 1 < rel_end
6014 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
6015 && rel[1].r_offset == rel->r_offset + 8)
6016 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
6017 else
6018 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
6019 goto dotlstoc;
6020
6021 case R_PPC64_DTPREL64:
6022 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
6023 if (rel != relocs
6024 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
6025 && rel[-1].r_offset == rel->r_offset - 8)
6026 /* This is the second reloc of a dtpmod, dtprel pair.
6027 Don't mark with TLS_DTPREL. */
6028 goto dodyn;
6029
6030 dotlstoc:
6031 sec->has_tls_reloc = 1;
6032 if (h != NULL)
6033 {
6034 struct ppc_link_hash_entry *eh;
6035 eh = (struct ppc_link_hash_entry *) h;
6036 eh->tls_mask |= tls_type;
6037 }
6038 else
6039 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
6040 rel->r_addend, tls_type))
6041 return FALSE;
6042
6043 ppc64_sec = ppc64_elf_section_data (sec);
6044 if (ppc64_sec->sec_type != sec_toc)
6045 {
6046 bfd_size_type amt;
6047
6048 /* One extra to simplify get_tls_mask. */
6049 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
6050 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
6051 if (ppc64_sec->u.toc.symndx == NULL)
6052 return FALSE;
6053 amt = sec->size * sizeof (bfd_vma) / 8;
6054 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
6055 if (ppc64_sec->u.toc.add == NULL)
6056 return FALSE;
6057 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
6058 ppc64_sec->sec_type = sec_toc;
6059 }
6060 BFD_ASSERT (rel->r_offset % 8 == 0);
6061 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
6062 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
6063
6064 /* Mark the second slot of a GD or LD entry.
6065 -1 to indicate GD and -2 to indicate LD. */
6066 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
6067 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
6068 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
6069 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
6070 goto dodyn;
6071
6072 case R_PPC64_TPREL16:
6073 case R_PPC64_TPREL16_LO:
6074 case R_PPC64_TPREL16_HI:
6075 case R_PPC64_TPREL16_HA:
6076 case R_PPC64_TPREL16_DS:
6077 case R_PPC64_TPREL16_LO_DS:
6078 case R_PPC64_TPREL16_HIGH:
6079 case R_PPC64_TPREL16_HIGHA:
6080 case R_PPC64_TPREL16_HIGHER:
6081 case R_PPC64_TPREL16_HIGHERA:
6082 case R_PPC64_TPREL16_HIGHEST:
6083 case R_PPC64_TPREL16_HIGHESTA:
6084 if (bfd_link_dll (info))
6085 info->flags |= DF_STATIC_TLS;
6086 goto dodyn;
6087
6088 case R_PPC64_ADDR64:
6089 if (is_opd
6090 && rel + 1 < rel_end
6091 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
6092 {
6093 if (h != NULL)
6094 ((struct ppc_link_hash_entry *) h)->is_func = 1;
6095 }
6096 /* Fall through. */
6097
6098 case R_PPC64_ADDR16:
6099 case R_PPC64_ADDR16_DS:
6100 case R_PPC64_ADDR16_HA:
6101 case R_PPC64_ADDR16_HI:
6102 case R_PPC64_ADDR16_HIGH:
6103 case R_PPC64_ADDR16_HIGHA:
6104 case R_PPC64_ADDR16_HIGHER:
6105 case R_PPC64_ADDR16_HIGHERA:
6106 case R_PPC64_ADDR16_HIGHEST:
6107 case R_PPC64_ADDR16_HIGHESTA:
6108 case R_PPC64_ADDR16_LO:
6109 case R_PPC64_ADDR16_LO_DS:
6110 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6111 && rel->r_addend == 0)
6112 {
6113 /* We may need a .plt entry if this reloc refers to a
6114 function in a shared lib. */
6115 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
6116 return FALSE;
6117 h->pointer_equality_needed = 1;
6118 }
6119 /* Fall through. */
6120
6121 case R_PPC64_REL30:
6122 case R_PPC64_REL32:
6123 case R_PPC64_REL64:
6124 case R_PPC64_ADDR32:
6125 case R_PPC64_UADDR16:
6126 case R_PPC64_UADDR32:
6127 case R_PPC64_UADDR64:
6128 case R_PPC64_TOC:
6129 if (h != NULL && !bfd_link_pic (info))
6130 /* We may need a copy reloc. */
6131 h->non_got_ref = 1;
6132
6133 /* Don't propagate .opd relocs. */
6134 if (NO_OPD_RELOCS && is_opd)
6135 break;
6136
6137 /* If we are creating a shared library, and this is a reloc
6138 against a global symbol, or a non PC relative reloc
6139 against a local symbol, then we need to copy the reloc
6140 into the shared library. However, if we are linking with
6141 -Bsymbolic, we do not need to copy a reloc against a
6142 global symbol which is defined in an object we are
6143 including in the link (i.e., DEF_REGULAR is set). At
6144 this point we have not seen all the input files, so it is
6145 possible that DEF_REGULAR is not set now but will be set
6146 later (it is never cleared). In case of a weak definition,
6147 DEF_REGULAR may be cleared later by a strong definition in
6148 a shared library. We account for that possibility below by
6149 storing information in the dyn_relocs field of the hash
6150 table entry. A similar situation occurs when creating
6151 shared libraries and symbol visibility changes render the
6152 symbol local.
6153
6154 If on the other hand, we are creating an executable, we
6155 may need to keep relocations for symbols satisfied by a
6156 dynamic library if we manage to avoid copy relocs for the
6157 symbol. */
6158 dodyn:
6159 if ((bfd_link_pic (info)
6160 && (must_be_dyn_reloc (info, r_type)
6161 || (h != NULL
6162 && (!SYMBOLIC_BIND (info, h)
6163 || h->root.type == bfd_link_hash_defweak
6164 || !h->def_regular))))
6165 || (ELIMINATE_COPY_RELOCS
6166 && !bfd_link_pic (info)
6167 && h != NULL
6168 && (h->root.type == bfd_link_hash_defweak
6169 || !h->def_regular))
6170 || (!bfd_link_pic (info)
6171 && ifunc != NULL))
6172 {
6173 /* We must copy these reloc types into the output file.
6174 Create a reloc section in dynobj and make room for
6175 this reloc. */
6176 if (sreloc == NULL)
6177 {
6178 sreloc = _bfd_elf_make_dynamic_reloc_section
6179 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6180
6181 if (sreloc == NULL)
6182 return FALSE;
6183 }
6184
6185 /* If this is a global symbol, we count the number of
6186 relocations we need for this symbol. */
6187 if (h != NULL)
6188 {
6189 struct elf_dyn_relocs *p;
6190 struct elf_dyn_relocs **head;
6191
6192 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6193 p = *head;
6194 if (p == NULL || p->sec != sec)
6195 {
6196 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6197 if (p == NULL)
6198 return FALSE;
6199 p->next = *head;
6200 *head = p;
6201 p->sec = sec;
6202 p->count = 0;
6203 p->pc_count = 0;
6204 }
6205 p->count += 1;
6206 if (!must_be_dyn_reloc (info, r_type))
6207 p->pc_count += 1;
6208 }
6209 else
6210 {
6211 /* Track dynamic relocs needed for local syms too.
6212 We really need local syms available to do this
6213 easily. Oh well. */
6214 struct ppc_dyn_relocs *p;
6215 struct ppc_dyn_relocs **head;
6216 bfd_boolean is_ifunc;
6217 asection *s;
6218 void *vpp;
6219 Elf_Internal_Sym *isym;
6220
6221 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6222 abfd, r_symndx);
6223 if (isym == NULL)
6224 return FALSE;
6225
6226 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6227 if (s == NULL)
6228 s = sec;
6229
6230 vpp = &elf_section_data (s)->local_dynrel;
6231 head = (struct ppc_dyn_relocs **) vpp;
6232 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6233 p = *head;
6234 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6235 p = p->next;
6236 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6237 {
6238 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6239 if (p == NULL)
6240 return FALSE;
6241 p->next = *head;
6242 *head = p;
6243 p->sec = sec;
6244 p->ifunc = is_ifunc;
6245 p->count = 0;
6246 }
6247 p->count += 1;
6248 }
6249 }
6250 break;
6251
6252 default:
6253 break;
6254 }
6255 }
6256
6257 return TRUE;
6258 }
6259
6260 /* Merge backend specific data from an object file to the output
6261 object file when linking. */
6262
6263 static bfd_boolean
6264 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6265 {
6266 bfd *obfd = info->output_bfd;
6267 unsigned long iflags, oflags;
6268
6269 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6270 return TRUE;
6271
6272 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6273 return TRUE;
6274
6275 if (!_bfd_generic_verify_endian_match (ibfd, info))
6276 return FALSE;
6277
6278 iflags = elf_elfheader (ibfd)->e_flags;
6279 oflags = elf_elfheader (obfd)->e_flags;
6280
6281 if (iflags & ~EF_PPC64_ABI)
6282 {
6283 _bfd_error_handler
6284 /* xgettext:c-format */
6285 (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6286 bfd_set_error (bfd_error_bad_value);
6287 return FALSE;
6288 }
6289 else if (iflags != oflags && iflags != 0)
6290 {
6291 _bfd_error_handler
6292 /* xgettext:c-format */
6293 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6294 ibfd, iflags, oflags);
6295 bfd_set_error (bfd_error_bad_value);
6296 return FALSE;
6297 }
6298
6299 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
6300 return FALSE;
6301
6302 /* Merge Tag_compatibility attributes and any common GNU ones. */
6303 return _bfd_elf_merge_object_attributes (ibfd, info);
6304 }
6305
6306 static bfd_boolean
6307 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6308 {
6309 /* Print normal ELF private data. */
6310 _bfd_elf_print_private_bfd_data (abfd, ptr);
6311
6312 if (elf_elfheader (abfd)->e_flags != 0)
6313 {
6314 FILE *file = ptr;
6315
6316 fprintf (file, _("private flags = 0x%lx:"),
6317 elf_elfheader (abfd)->e_flags);
6318
6319 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6320 fprintf (file, _(" [abiv%ld]"),
6321 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6322 fputc ('\n', file);
6323 }
6324
6325 return TRUE;
6326 }
6327
6328 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6329 of the code entry point, and its section, which must be in the same
6330 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6331
6332 static bfd_vma
6333 opd_entry_value (asection *opd_sec,
6334 bfd_vma offset,
6335 asection **code_sec,
6336 bfd_vma *code_off,
6337 bfd_boolean in_code_sec)
6338 {
6339 bfd *opd_bfd = opd_sec->owner;
6340 Elf_Internal_Rela *relocs;
6341 Elf_Internal_Rela *lo, *hi, *look;
6342 bfd_vma val;
6343
6344 /* No relocs implies we are linking a --just-symbols object, or looking
6345 at a final linked executable with addr2line or somesuch. */
6346 if (opd_sec->reloc_count == 0)
6347 {
6348 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6349
6350 if (contents == NULL)
6351 {
6352 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6353 return (bfd_vma) -1;
6354 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6355 }
6356
6357 /* PR 17512: file: 64b9dfbb. */
6358 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6359 return (bfd_vma) -1;
6360
6361 val = bfd_get_64 (opd_bfd, contents + offset);
6362 if (code_sec != NULL)
6363 {
6364 asection *sec, *likely = NULL;
6365
6366 if (in_code_sec)
6367 {
6368 sec = *code_sec;
6369 if (sec->vma <= val
6370 && val < sec->vma + sec->size)
6371 likely = sec;
6372 else
6373 val = -1;
6374 }
6375 else
6376 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6377 if (sec->vma <= val
6378 && (sec->flags & SEC_LOAD) != 0
6379 && (sec->flags & SEC_ALLOC) != 0)
6380 likely = sec;
6381 if (likely != NULL)
6382 {
6383 *code_sec = likely;
6384 if (code_off != NULL)
6385 *code_off = val - likely->vma;
6386 }
6387 }
6388 return val;
6389 }
6390
6391 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6392
6393 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6394 if (relocs == NULL)
6395 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6396 /* PR 17512: file: df8e1fd6. */
6397 if (relocs == NULL)
6398 return (bfd_vma) -1;
6399
6400 /* Go find the opd reloc at the sym address. */
6401 lo = relocs;
6402 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6403 val = (bfd_vma) -1;
6404 while (lo < hi)
6405 {
6406 look = lo + (hi - lo) / 2;
6407 if (look->r_offset < offset)
6408 lo = look + 1;
6409 else if (look->r_offset > offset)
6410 hi = look;
6411 else
6412 {
6413 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6414
6415 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6416 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6417 {
6418 unsigned long symndx = ELF64_R_SYM (look->r_info);
6419 asection *sec = NULL;
6420
6421 if (symndx >= symtab_hdr->sh_info
6422 && elf_sym_hashes (opd_bfd) != NULL)
6423 {
6424 struct elf_link_hash_entry **sym_hashes;
6425 struct elf_link_hash_entry *rh;
6426
6427 sym_hashes = elf_sym_hashes (opd_bfd);
6428 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6429 if (rh != NULL)
6430 {
6431 rh = elf_follow_link (rh);
6432 if (rh->root.type != bfd_link_hash_defined
6433 && rh->root.type != bfd_link_hash_defweak)
6434 break;
6435 if (rh->root.u.def.section->owner == opd_bfd)
6436 {
6437 val = rh->root.u.def.value;
6438 sec = rh->root.u.def.section;
6439 }
6440 }
6441 }
6442
6443 if (sec == NULL)
6444 {
6445 Elf_Internal_Sym *sym;
6446
6447 if (symndx < symtab_hdr->sh_info)
6448 {
6449 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6450 if (sym == NULL)
6451 {
6452 size_t symcnt = symtab_hdr->sh_info;
6453 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6454 symcnt, 0,
6455 NULL, NULL, NULL);
6456 if (sym == NULL)
6457 break;
6458 symtab_hdr->contents = (bfd_byte *) sym;
6459 }
6460 sym += symndx;
6461 }
6462 else
6463 {
6464 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6465 1, symndx,
6466 NULL, NULL, NULL);
6467 if (sym == NULL)
6468 break;
6469 }
6470 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6471 if (sec == NULL)
6472 break;
6473 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6474 val = sym->st_value;
6475 }
6476
6477 val += look->r_addend;
6478 if (code_off != NULL)
6479 *code_off = val;
6480 if (code_sec != NULL)
6481 {
6482 if (in_code_sec && *code_sec != sec)
6483 return -1;
6484 else
6485 *code_sec = sec;
6486 }
6487 if (sec->output_section != NULL)
6488 val += sec->output_section->vma + sec->output_offset;
6489 }
6490 break;
6491 }
6492 }
6493
6494 return val;
6495 }
6496
6497 /* If the ELF symbol SYM might be a function in SEC, return the
6498 function size and set *CODE_OFF to the function's entry point,
6499 otherwise return zero. */
6500
6501 static bfd_size_type
6502 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6503 bfd_vma *code_off)
6504 {
6505 bfd_size_type size;
6506
6507 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6508 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6509 return 0;
6510
6511 size = 0;
6512 if (!(sym->flags & BSF_SYNTHETIC))
6513 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6514
6515 if (strcmp (sym->section->name, ".opd") == 0)
6516 {
6517 struct _opd_sec_data *opd = get_opd_info (sym->section);
6518 bfd_vma symval = sym->value;
6519
6520 if (opd != NULL
6521 && opd->adjust != NULL
6522 && elf_section_data (sym->section)->relocs != NULL)
6523 {
6524 /* opd_entry_value will use cached relocs that have been
6525 adjusted, but with raw symbols. That means both local
6526 and global symbols need adjusting. */
6527 long adjust = opd->adjust[OPD_NDX (symval)];
6528 if (adjust == -1)
6529 return 0;
6530 symval += adjust;
6531 }
6532
6533 if (opd_entry_value (sym->section, symval,
6534 &sec, code_off, TRUE) == (bfd_vma) -1)
6535 return 0;
6536 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6537 symbol. This size has nothing to do with the code size of the
6538 function, which is what we're supposed to return, but the
6539 code size isn't available without looking up the dot-sym.
6540 However, doing that would be a waste of time particularly
6541 since elf_find_function will look at the dot-sym anyway.
6542 Now, elf_find_function will keep the largest size of any
6543 function sym found at the code address of interest, so return
6544 1 here to avoid it incorrectly caching a larger function size
6545 for a small function. This does mean we return the wrong
6546 size for a new-ABI function of size 24, but all that does is
6547 disable caching for such functions. */
6548 if (size == 24)
6549 size = 1;
6550 }
6551 else
6552 {
6553 if (sym->section != sec)
6554 return 0;
6555 *code_off = sym->value;
6556 }
6557 if (size == 0)
6558 size = 1;
6559 return size;
6560 }
6561
6562 /* Return true if symbol is a strong function defined in an ELFv2
6563 object with st_other localentry bits of zero, ie. its local entry
6564 point coincides with its global entry point. */
6565
6566 static bfd_boolean
6567 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6568 {
6569 return (h != NULL
6570 && h->type == STT_FUNC
6571 && h->root.type == bfd_link_hash_defined
6572 && (STO_PPC64_LOCAL_MASK & h->other) == 0
6573 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6574 && is_ppc64_elf (h->root.u.def.section->owner)
6575 && abiversion (h->root.u.def.section->owner) >= 2);
6576 }
6577
6578 /* Return true if symbol is defined in a regular object file. */
6579
6580 static bfd_boolean
6581 is_static_defined (struct elf_link_hash_entry *h)
6582 {
6583 return ((h->root.type == bfd_link_hash_defined
6584 || h->root.type == bfd_link_hash_defweak)
6585 && h->root.u.def.section != NULL
6586 && h->root.u.def.section->output_section != NULL);
6587 }
6588
6589 /* If FDH is a function descriptor symbol, return the associated code
6590 entry symbol if it is defined. Return NULL otherwise. */
6591
6592 static struct ppc_link_hash_entry *
6593 defined_code_entry (struct ppc_link_hash_entry *fdh)
6594 {
6595 if (fdh->is_func_descriptor)
6596 {
6597 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6598 if (fh->elf.root.type == bfd_link_hash_defined
6599 || fh->elf.root.type == bfd_link_hash_defweak)
6600 return fh;
6601 }
6602 return NULL;
6603 }
6604
6605 /* If FH is a function code entry symbol, return the associated
6606 function descriptor symbol if it is defined. Return NULL otherwise. */
6607
6608 static struct ppc_link_hash_entry *
6609 defined_func_desc (struct ppc_link_hash_entry *fh)
6610 {
6611 if (fh->oh != NULL
6612 && fh->oh->is_func_descriptor)
6613 {
6614 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6615 if (fdh->elf.root.type == bfd_link_hash_defined
6616 || fdh->elf.root.type == bfd_link_hash_defweak)
6617 return fdh;
6618 }
6619 return NULL;
6620 }
6621
6622 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6623
6624 /* Garbage collect sections, after first dealing with dot-symbols. */
6625
6626 static bfd_boolean
6627 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6628 {
6629 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6630
6631 if (htab != NULL && htab->need_func_desc_adj)
6632 {
6633 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6634 htab->need_func_desc_adj = 0;
6635 }
6636 return bfd_elf_gc_sections (abfd, info);
6637 }
6638
6639 /* Mark all our entry sym sections, both opd and code section. */
6640
6641 static void
6642 ppc64_elf_gc_keep (struct bfd_link_info *info)
6643 {
6644 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6645 struct bfd_sym_chain *sym;
6646
6647 if (htab == NULL)
6648 return;
6649
6650 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6651 {
6652 struct ppc_link_hash_entry *eh, *fh;
6653 asection *sec;
6654
6655 eh = (struct ppc_link_hash_entry *)
6656 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6657 if (eh == NULL)
6658 continue;
6659 if (eh->elf.root.type != bfd_link_hash_defined
6660 && eh->elf.root.type != bfd_link_hash_defweak)
6661 continue;
6662
6663 fh = defined_code_entry (eh);
6664 if (fh != NULL)
6665 {
6666 sec = fh->elf.root.u.def.section;
6667 sec->flags |= SEC_KEEP;
6668 }
6669 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6670 && opd_entry_value (eh->elf.root.u.def.section,
6671 eh->elf.root.u.def.value,
6672 &sec, NULL, FALSE) != (bfd_vma) -1)
6673 sec->flags |= SEC_KEEP;
6674
6675 sec = eh->elf.root.u.def.section;
6676 sec->flags |= SEC_KEEP;
6677 }
6678 }
6679
6680 /* Mark sections containing dynamically referenced symbols. When
6681 building shared libraries, we must assume that any visible symbol is
6682 referenced. */
6683
6684 static bfd_boolean
6685 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6686 {
6687 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6688 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6689 struct ppc_link_hash_entry *fdh;
6690 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6691
6692 /* Dynamic linking info is on the func descriptor sym. */
6693 fdh = defined_func_desc (eh);
6694 if (fdh != NULL)
6695 eh = fdh;
6696
6697 if ((eh->elf.root.type == bfd_link_hash_defined
6698 || eh->elf.root.type == bfd_link_hash_defweak)
6699 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6700 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6701 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6702 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6703 && (!bfd_link_executable (info)
6704 || info->gc_keep_exported
6705 || info->export_dynamic
6706 || (eh->elf.dynamic
6707 && d != NULL
6708 && (*d->match) (&d->head, NULL,
6709 eh->elf.root.root.string)))
6710 && (eh->elf.versioned >= versioned
6711 || !bfd_hide_sym_by_version (info->version_info,
6712 eh->elf.root.root.string)))))
6713 {
6714 asection *code_sec;
6715 struct ppc_link_hash_entry *fh;
6716
6717 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6718
6719 /* Function descriptor syms cause the associated
6720 function code sym section to be marked. */
6721 fh = defined_code_entry (eh);
6722 if (fh != NULL)
6723 {
6724 code_sec = fh->elf.root.u.def.section;
6725 code_sec->flags |= SEC_KEEP;
6726 }
6727 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6728 && opd_entry_value (eh->elf.root.u.def.section,
6729 eh->elf.root.u.def.value,
6730 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6731 code_sec->flags |= SEC_KEEP;
6732 }
6733
6734 return TRUE;
6735 }
6736
6737 /* Return the section that should be marked against GC for a given
6738 relocation. */
6739
6740 static asection *
6741 ppc64_elf_gc_mark_hook (asection *sec,
6742 struct bfd_link_info *info,
6743 Elf_Internal_Rela *rel,
6744 struct elf_link_hash_entry *h,
6745 Elf_Internal_Sym *sym)
6746 {
6747 asection *rsec;
6748
6749 /* Syms return NULL if we're marking .opd, so we avoid marking all
6750 function sections, as all functions are referenced in .opd. */
6751 rsec = NULL;
6752 if (get_opd_info (sec) != NULL)
6753 return rsec;
6754
6755 if (h != NULL)
6756 {
6757 enum elf_ppc64_reloc_type r_type;
6758 struct ppc_link_hash_entry *eh, *fh, *fdh;
6759
6760 r_type = ELF64_R_TYPE (rel->r_info);
6761 switch (r_type)
6762 {
6763 case R_PPC64_GNU_VTINHERIT:
6764 case R_PPC64_GNU_VTENTRY:
6765 break;
6766
6767 default:
6768 switch (h->root.type)
6769 {
6770 case bfd_link_hash_defined:
6771 case bfd_link_hash_defweak:
6772 eh = (struct ppc_link_hash_entry *) h;
6773 fdh = defined_func_desc (eh);
6774 if (fdh != NULL)
6775 {
6776 /* -mcall-aixdesc code references the dot-symbol on
6777 a call reloc. Mark the function descriptor too
6778 against garbage collection. */
6779 fdh->elf.mark = 1;
6780 if (fdh->elf.is_weakalias)
6781 weakdef (&fdh->elf)->mark = 1;
6782 eh = fdh;
6783 }
6784
6785 /* Function descriptor syms cause the associated
6786 function code sym section to be marked. */
6787 fh = defined_code_entry (eh);
6788 if (fh != NULL)
6789 {
6790 /* They also mark their opd section. */
6791 eh->elf.root.u.def.section->gc_mark = 1;
6792
6793 rsec = fh->elf.root.u.def.section;
6794 }
6795 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6796 && opd_entry_value (eh->elf.root.u.def.section,
6797 eh->elf.root.u.def.value,
6798 &rsec, NULL, FALSE) != (bfd_vma) -1)
6799 eh->elf.root.u.def.section->gc_mark = 1;
6800 else
6801 rsec = h->root.u.def.section;
6802 break;
6803
6804 case bfd_link_hash_common:
6805 rsec = h->root.u.c.p->section;
6806 break;
6807
6808 default:
6809 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6810 }
6811 }
6812 }
6813 else
6814 {
6815 struct _opd_sec_data *opd;
6816
6817 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6818 opd = get_opd_info (rsec);
6819 if (opd != NULL && opd->func_sec != NULL)
6820 {
6821 rsec->gc_mark = 1;
6822
6823 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6824 }
6825 }
6826
6827 return rsec;
6828 }
6829
6830 /* The maximum size of .sfpr. */
6831 #define SFPR_MAX (218*4)
6832
6833 struct sfpr_def_parms
6834 {
6835 const char name[12];
6836 unsigned char lo, hi;
6837 bfd_byte *(*write_ent) (bfd *, bfd_byte *, int);
6838 bfd_byte *(*write_tail) (bfd *, bfd_byte *, int);
6839 };
6840
6841 /* Auto-generate _save*, _rest* functions in .sfpr.
6842 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6843 instead. */
6844
6845 static bfd_boolean
6846 sfpr_define (struct bfd_link_info *info,
6847 const struct sfpr_def_parms *parm,
6848 asection *stub_sec)
6849 {
6850 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6851 unsigned int i;
6852 size_t len = strlen (parm->name);
6853 bfd_boolean writing = FALSE;
6854 char sym[16];
6855
6856 if (htab == NULL)
6857 return FALSE;
6858
6859 memcpy (sym, parm->name, len);
6860 sym[len + 2] = 0;
6861
6862 for (i = parm->lo; i <= parm->hi; i++)
6863 {
6864 struct ppc_link_hash_entry *h;
6865
6866 sym[len + 0] = i / 10 + '0';
6867 sym[len + 1] = i % 10 + '0';
6868 h = (struct ppc_link_hash_entry *)
6869 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6870 if (stub_sec != NULL)
6871 {
6872 if (h != NULL
6873 && h->elf.root.type == bfd_link_hash_defined
6874 && h->elf.root.u.def.section == htab->sfpr)
6875 {
6876 struct elf_link_hash_entry *s;
6877 char buf[32];
6878 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6879 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6880 if (s == NULL)
6881 return FALSE;
6882 if (s->root.type == bfd_link_hash_new
6883 || (s->root.type = bfd_link_hash_defined
6884 && s->root.u.def.section == stub_sec))
6885 {
6886 s->root.type = bfd_link_hash_defined;
6887 s->root.u.def.section = stub_sec;
6888 s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6889 + h->elf.root.u.def.value);
6890 s->ref_regular = 1;
6891 s->def_regular = 1;
6892 s->ref_regular_nonweak = 1;
6893 s->forced_local = 1;
6894 s->non_elf = 0;
6895 s->root.linker_def = 1;
6896 }
6897 }
6898 continue;
6899 }
6900 if (h != NULL)
6901 {
6902 h->save_res = 1;
6903 if (!h->elf.def_regular)
6904 {
6905 h->elf.root.type = bfd_link_hash_defined;
6906 h->elf.root.u.def.section = htab->sfpr;
6907 h->elf.root.u.def.value = htab->sfpr->size;
6908 h->elf.type = STT_FUNC;
6909 h->elf.def_regular = 1;
6910 h->elf.non_elf = 0;
6911 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6912 writing = TRUE;
6913 if (htab->sfpr->contents == NULL)
6914 {
6915 htab->sfpr->contents
6916 = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6917 if (htab->sfpr->contents == NULL)
6918 return FALSE;
6919 }
6920 }
6921 }
6922 if (writing)
6923 {
6924 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6925 if (i != parm->hi)
6926 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6927 else
6928 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6929 htab->sfpr->size = p - htab->sfpr->contents;
6930 }
6931 }
6932
6933 return TRUE;
6934 }
6935
6936 static bfd_byte *
6937 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6938 {
6939 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6940 return p + 4;
6941 }
6942
6943 static bfd_byte *
6944 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6945 {
6946 p = savegpr0 (abfd, p, r);
6947 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6948 p = p + 4;
6949 bfd_put_32 (abfd, BLR, p);
6950 return p + 4;
6951 }
6952
6953 static bfd_byte *
6954 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6955 {
6956 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6957 return p + 4;
6958 }
6959
6960 static bfd_byte *
6961 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6962 {
6963 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6964 p = p + 4;
6965 p = restgpr0 (abfd, p, r);
6966 bfd_put_32 (abfd, MTLR_R0, p);
6967 p = p + 4;
6968 if (r == 29)
6969 {
6970 p = restgpr0 (abfd, p, 30);
6971 p = restgpr0 (abfd, p, 31);
6972 }
6973 bfd_put_32 (abfd, BLR, p);
6974 return p + 4;
6975 }
6976
6977 static bfd_byte *
6978 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6979 {
6980 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6981 return p + 4;
6982 }
6983
6984 static bfd_byte *
6985 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6986 {
6987 p = savegpr1 (abfd, p, r);
6988 bfd_put_32 (abfd, BLR, p);
6989 return p + 4;
6990 }
6991
6992 static bfd_byte *
6993 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6994 {
6995 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6996 return p + 4;
6997 }
6998
6999 static bfd_byte *
7000 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
7001 {
7002 p = restgpr1 (abfd, p, r);
7003 bfd_put_32 (abfd, BLR, p);
7004 return p + 4;
7005 }
7006
7007 static bfd_byte *
7008 savefpr (bfd *abfd, bfd_byte *p, int r)
7009 {
7010 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7011 return p + 4;
7012 }
7013
7014 static bfd_byte *
7015 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
7016 {
7017 p = savefpr (abfd, p, r);
7018 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
7019 p = p + 4;
7020 bfd_put_32 (abfd, BLR, p);
7021 return p + 4;
7022 }
7023
7024 static bfd_byte *
7025 restfpr (bfd *abfd, bfd_byte *p, int r)
7026 {
7027 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7028 return p + 4;
7029 }
7030
7031 static bfd_byte *
7032 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
7033 {
7034 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
7035 p = p + 4;
7036 p = restfpr (abfd, p, r);
7037 bfd_put_32 (abfd, MTLR_R0, p);
7038 p = p + 4;
7039 if (r == 29)
7040 {
7041 p = restfpr (abfd, p, 30);
7042 p = restfpr (abfd, p, 31);
7043 }
7044 bfd_put_32 (abfd, BLR, p);
7045 return p + 4;
7046 }
7047
7048 static bfd_byte *
7049 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7050 {
7051 p = savefpr (abfd, p, r);
7052 bfd_put_32 (abfd, BLR, p);
7053 return p + 4;
7054 }
7055
7056 static bfd_byte *
7057 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7058 {
7059 p = restfpr (abfd, p, r);
7060 bfd_put_32 (abfd, BLR, p);
7061 return p + 4;
7062 }
7063
7064 static bfd_byte *
7065 savevr (bfd *abfd, bfd_byte *p, int r)
7066 {
7067 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7068 p = p + 4;
7069 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7070 return p + 4;
7071 }
7072
7073 static bfd_byte *
7074 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7075 {
7076 p = savevr (abfd, p, r);
7077 bfd_put_32 (abfd, BLR, p);
7078 return p + 4;
7079 }
7080
7081 static bfd_byte *
7082 restvr (bfd *abfd, bfd_byte *p, int r)
7083 {
7084 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7085 p = p + 4;
7086 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7087 return p + 4;
7088 }
7089
7090 static bfd_byte *
7091 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7092 {
7093 p = restvr (abfd, p, r);
7094 bfd_put_32 (abfd, BLR, p);
7095 return p + 4;
7096 }
7097
7098 /* Called via elf_link_hash_traverse to transfer dynamic linking
7099 information on function code symbol entries to their corresponding
7100 function descriptor symbol entries. */
7101
7102 static bfd_boolean
7103 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7104 {
7105 struct bfd_link_info *info;
7106 struct ppc_link_hash_table *htab;
7107 struct ppc_link_hash_entry *fh;
7108 struct ppc_link_hash_entry *fdh;
7109 bfd_boolean force_local;
7110
7111 fh = (struct ppc_link_hash_entry *) h;
7112 if (fh->elf.root.type == bfd_link_hash_indirect)
7113 return TRUE;
7114
7115 if (!fh->is_func)
7116 return TRUE;
7117
7118 if (fh->elf.root.root.string[0] != '.'
7119 || fh->elf.root.root.string[1] == '\0')
7120 return TRUE;
7121
7122 info = inf;
7123 htab = ppc_hash_table (info);
7124 if (htab == NULL)
7125 return FALSE;
7126
7127 /* Find the corresponding function descriptor symbol. */
7128 fdh = lookup_fdh (fh, htab);
7129
7130 /* Resolve undefined references to dot-symbols as the value
7131 in the function descriptor, if we have one in a regular object.
7132 This is to satisfy cases like ".quad .foo". Calls to functions
7133 in dynamic objects are handled elsewhere. */
7134 if ((fh->elf.root.type == bfd_link_hash_undefined
7135 || fh->elf.root.type == bfd_link_hash_undefweak)
7136 && (fdh->elf.root.type == bfd_link_hash_defined
7137 || fdh->elf.root.type == bfd_link_hash_defweak)
7138 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7139 && opd_entry_value (fdh->elf.root.u.def.section,
7140 fdh->elf.root.u.def.value,
7141 &fh->elf.root.u.def.section,
7142 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7143 {
7144 fh->elf.root.type = fdh->elf.root.type;
7145 fh->elf.forced_local = 1;
7146 fh->elf.def_regular = fdh->elf.def_regular;
7147 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7148 }
7149
7150 if (!fh->elf.dynamic)
7151 {
7152 struct plt_entry *ent;
7153
7154 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7155 if (ent->plt.refcount > 0)
7156 break;
7157 if (ent == NULL)
7158 return TRUE;
7159 }
7160
7161 /* Create a descriptor as undefined if necessary. */
7162 if (fdh == NULL
7163 && !bfd_link_executable (info)
7164 && (fh->elf.root.type == bfd_link_hash_undefined
7165 || fh->elf.root.type == bfd_link_hash_undefweak))
7166 {
7167 fdh = make_fdh (info, fh);
7168 if (fdh == NULL)
7169 return FALSE;
7170 }
7171
7172 /* We can't support overriding of symbols on a fake descriptor. */
7173 if (fdh != NULL
7174 && fdh->fake
7175 && (fh->elf.root.type == bfd_link_hash_defined
7176 || fh->elf.root.type == bfd_link_hash_defweak))
7177 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7178
7179 /* Transfer dynamic linking information to the function descriptor. */
7180 if (fdh != NULL)
7181 {
7182 fdh->elf.ref_regular |= fh->elf.ref_regular;
7183 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7184 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7185 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7186 fdh->elf.dynamic |= fh->elf.dynamic;
7187 fdh->elf.needs_plt |= (fh->elf.needs_plt
7188 || fh->elf.type == STT_FUNC
7189 || fh->elf.type == STT_GNU_IFUNC);
7190 move_plt_plist (fh, fdh);
7191
7192 if (!fdh->elf.forced_local
7193 && fh->elf.dynindx != -1)
7194 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7195 return FALSE;
7196 }
7197
7198 /* Now that the info is on the function descriptor, clear the
7199 function code sym info. Any function code syms for which we
7200 don't have a definition in a regular file, we force local.
7201 This prevents a shared library from exporting syms that have
7202 been imported from another library. Function code syms that
7203 are really in the library we must leave global to prevent the
7204 linker dragging in a definition from a static library. */
7205 force_local = (!fh->elf.def_regular
7206 || fdh == NULL
7207 || !fdh->elf.def_regular
7208 || fdh->elf.forced_local);
7209 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7210
7211 return TRUE;
7212 }
7213
7214 static const struct sfpr_def_parms save_res_funcs[] =
7215 {
7216 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7217 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7218 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7219 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7220 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7221 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7222 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7223 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7224 { "._savef", 14, 31, savefpr, savefpr1_tail },
7225 { "._restf", 14, 31, restfpr, restfpr1_tail },
7226 { "_savevr_", 20, 31, savevr, savevr_tail },
7227 { "_restvr_", 20, 31, restvr, restvr_tail }
7228 };
7229
7230 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7231 this hook to a) provide some gcc support functions, and b) transfer
7232 dynamic linking information gathered so far on function code symbol
7233 entries, to their corresponding function descriptor symbol entries. */
7234
7235 static bfd_boolean
7236 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7237 struct bfd_link_info *info)
7238 {
7239 struct ppc_link_hash_table *htab;
7240
7241 htab = ppc_hash_table (info);
7242 if (htab == NULL)
7243 return FALSE;
7244
7245 /* Provide any missing _save* and _rest* functions. */
7246 if (htab->sfpr != NULL)
7247 {
7248 unsigned int i;
7249
7250 htab->sfpr->size = 0;
7251 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7252 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7253 return FALSE;
7254 if (htab->sfpr->size == 0)
7255 htab->sfpr->flags |= SEC_EXCLUDE;
7256 }
7257
7258 if (bfd_link_relocatable (info))
7259 return TRUE;
7260
7261 if (htab->elf.hgot != NULL)
7262 {
7263 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7264 /* Make .TOC. defined so as to prevent it being made dynamic.
7265 The wrong value here is fixed later in ppc64_elf_set_toc. */
7266 if (!htab->elf.hgot->def_regular
7267 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7268 {
7269 htab->elf.hgot->root.type = bfd_link_hash_defined;
7270 htab->elf.hgot->root.u.def.value = 0;
7271 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7272 htab->elf.hgot->def_regular = 1;
7273 htab->elf.hgot->root.linker_def = 1;
7274 }
7275 htab->elf.hgot->type = STT_OBJECT;
7276 htab->elf.hgot->other
7277 = (htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
7278 }
7279
7280 if (htab->need_func_desc_adj)
7281 {
7282 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7283 htab->need_func_desc_adj = 0;
7284 }
7285
7286 return TRUE;
7287 }
7288
7289 /* Find dynamic relocs for H that apply to read-only sections. */
7290
7291 static asection *
7292 readonly_dynrelocs (struct elf_link_hash_entry *h)
7293 {
7294 struct ppc_link_hash_entry *eh;
7295 struct elf_dyn_relocs *p;
7296
7297 eh = (struct ppc_link_hash_entry *) h;
7298 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7299 {
7300 asection *s = p->sec->output_section;
7301
7302 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7303 return p->sec;
7304 }
7305 return NULL;
7306 }
7307
7308 /* Return true if we have dynamic relocs against H or any of its weak
7309 aliases, that apply to read-only sections. Cannot be used after
7310 size_dynamic_sections. */
7311
7312 static bfd_boolean
7313 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7314 {
7315 struct ppc_link_hash_entry *eh;
7316
7317 eh = (struct ppc_link_hash_entry *) h;
7318 do
7319 {
7320 if (readonly_dynrelocs (&eh->elf))
7321 return TRUE;
7322 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7323 }
7324 while (eh != NULL && &eh->elf != h);
7325
7326 return FALSE;
7327 }
7328
7329 /* Return whether EH has pc-relative dynamic relocs. */
7330
7331 static bfd_boolean
7332 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7333 {
7334 struct elf_dyn_relocs *p;
7335
7336 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7337 if (p->pc_count != 0)
7338 return TRUE;
7339 return FALSE;
7340 }
7341
7342 /* Return true if a global entry stub will be created for H. Valid
7343 for ELFv2 before plt entries have been allocated. */
7344
7345 static bfd_boolean
7346 global_entry_stub (struct elf_link_hash_entry *h)
7347 {
7348 struct plt_entry *pent;
7349
7350 if (!h->pointer_equality_needed
7351 || h->def_regular)
7352 return FALSE;
7353
7354 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7355 if (pent->plt.refcount > 0
7356 && pent->addend == 0)
7357 return TRUE;
7358
7359 return FALSE;
7360 }
7361
7362 /* Adjust a symbol defined by a dynamic object and referenced by a
7363 regular object. The current definition is in some section of the
7364 dynamic object, but we're not including those sections. We have to
7365 change the definition to something the rest of the link can
7366 understand. */
7367
7368 static bfd_boolean
7369 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7370 struct elf_link_hash_entry *h)
7371 {
7372 struct ppc_link_hash_table *htab;
7373 asection *s, *srel;
7374
7375 htab = ppc_hash_table (info);
7376 if (htab == NULL)
7377 return FALSE;
7378
7379 /* Deal with function syms. */
7380 if (h->type == STT_FUNC
7381 || h->type == STT_GNU_IFUNC
7382 || h->needs_plt)
7383 {
7384 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7385 || SYMBOL_CALLS_LOCAL (info, h)
7386 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7387 /* Discard dyn_relocs when non-pic if we've decided that a
7388 function symbol is local and not an ifunc. We keep dynamic
7389 relocs for ifuncs when local rather than always emitting a
7390 plt call stub for them and defining the symbol on the call
7391 stub. We can't do that for ELFv1 anyway (a function symbol
7392 is defined on a descriptor, not code) and it can be faster at
7393 run-time due to not needing to bounce through a stub. The
7394 dyn_relocs for ifuncs will be applied even in a static
7395 executable. */
7396 if (!bfd_link_pic (info)
7397 && h->type != STT_GNU_IFUNC
7398 && local)
7399 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7400
7401 /* Clear procedure linkage table information for any symbol that
7402 won't need a .plt entry. */
7403 struct plt_entry *ent;
7404 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7405 if (ent->plt.refcount > 0)
7406 break;
7407 if (ent == NULL
7408 || (h->type != STT_GNU_IFUNC
7409 && local
7410 && (htab->can_convert_all_inline_plt
7411 || (((struct ppc_link_hash_entry *) h)->tls_mask
7412 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7413 {
7414 h->plt.plist = NULL;
7415 h->needs_plt = 0;
7416 h->pointer_equality_needed = 0;
7417 }
7418 else if (abiversion (info->output_bfd) >= 2)
7419 {
7420 /* Taking a function's address in a read/write section
7421 doesn't require us to define the function symbol in the
7422 executable on a global entry stub. A dynamic reloc can
7423 be used instead. The reason we prefer a few more dynamic
7424 relocs is that calling via a global entry stub costs a
7425 few more instructions, and pointer_equality_needed causes
7426 extra work in ld.so when resolving these symbols. */
7427 if (global_entry_stub (h))
7428 {
7429 if (!readonly_dynrelocs (h))
7430 {
7431 h->pointer_equality_needed = 0;
7432 /* If we haven't seen a branch reloc and the symbol
7433 isn't an ifunc then we don't need a plt entry. */
7434 if (!h->needs_plt)
7435 h->plt.plist = NULL;
7436 }
7437 else if (!bfd_link_pic (info))
7438 /* We are going to be defining the function symbol on the
7439 plt stub, so no dyn_relocs needed when non-pic. */
7440 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7441 }
7442
7443 /* ELFv2 function symbols can't have copy relocs. */
7444 return TRUE;
7445 }
7446 else if (!h->needs_plt
7447 && !readonly_dynrelocs (h))
7448 {
7449 /* If we haven't seen a branch reloc and the symbol isn't an
7450 ifunc then we don't need a plt entry. */
7451 h->plt.plist = NULL;
7452 h->pointer_equality_needed = 0;
7453 return TRUE;
7454 }
7455 }
7456 else
7457 h->plt.plist = NULL;
7458
7459 /* If this is a weak symbol, and there is a real definition, the
7460 processor independent code will have arranged for us to see the
7461 real definition first, and we can just use the same value. */
7462 if (h->is_weakalias)
7463 {
7464 struct elf_link_hash_entry *def = weakdef (h);
7465 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7466 h->root.u.def.section = def->root.u.def.section;
7467 h->root.u.def.value = def->root.u.def.value;
7468 if (def->root.u.def.section == htab->elf.sdynbss
7469 || def->root.u.def.section == htab->elf.sdynrelro)
7470 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7471 return TRUE;
7472 }
7473
7474 /* If we are creating a shared library, we must presume that the
7475 only references to the symbol are via the global offset table.
7476 For such cases we need not do anything here; the relocations will
7477 be handled correctly by relocate_section. */
7478 if (bfd_link_pic (info))
7479 return TRUE;
7480
7481 /* If there are no references to this symbol that do not use the
7482 GOT, we don't need to generate a copy reloc. */
7483 if (!h->non_got_ref)
7484 return TRUE;
7485
7486 /* Don't generate a copy reloc for symbols defined in the executable. */
7487 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7488
7489 /* If -z nocopyreloc was given, don't generate them either. */
7490 || info->nocopyreloc
7491
7492 /* If we don't find any dynamic relocs in read-only sections, then
7493 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7494 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7495
7496 /* Protected variables do not work with .dynbss. The copy in
7497 .dynbss won't be used by the shared library with the protected
7498 definition for the variable. Text relocations are preferable
7499 to an incorrect program. */
7500 || h->protected_def)
7501 return TRUE;
7502
7503 if (h->plt.plist != NULL)
7504 {
7505 /* We should never get here, but unfortunately there are versions
7506 of gcc out there that improperly (for this ABI) put initialized
7507 function pointers, vtable refs and suchlike in read-only
7508 sections. Allow them to proceed, but warn that this might
7509 break at runtime. */
7510 info->callbacks->einfo
7511 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7512 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7513 h->root.root.string);
7514 }
7515
7516 /* This is a reference to a symbol defined by a dynamic object which
7517 is not a function. */
7518
7519 /* We must allocate the symbol in our .dynbss section, which will
7520 become part of the .bss section of the executable. There will be
7521 an entry for this symbol in the .dynsym section. The dynamic
7522 object will contain position independent code, so all references
7523 from the dynamic object to this symbol will go through the global
7524 offset table. The dynamic linker will use the .dynsym entry to
7525 determine the address it must put in the global offset table, so
7526 both the dynamic object and the regular object will refer to the
7527 same memory location for the variable. */
7528 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7529 {
7530 s = htab->elf.sdynrelro;
7531 srel = htab->elf.sreldynrelro;
7532 }
7533 else
7534 {
7535 s = htab->elf.sdynbss;
7536 srel = htab->elf.srelbss;
7537 }
7538 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7539 {
7540 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7541 linker to copy the initial value out of the dynamic object
7542 and into the runtime process image. */
7543 srel->size += sizeof (Elf64_External_Rela);
7544 h->needs_copy = 1;
7545 }
7546
7547 /* We no longer want dyn_relocs. */
7548 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7549 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7550 }
7551
7552 /* If given a function descriptor symbol, hide both the function code
7553 sym and the descriptor. */
7554 static void
7555 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7556 struct elf_link_hash_entry *h,
7557 bfd_boolean force_local)
7558 {
7559 struct ppc_link_hash_entry *eh;
7560 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7561
7562 eh = (struct ppc_link_hash_entry *) h;
7563 if (eh->is_func_descriptor)
7564 {
7565 struct ppc_link_hash_entry *fh = eh->oh;
7566
7567 if (fh == NULL)
7568 {
7569 const char *p, *q;
7570 struct elf_link_hash_table *htab = elf_hash_table (info);
7571 char save;
7572
7573 /* We aren't supposed to use alloca in BFD because on
7574 systems which do not have alloca the version in libiberty
7575 calls xmalloc, which might cause the program to crash
7576 when it runs out of memory. This function doesn't have a
7577 return status, so there's no way to gracefully return an
7578 error. So cheat. We know that string[-1] can be safely
7579 accessed; It's either a string in an ELF string table,
7580 or allocated in an objalloc structure. */
7581
7582 p = eh->elf.root.root.string - 1;
7583 save = *p;
7584 *(char *) p = '.';
7585 fh = (struct ppc_link_hash_entry *)
7586 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7587 *(char *) p = save;
7588
7589 /* Unfortunately, if it so happens that the string we were
7590 looking for was allocated immediately before this string,
7591 then we overwrote the string terminator. That's the only
7592 reason the lookup should fail. */
7593 if (fh == NULL)
7594 {
7595 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7596 while (q >= eh->elf.root.root.string && *q == *p)
7597 --q, --p;
7598 if (q < eh->elf.root.root.string && *p == '.')
7599 fh = (struct ppc_link_hash_entry *)
7600 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7601 }
7602 if (fh != NULL)
7603 {
7604 eh->oh = fh;
7605 fh->oh = eh;
7606 }
7607 }
7608 if (fh != NULL)
7609 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7610 }
7611 }
7612
7613 static bfd_boolean
7614 get_sym_h (struct elf_link_hash_entry **hp,
7615 Elf_Internal_Sym **symp,
7616 asection **symsecp,
7617 unsigned char **tls_maskp,
7618 Elf_Internal_Sym **locsymsp,
7619 unsigned long r_symndx,
7620 bfd *ibfd)
7621 {
7622 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7623
7624 if (r_symndx >= symtab_hdr->sh_info)
7625 {
7626 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7627 struct elf_link_hash_entry *h;
7628
7629 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7630 h = elf_follow_link (h);
7631
7632 if (hp != NULL)
7633 *hp = h;
7634
7635 if (symp != NULL)
7636 *symp = NULL;
7637
7638 if (symsecp != NULL)
7639 {
7640 asection *symsec = NULL;
7641 if (h->root.type == bfd_link_hash_defined
7642 || h->root.type == bfd_link_hash_defweak)
7643 symsec = h->root.u.def.section;
7644 *symsecp = symsec;
7645 }
7646
7647 if (tls_maskp != NULL)
7648 {
7649 struct ppc_link_hash_entry *eh;
7650
7651 eh = (struct ppc_link_hash_entry *) h;
7652 *tls_maskp = &eh->tls_mask;
7653 }
7654 }
7655 else
7656 {
7657 Elf_Internal_Sym *sym;
7658 Elf_Internal_Sym *locsyms = *locsymsp;
7659
7660 if (locsyms == NULL)
7661 {
7662 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7663 if (locsyms == NULL)
7664 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7665 symtab_hdr->sh_info,
7666 0, NULL, NULL, NULL);
7667 if (locsyms == NULL)
7668 return FALSE;
7669 *locsymsp = locsyms;
7670 }
7671 sym = locsyms + r_symndx;
7672
7673 if (hp != NULL)
7674 *hp = NULL;
7675
7676 if (symp != NULL)
7677 *symp = sym;
7678
7679 if (symsecp != NULL)
7680 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7681
7682 if (tls_maskp != NULL)
7683 {
7684 struct got_entry **lgot_ents;
7685 unsigned char *tls_mask;
7686
7687 tls_mask = NULL;
7688 lgot_ents = elf_local_got_ents (ibfd);
7689 if (lgot_ents != NULL)
7690 {
7691 struct plt_entry **local_plt = (struct plt_entry **)
7692 (lgot_ents + symtab_hdr->sh_info);
7693 unsigned char *lgot_masks = (unsigned char *)
7694 (local_plt + symtab_hdr->sh_info);
7695 tls_mask = &lgot_masks[r_symndx];
7696 }
7697 *tls_maskp = tls_mask;
7698 }
7699 }
7700 return TRUE;
7701 }
7702
7703 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7704 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7705 type suitable for optimization, and 1 otherwise. */
7706
7707 static int
7708 get_tls_mask (unsigned char **tls_maskp,
7709 unsigned long *toc_symndx,
7710 bfd_vma *toc_addend,
7711 Elf_Internal_Sym **locsymsp,
7712 const Elf_Internal_Rela *rel,
7713 bfd *ibfd)
7714 {
7715 unsigned long r_symndx;
7716 int next_r;
7717 struct elf_link_hash_entry *h;
7718 Elf_Internal_Sym *sym;
7719 asection *sec;
7720 bfd_vma off;
7721
7722 r_symndx = ELF64_R_SYM (rel->r_info);
7723 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7724 return 0;
7725
7726 if ((*tls_maskp != NULL
7727 && (**tls_maskp & TLS_TLS) != 0
7728 && **tls_maskp != (TLS_TLS | TLS_MARK))
7729 || sec == NULL
7730 || ppc64_elf_section_data (sec) == NULL
7731 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7732 return 1;
7733
7734 /* Look inside a TOC section too. */
7735 if (h != NULL)
7736 {
7737 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7738 off = h->root.u.def.value;
7739 }
7740 else
7741 off = sym->st_value;
7742 off += rel->r_addend;
7743 BFD_ASSERT (off % 8 == 0);
7744 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7745 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7746 if (toc_symndx != NULL)
7747 *toc_symndx = r_symndx;
7748 if (toc_addend != NULL)
7749 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7750 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7751 return 0;
7752 if ((h == NULL || is_static_defined (h))
7753 && (next_r == -1 || next_r == -2))
7754 return 1 - next_r;
7755 return 1;
7756 }
7757
7758 /* Find (or create) an entry in the tocsave hash table. */
7759
7760 static struct tocsave_entry *
7761 tocsave_find (struct ppc_link_hash_table *htab,
7762 enum insert_option insert,
7763 Elf_Internal_Sym **local_syms,
7764 const Elf_Internal_Rela *irela,
7765 bfd *ibfd)
7766 {
7767 unsigned long r_indx;
7768 struct elf_link_hash_entry *h;
7769 Elf_Internal_Sym *sym;
7770 struct tocsave_entry ent, *p;
7771 hashval_t hash;
7772 struct tocsave_entry **slot;
7773
7774 r_indx = ELF64_R_SYM (irela->r_info);
7775 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7776 return NULL;
7777 if (ent.sec == NULL || ent.sec->output_section == NULL)
7778 {
7779 _bfd_error_handler
7780 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7781 return NULL;
7782 }
7783
7784 if (h != NULL)
7785 ent.offset = h->root.u.def.value;
7786 else
7787 ent.offset = sym->st_value;
7788 ent.offset += irela->r_addend;
7789
7790 hash = tocsave_htab_hash (&ent);
7791 slot = ((struct tocsave_entry **)
7792 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7793 if (slot == NULL)
7794 return NULL;
7795
7796 if (*slot == NULL)
7797 {
7798 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7799 if (p == NULL)
7800 return NULL;
7801 *p = ent;
7802 *slot = p;
7803 }
7804 return *slot;
7805 }
7806
7807 /* Adjust all global syms defined in opd sections. In gcc generated
7808 code for the old ABI, these will already have been done. */
7809
7810 static bfd_boolean
7811 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7812 {
7813 struct ppc_link_hash_entry *eh;
7814 asection *sym_sec;
7815 struct _opd_sec_data *opd;
7816
7817 if (h->root.type == bfd_link_hash_indirect)
7818 return TRUE;
7819
7820 if (h->root.type != bfd_link_hash_defined
7821 && h->root.type != bfd_link_hash_defweak)
7822 return TRUE;
7823
7824 eh = (struct ppc_link_hash_entry *) h;
7825 if (eh->adjust_done)
7826 return TRUE;
7827
7828 sym_sec = eh->elf.root.u.def.section;
7829 opd = get_opd_info (sym_sec);
7830 if (opd != NULL && opd->adjust != NULL)
7831 {
7832 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7833 if (adjust == -1)
7834 {
7835 /* This entry has been deleted. */
7836 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7837 if (dsec == NULL)
7838 {
7839 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7840 if (discarded_section (dsec))
7841 {
7842 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7843 break;
7844 }
7845 }
7846 eh->elf.root.u.def.value = 0;
7847 eh->elf.root.u.def.section = dsec;
7848 }
7849 else
7850 eh->elf.root.u.def.value += adjust;
7851 eh->adjust_done = 1;
7852 }
7853 return TRUE;
7854 }
7855
7856 /* Handles decrementing dynamic reloc counts for the reloc specified by
7857 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7858 have already been determined. */
7859
7860 static bfd_boolean
7861 dec_dynrel_count (bfd_vma r_info,
7862 asection *sec,
7863 struct bfd_link_info *info,
7864 Elf_Internal_Sym **local_syms,
7865 struct elf_link_hash_entry *h,
7866 Elf_Internal_Sym *sym)
7867 {
7868 enum elf_ppc64_reloc_type r_type;
7869 asection *sym_sec = NULL;
7870
7871 /* Can this reloc be dynamic? This switch, and later tests here
7872 should be kept in sync with the code in check_relocs. */
7873 r_type = ELF64_R_TYPE (r_info);
7874 switch (r_type)
7875 {
7876 default:
7877 return TRUE;
7878
7879 case R_PPC64_TPREL16:
7880 case R_PPC64_TPREL16_LO:
7881 case R_PPC64_TPREL16_HI:
7882 case R_PPC64_TPREL16_HA:
7883 case R_PPC64_TPREL16_DS:
7884 case R_PPC64_TPREL16_LO_DS:
7885 case R_PPC64_TPREL16_HIGH:
7886 case R_PPC64_TPREL16_HIGHA:
7887 case R_PPC64_TPREL16_HIGHER:
7888 case R_PPC64_TPREL16_HIGHERA:
7889 case R_PPC64_TPREL16_HIGHEST:
7890 case R_PPC64_TPREL16_HIGHESTA:
7891 case R_PPC64_TPREL64:
7892 case R_PPC64_DTPMOD64:
7893 case R_PPC64_DTPREL64:
7894 case R_PPC64_ADDR64:
7895 case R_PPC64_REL30:
7896 case R_PPC64_REL32:
7897 case R_PPC64_REL64:
7898 case R_PPC64_ADDR14:
7899 case R_PPC64_ADDR14_BRNTAKEN:
7900 case R_PPC64_ADDR14_BRTAKEN:
7901 case R_PPC64_ADDR16:
7902 case R_PPC64_ADDR16_DS:
7903 case R_PPC64_ADDR16_HA:
7904 case R_PPC64_ADDR16_HI:
7905 case R_PPC64_ADDR16_HIGH:
7906 case R_PPC64_ADDR16_HIGHA:
7907 case R_PPC64_ADDR16_HIGHER:
7908 case R_PPC64_ADDR16_HIGHERA:
7909 case R_PPC64_ADDR16_HIGHEST:
7910 case R_PPC64_ADDR16_HIGHESTA:
7911 case R_PPC64_ADDR16_LO:
7912 case R_PPC64_ADDR16_LO_DS:
7913 case R_PPC64_ADDR24:
7914 case R_PPC64_ADDR32:
7915 case R_PPC64_UADDR16:
7916 case R_PPC64_UADDR32:
7917 case R_PPC64_UADDR64:
7918 case R_PPC64_TOC:
7919 break;
7920 }
7921
7922 if (local_syms != NULL)
7923 {
7924 unsigned long r_symndx;
7925 bfd *ibfd = sec->owner;
7926
7927 r_symndx = ELF64_R_SYM (r_info);
7928 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7929 return FALSE;
7930 }
7931
7932 if ((bfd_link_pic (info)
7933 && (must_be_dyn_reloc (info, r_type)
7934 || (h != NULL
7935 && (!SYMBOLIC_BIND (info, h)
7936 || h->root.type == bfd_link_hash_defweak
7937 || !h->def_regular))))
7938 || (ELIMINATE_COPY_RELOCS
7939 && !bfd_link_pic (info)
7940 && h != NULL
7941 && (h->root.type == bfd_link_hash_defweak
7942 || !h->def_regular)))
7943 ;
7944 else
7945 return TRUE;
7946
7947 if (h != NULL)
7948 {
7949 struct elf_dyn_relocs *p;
7950 struct elf_dyn_relocs **pp;
7951 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7952
7953 /* elf_gc_sweep may have already removed all dyn relocs associated
7954 with local syms for a given section. Also, symbol flags are
7955 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7956 report a dynreloc miscount. */
7957 if (*pp == NULL && info->gc_sections)
7958 return TRUE;
7959
7960 while ((p = *pp) != NULL)
7961 {
7962 if (p->sec == sec)
7963 {
7964 if (!must_be_dyn_reloc (info, r_type))
7965 p->pc_count -= 1;
7966 p->count -= 1;
7967 if (p->count == 0)
7968 *pp = p->next;
7969 return TRUE;
7970 }
7971 pp = &p->next;
7972 }
7973 }
7974 else
7975 {
7976 struct ppc_dyn_relocs *p;
7977 struct ppc_dyn_relocs **pp;
7978 void *vpp;
7979 bfd_boolean is_ifunc;
7980
7981 if (local_syms == NULL)
7982 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7983 if (sym_sec == NULL)
7984 sym_sec = sec;
7985
7986 vpp = &elf_section_data (sym_sec)->local_dynrel;
7987 pp = (struct ppc_dyn_relocs **) vpp;
7988
7989 if (*pp == NULL && info->gc_sections)
7990 return TRUE;
7991
7992 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7993 while ((p = *pp) != NULL)
7994 {
7995 if (p->sec == sec && p->ifunc == is_ifunc)
7996 {
7997 p->count -= 1;
7998 if (p->count == 0)
7999 *pp = p->next;
8000 return TRUE;
8001 }
8002 pp = &p->next;
8003 }
8004 }
8005
8006 /* xgettext:c-format */
8007 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
8008 sec->owner, sec);
8009 bfd_set_error (bfd_error_bad_value);
8010 return FALSE;
8011 }
8012
8013 /* Remove unused Official Procedure Descriptor entries. Currently we
8014 only remove those associated with functions in discarded link-once
8015 sections, or weakly defined functions that have been overridden. It
8016 would be possible to remove many more entries for statically linked
8017 applications. */
8018
8019 bfd_boolean
8020 ppc64_elf_edit_opd (struct bfd_link_info *info)
8021 {
8022 bfd *ibfd;
8023 bfd_boolean some_edited = FALSE;
8024 asection *need_pad = NULL;
8025 struct ppc_link_hash_table *htab;
8026
8027 htab = ppc_hash_table (info);
8028 if (htab == NULL)
8029 return FALSE;
8030
8031 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8032 {
8033 asection *sec;
8034 Elf_Internal_Rela *relstart, *rel, *relend;
8035 Elf_Internal_Shdr *symtab_hdr;
8036 Elf_Internal_Sym *local_syms;
8037 struct _opd_sec_data *opd;
8038 bfd_boolean need_edit, add_aux_fields, broken;
8039 bfd_size_type cnt_16b = 0;
8040
8041 if (!is_ppc64_elf (ibfd))
8042 continue;
8043
8044 sec = bfd_get_section_by_name (ibfd, ".opd");
8045 if (sec == NULL || sec->size == 0)
8046 continue;
8047
8048 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
8049 continue;
8050
8051 if (sec->output_section == bfd_abs_section_ptr)
8052 continue;
8053
8054 /* Look through the section relocs. */
8055 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
8056 continue;
8057
8058 local_syms = NULL;
8059 symtab_hdr = &elf_symtab_hdr (ibfd);
8060
8061 /* Read the relocations. */
8062 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8063 info->keep_memory);
8064 if (relstart == NULL)
8065 return FALSE;
8066
8067 /* First run through the relocs to check they are sane, and to
8068 determine whether we need to edit this opd section. */
8069 need_edit = FALSE;
8070 broken = FALSE;
8071 need_pad = sec;
8072 relend = relstart + sec->reloc_count;
8073 for (rel = relstart; rel < relend; )
8074 {
8075 enum elf_ppc64_reloc_type r_type;
8076 unsigned long r_symndx;
8077 asection *sym_sec;
8078 struct elf_link_hash_entry *h;
8079 Elf_Internal_Sym *sym;
8080 bfd_vma offset;
8081
8082 /* .opd contains an array of 16 or 24 byte entries. We're
8083 only interested in the reloc pointing to a function entry
8084 point. */
8085 offset = rel->r_offset;
8086 if (rel + 1 == relend
8087 || rel[1].r_offset != offset + 8)
8088 {
8089 /* If someone messes with .opd alignment then after a
8090 "ld -r" we might have padding in the middle of .opd.
8091 Also, there's nothing to prevent someone putting
8092 something silly in .opd with the assembler. No .opd
8093 optimization for them! */
8094 broken_opd:
8095 _bfd_error_handler
8096 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
8097 broken = TRUE;
8098 break;
8099 }
8100
8101 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8102 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8103 {
8104 _bfd_error_handler
8105 /* xgettext:c-format */
8106 (_("%pB: unexpected reloc type %u in .opd section"),
8107 ibfd, r_type);
8108 broken = TRUE;
8109 break;
8110 }
8111
8112 r_symndx = ELF64_R_SYM (rel->r_info);
8113 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8114 r_symndx, ibfd))
8115 goto error_ret;
8116
8117 if (sym_sec == NULL || sym_sec->owner == NULL)
8118 {
8119 const char *sym_name;
8120 if (h != NULL)
8121 sym_name = h->root.root.string;
8122 else
8123 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8124 sym_sec);
8125
8126 _bfd_error_handler
8127 /* xgettext:c-format */
8128 (_("%pB: undefined sym `%s' in .opd section"),
8129 ibfd, sym_name);
8130 broken = TRUE;
8131 break;
8132 }
8133
8134 /* opd entries are always for functions defined in the
8135 current input bfd. If the symbol isn't defined in the
8136 input bfd, then we won't be using the function in this
8137 bfd; It must be defined in a linkonce section in another
8138 bfd, or is weak. It's also possible that we are
8139 discarding the function due to a linker script /DISCARD/,
8140 which we test for via the output_section. */
8141 if (sym_sec->owner != ibfd
8142 || sym_sec->output_section == bfd_abs_section_ptr)
8143 need_edit = TRUE;
8144
8145 rel += 2;
8146 if (rel + 1 == relend
8147 || (rel + 2 < relend
8148 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8149 ++rel;
8150
8151 if (rel == relend)
8152 {
8153 if (sec->size == offset + 24)
8154 {
8155 need_pad = NULL;
8156 break;
8157 }
8158 if (sec->size == offset + 16)
8159 {
8160 cnt_16b++;
8161 break;
8162 }
8163 goto broken_opd;
8164 }
8165 else if (rel + 1 < relend
8166 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8167 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8168 {
8169 if (rel[0].r_offset == offset + 16)
8170 cnt_16b++;
8171 else if (rel[0].r_offset != offset + 24)
8172 goto broken_opd;
8173 }
8174 else
8175 goto broken_opd;
8176 }
8177
8178 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8179
8180 if (!broken && (need_edit || add_aux_fields))
8181 {
8182 Elf_Internal_Rela *write_rel;
8183 Elf_Internal_Shdr *rel_hdr;
8184 bfd_byte *rptr, *wptr;
8185 bfd_byte *new_contents;
8186 bfd_size_type amt;
8187
8188 new_contents = NULL;
8189 amt = OPD_NDX (sec->size) * sizeof (long);
8190 opd = &ppc64_elf_section_data (sec)->u.opd;
8191 opd->adjust = bfd_zalloc (sec->owner, amt);
8192 if (opd->adjust == NULL)
8193 return FALSE;
8194
8195 /* This seems a waste of time as input .opd sections are all
8196 zeros as generated by gcc, but I suppose there's no reason
8197 this will always be so. We might start putting something in
8198 the third word of .opd entries. */
8199 if ((sec->flags & SEC_IN_MEMORY) == 0)
8200 {
8201 bfd_byte *loc;
8202 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8203 {
8204 if (loc != NULL)
8205 free (loc);
8206 error_ret:
8207 if (local_syms != NULL
8208 && symtab_hdr->contents != (unsigned char *) local_syms)
8209 free (local_syms);
8210 if (elf_section_data (sec)->relocs != relstart)
8211 free (relstart);
8212 return FALSE;
8213 }
8214 sec->contents = loc;
8215 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8216 }
8217
8218 elf_section_data (sec)->relocs = relstart;
8219
8220 new_contents = sec->contents;
8221 if (add_aux_fields)
8222 {
8223 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8224 if (new_contents == NULL)
8225 return FALSE;
8226 need_pad = NULL;
8227 }
8228 wptr = new_contents;
8229 rptr = sec->contents;
8230 write_rel = relstart;
8231 for (rel = relstart; rel < relend; )
8232 {
8233 unsigned long r_symndx;
8234 asection *sym_sec;
8235 struct elf_link_hash_entry *h;
8236 struct ppc_link_hash_entry *fdh = NULL;
8237 Elf_Internal_Sym *sym;
8238 long opd_ent_size;
8239 Elf_Internal_Rela *next_rel;
8240 bfd_boolean skip;
8241
8242 r_symndx = ELF64_R_SYM (rel->r_info);
8243 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8244 r_symndx, ibfd))
8245 goto error_ret;
8246
8247 next_rel = rel + 2;
8248 if (next_rel + 1 == relend
8249 || (next_rel + 2 < relend
8250 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8251 ++next_rel;
8252
8253 /* See if the .opd entry is full 24 byte or
8254 16 byte (with fd_aux entry overlapped with next
8255 fd_func). */
8256 opd_ent_size = 24;
8257 if (next_rel == relend)
8258 {
8259 if (sec->size == rel->r_offset + 16)
8260 opd_ent_size = 16;
8261 }
8262 else if (next_rel->r_offset == rel->r_offset + 16)
8263 opd_ent_size = 16;
8264
8265 if (h != NULL
8266 && h->root.root.string[0] == '.')
8267 {
8268 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8269 if (fdh != NULL)
8270 {
8271 fdh = ppc_follow_link (fdh);
8272 if (fdh->elf.root.type != bfd_link_hash_defined
8273 && fdh->elf.root.type != bfd_link_hash_defweak)
8274 fdh = NULL;
8275 }
8276 }
8277
8278 skip = (sym_sec->owner != ibfd
8279 || sym_sec->output_section == bfd_abs_section_ptr);
8280 if (skip)
8281 {
8282 if (fdh != NULL && sym_sec->owner == ibfd)
8283 {
8284 /* Arrange for the function descriptor sym
8285 to be dropped. */
8286 fdh->elf.root.u.def.value = 0;
8287 fdh->elf.root.u.def.section = sym_sec;
8288 }
8289 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8290
8291 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8292 rel = next_rel;
8293 else
8294 while (1)
8295 {
8296 if (!dec_dynrel_count (rel->r_info, sec, info,
8297 NULL, h, sym))
8298 goto error_ret;
8299
8300 if (++rel == next_rel)
8301 break;
8302
8303 r_symndx = ELF64_R_SYM (rel->r_info);
8304 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8305 r_symndx, ibfd))
8306 goto error_ret;
8307 }
8308 }
8309 else
8310 {
8311 /* We'll be keeping this opd entry. */
8312 long adjust;
8313
8314 if (fdh != NULL)
8315 {
8316 /* Redefine the function descriptor symbol to
8317 this location in the opd section. It is
8318 necessary to update the value here rather
8319 than using an array of adjustments as we do
8320 for local symbols, because various places
8321 in the generic ELF code use the value
8322 stored in u.def.value. */
8323 fdh->elf.root.u.def.value = wptr - new_contents;
8324 fdh->adjust_done = 1;
8325 }
8326
8327 /* Local syms are a bit tricky. We could
8328 tweak them as they can be cached, but
8329 we'd need to look through the local syms
8330 for the function descriptor sym which we
8331 don't have at the moment. So keep an
8332 array of adjustments. */
8333 adjust = (wptr - new_contents) - (rptr - sec->contents);
8334 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8335
8336 if (wptr != rptr)
8337 memcpy (wptr, rptr, opd_ent_size);
8338 wptr += opd_ent_size;
8339 if (add_aux_fields && opd_ent_size == 16)
8340 {
8341 memset (wptr, '\0', 8);
8342 wptr += 8;
8343 }
8344
8345 /* We need to adjust any reloc offsets to point to the
8346 new opd entries. */
8347 for ( ; rel != next_rel; ++rel)
8348 {
8349 rel->r_offset += adjust;
8350 if (write_rel != rel)
8351 memcpy (write_rel, rel, sizeof (*rel));
8352 ++write_rel;
8353 }
8354 }
8355
8356 rptr += opd_ent_size;
8357 }
8358
8359 sec->size = wptr - new_contents;
8360 sec->reloc_count = write_rel - relstart;
8361 if (add_aux_fields)
8362 {
8363 free (sec->contents);
8364 sec->contents = new_contents;
8365 }
8366
8367 /* Fudge the header size too, as this is used later in
8368 elf_bfd_final_link if we are emitting relocs. */
8369 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8370 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8371 some_edited = TRUE;
8372 }
8373 else if (elf_section_data (sec)->relocs != relstart)
8374 free (relstart);
8375
8376 if (local_syms != NULL
8377 && symtab_hdr->contents != (unsigned char *) local_syms)
8378 {
8379 if (!info->keep_memory)
8380 free (local_syms);
8381 else
8382 symtab_hdr->contents = (unsigned char *) local_syms;
8383 }
8384 }
8385
8386 if (some_edited)
8387 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8388
8389 /* If we are doing a final link and the last .opd entry is just 16 byte
8390 long, add a 8 byte padding after it. */
8391 if (need_pad != NULL && !bfd_link_relocatable (info))
8392 {
8393 bfd_byte *p;
8394
8395 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8396 {
8397 BFD_ASSERT (need_pad->size > 0);
8398
8399 p = bfd_malloc (need_pad->size + 8);
8400 if (p == NULL)
8401 return FALSE;
8402
8403 if (!bfd_get_section_contents (need_pad->owner, need_pad,
8404 p, 0, need_pad->size))
8405 return FALSE;
8406
8407 need_pad->contents = p;
8408 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8409 }
8410 else
8411 {
8412 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8413 if (p == NULL)
8414 return FALSE;
8415
8416 need_pad->contents = p;
8417 }
8418
8419 memset (need_pad->contents + need_pad->size, 0, 8);
8420 need_pad->size += 8;
8421 }
8422
8423 return TRUE;
8424 }
8425
8426 /* Analyze inline PLT call relocations to see whether calls to locally
8427 defined functions can be converted to direct calls. */
8428
8429 bfd_boolean
8430 ppc64_elf_inline_plt (struct bfd_link_info *info)
8431 {
8432 struct ppc_link_hash_table *htab;
8433 bfd *ibfd;
8434 asection *sec;
8435 bfd_vma low_vma, high_vma, limit;
8436
8437 htab = ppc_hash_table (info);
8438 if (htab == NULL)
8439 return FALSE;
8440
8441 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
8442 reduced somewhat to cater for possible stubs that might be added
8443 between the call and its destination. */
8444 if (htab->params->group_size < 0)
8445 {
8446 limit = -htab->params->group_size;
8447 if (limit == 1)
8448 limit = 0x1e00000;
8449 }
8450 else
8451 {
8452 limit = htab->params->group_size;
8453 if (limit == 1)
8454 limit = 0x1c00000;
8455 }
8456
8457 low_vma = -1;
8458 high_vma = 0;
8459 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8460 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8461 {
8462 if (low_vma > sec->vma)
8463 low_vma = sec->vma;
8464 if (high_vma < sec->vma + sec->size)
8465 high_vma = sec->vma + sec->size;
8466 }
8467
8468 /* If a "bl" can reach anywhere in local code sections, then we can
8469 convert all inline PLT sequences to direct calls when the symbol
8470 is local. */
8471 if (high_vma - low_vma < limit)
8472 {
8473 htab->can_convert_all_inline_plt = 1;
8474 return TRUE;
8475 }
8476
8477 /* Otherwise, go looking through relocs for cases where a direct
8478 call won't reach. Mark the symbol on any such reloc to disable
8479 the optimization and keep the PLT entry as it seems likely that
8480 this will be better than creating trampolines. Note that this
8481 will disable the optimization for all inline PLT calls to a
8482 particular symbol, not just those that won't reach. The
8483 difficulty in doing a more precise optimization is that the
8484 linker needs to make a decision depending on whether a
8485 particular R_PPC64_PLTCALL insn can be turned into a direct
8486 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8487 the sequence, and there is nothing that ties those relocs
8488 together except their symbol. */
8489
8490 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8491 {
8492 Elf_Internal_Shdr *symtab_hdr;
8493 Elf_Internal_Sym *local_syms;
8494
8495 if (!is_ppc64_elf (ibfd))
8496 continue;
8497
8498 local_syms = NULL;
8499 symtab_hdr = &elf_symtab_hdr (ibfd);
8500
8501 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8502 if (ppc64_elf_section_data (sec)->has_pltcall
8503 && !bfd_is_abs_section (sec->output_section))
8504 {
8505 Elf_Internal_Rela *relstart, *rel, *relend;
8506
8507 /* Read the relocations. */
8508 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8509 info->keep_memory);
8510 if (relstart == NULL)
8511 return FALSE;
8512
8513 relend = relstart + sec->reloc_count;
8514 for (rel = relstart; rel < relend; )
8515 {
8516 enum elf_ppc64_reloc_type r_type;
8517 unsigned long r_symndx;
8518 asection *sym_sec;
8519 struct elf_link_hash_entry *h;
8520 Elf_Internal_Sym *sym;
8521 unsigned char *tls_maskp;
8522
8523 r_type = ELF64_R_TYPE (rel->r_info);
8524 if (r_type != R_PPC64_PLTCALL)
8525 continue;
8526
8527 r_symndx = ELF64_R_SYM (rel->r_info);
8528 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8529 r_symndx, ibfd))
8530 {
8531 if (elf_section_data (sec)->relocs != relstart)
8532 free (relstart);
8533 if (local_syms != NULL
8534 && symtab_hdr->contents != (bfd_byte *) local_syms)
8535 free (local_syms);
8536 return FALSE;
8537 }
8538
8539 if (sym_sec != NULL && sym_sec->output_section != NULL)
8540 {
8541 bfd_vma from, to;
8542 if (h != NULL)
8543 to = h->root.u.def.value;
8544 else
8545 to = sym->st_value;
8546 to += (rel->r_addend
8547 + sym_sec->output_offset
8548 + sym_sec->output_section->vma);
8549 from = (rel->r_offset
8550 + sec->output_offset
8551 + sec->output_section->vma);
8552 if (to - from + limit < 2 * limit)
8553 *tls_maskp &= ~PLT_KEEP;
8554 }
8555 }
8556 if (elf_section_data (sec)->relocs != relstart)
8557 free (relstart);
8558 }
8559
8560 if (local_syms != NULL
8561 && symtab_hdr->contents != (unsigned char *) local_syms)
8562 {
8563 if (!info->keep_memory)
8564 free (local_syms);
8565 else
8566 symtab_hdr->contents = (unsigned char *) local_syms;
8567 }
8568 }
8569
8570 return TRUE;
8571 }
8572
8573 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8574
8575 asection *
8576 ppc64_elf_tls_setup (struct bfd_link_info *info)
8577 {
8578 struct ppc_link_hash_table *htab;
8579
8580 htab = ppc_hash_table (info);
8581 if (htab == NULL)
8582 return NULL;
8583
8584 if (abiversion (info->output_bfd) == 1)
8585 htab->opd_abi = 1;
8586
8587 if (htab->params->no_multi_toc)
8588 htab->do_multi_toc = 0;
8589 else if (!htab->do_multi_toc)
8590 htab->params->no_multi_toc = 1;
8591
8592 /* Default to --no-plt-localentry, as this option can cause problems
8593 with symbol interposition. For example, glibc libpthread.so and
8594 libc.so duplicate many pthread symbols, with a fallback
8595 implementation in libc.so. In some cases the fallback does more
8596 work than the pthread implementation. __pthread_condattr_destroy
8597 is one such symbol: the libpthread.so implementation is
8598 localentry:0 while the libc.so implementation is localentry:8.
8599 An app that "cleverly" uses dlopen to only load necessary
8600 libraries at runtime may omit loading libpthread.so when not
8601 running multi-threaded, which then results in the libc.so
8602 fallback symbols being used and ld.so complaining. Now there
8603 are workarounds in ld (see non_zero_localentry) to detect the
8604 pthread situation, but that may not be the only case where
8605 --plt-localentry can cause trouble. */
8606 if (htab->params->plt_localentry0 < 0)
8607 htab->params->plt_localentry0 = 0;
8608 if (htab->params->plt_localentry0
8609 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8610 FALSE, FALSE, FALSE) == NULL)
8611 _bfd_error_handler
8612 (_("warning: --plt-localentry is especially dangerous without "
8613 "ld.so support to detect ABI violations"));
8614
8615 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8616 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8617 FALSE, FALSE, TRUE));
8618 /* Move dynamic linking info to the function descriptor sym. */
8619 if (htab->tls_get_addr != NULL)
8620 func_desc_adjust (&htab->tls_get_addr->elf, info);
8621 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8622 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8623 FALSE, FALSE, TRUE));
8624 if (htab->params->tls_get_addr_opt)
8625 {
8626 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8627
8628 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8629 FALSE, FALSE, TRUE);
8630 if (opt != NULL)
8631 func_desc_adjust (opt, info);
8632 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8633 FALSE, FALSE, TRUE);
8634 if (opt_fd != NULL
8635 && (opt_fd->root.type == bfd_link_hash_defined
8636 || opt_fd->root.type == bfd_link_hash_defweak))
8637 {
8638 /* If glibc supports an optimized __tls_get_addr call stub,
8639 signalled by the presence of __tls_get_addr_opt, and we'll
8640 be calling __tls_get_addr via a plt call stub, then
8641 make __tls_get_addr point to __tls_get_addr_opt. */
8642 tga_fd = &htab->tls_get_addr_fd->elf;
8643 if (htab->elf.dynamic_sections_created
8644 && tga_fd != NULL
8645 && (tga_fd->type == STT_FUNC
8646 || tga_fd->needs_plt)
8647 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8648 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8649 {
8650 struct plt_entry *ent;
8651
8652 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8653 if (ent->plt.refcount > 0)
8654 break;
8655 if (ent != NULL)
8656 {
8657 tga_fd->root.type = bfd_link_hash_indirect;
8658 tga_fd->root.u.i.link = &opt_fd->root;
8659 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8660 opt_fd->mark = 1;
8661 if (opt_fd->dynindx != -1)
8662 {
8663 /* Use __tls_get_addr_opt in dynamic relocations. */
8664 opt_fd->dynindx = -1;
8665 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8666 opt_fd->dynstr_index);
8667 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8668 return NULL;
8669 }
8670 htab->tls_get_addr_fd
8671 = (struct ppc_link_hash_entry *) opt_fd;
8672 tga = &htab->tls_get_addr->elf;
8673 if (opt != NULL && tga != NULL)
8674 {
8675 tga->root.type = bfd_link_hash_indirect;
8676 tga->root.u.i.link = &opt->root;
8677 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8678 opt->mark = 1;
8679 _bfd_elf_link_hash_hide_symbol (info, opt,
8680 tga->forced_local);
8681 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8682 }
8683 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8684 htab->tls_get_addr_fd->is_func_descriptor = 1;
8685 if (htab->tls_get_addr != NULL)
8686 {
8687 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8688 htab->tls_get_addr->is_func = 1;
8689 }
8690 }
8691 }
8692 }
8693 else if (htab->params->tls_get_addr_opt < 0)
8694 htab->params->tls_get_addr_opt = 0;
8695 }
8696 return _bfd_elf_tls_setup (info->output_bfd, info);
8697 }
8698
8699 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8700 HASH1 or HASH2. */
8701
8702 static bfd_boolean
8703 branch_reloc_hash_match (const bfd *ibfd,
8704 const Elf_Internal_Rela *rel,
8705 const struct ppc_link_hash_entry *hash1,
8706 const struct ppc_link_hash_entry *hash2)
8707 {
8708 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8709 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8710 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8711
8712 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8713 {
8714 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8715 struct elf_link_hash_entry *h;
8716
8717 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8718 h = elf_follow_link (h);
8719 if (h == &hash1->elf || h == &hash2->elf)
8720 return TRUE;
8721 }
8722 return FALSE;
8723 }
8724
8725 /* Run through all the TLS relocs looking for optimization
8726 opportunities. The linker has been hacked (see ppc64elf.em) to do
8727 a preliminary section layout so that we know the TLS segment
8728 offsets. We can't optimize earlier because some optimizations need
8729 to know the tp offset, and we need to optimize before allocating
8730 dynamic relocations. */
8731
8732 bfd_boolean
8733 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8734 {
8735 bfd *ibfd;
8736 asection *sec;
8737 struct ppc_link_hash_table *htab;
8738 unsigned char *toc_ref;
8739 int pass;
8740
8741 if (!bfd_link_executable (info))
8742 return TRUE;
8743
8744 htab = ppc_hash_table (info);
8745 if (htab == NULL)
8746 return FALSE;
8747
8748 /* Make two passes over the relocs. On the first pass, mark toc
8749 entries involved with tls relocs, and check that tls relocs
8750 involved in setting up a tls_get_addr call are indeed followed by
8751 such a call. If they are not, we can't do any tls optimization.
8752 On the second pass twiddle tls_mask flags to notify
8753 relocate_section that optimization can be done, and adjust got
8754 and plt refcounts. */
8755 toc_ref = NULL;
8756 for (pass = 0; pass < 2; ++pass)
8757 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8758 {
8759 Elf_Internal_Sym *locsyms = NULL;
8760 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8761
8762 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8763 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8764 {
8765 Elf_Internal_Rela *relstart, *rel, *relend;
8766 bfd_boolean found_tls_get_addr_arg = 0;
8767
8768 /* Read the relocations. */
8769 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8770 info->keep_memory);
8771 if (relstart == NULL)
8772 {
8773 free (toc_ref);
8774 return FALSE;
8775 }
8776
8777 relend = relstart + sec->reloc_count;
8778 for (rel = relstart; rel < relend; rel++)
8779 {
8780 enum elf_ppc64_reloc_type r_type;
8781 unsigned long r_symndx;
8782 struct elf_link_hash_entry *h;
8783 Elf_Internal_Sym *sym;
8784 asection *sym_sec;
8785 unsigned char *tls_mask;
8786 unsigned char tls_set, tls_clear, tls_type = 0;
8787 bfd_vma value;
8788 bfd_boolean ok_tprel, is_local;
8789 long toc_ref_index = 0;
8790 int expecting_tls_get_addr = 0;
8791 bfd_boolean ret = FALSE;
8792
8793 r_symndx = ELF64_R_SYM (rel->r_info);
8794 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8795 r_symndx, ibfd))
8796 {
8797 err_free_rel:
8798 if (elf_section_data (sec)->relocs != relstart)
8799 free (relstart);
8800 if (toc_ref != NULL)
8801 free (toc_ref);
8802 if (locsyms != NULL
8803 && (elf_symtab_hdr (ibfd).contents
8804 != (unsigned char *) locsyms))
8805 free (locsyms);
8806 return ret;
8807 }
8808
8809 if (h != NULL)
8810 {
8811 if (h->root.type == bfd_link_hash_defined
8812 || h->root.type == bfd_link_hash_defweak)
8813 value = h->root.u.def.value;
8814 else if (h->root.type == bfd_link_hash_undefweak)
8815 value = 0;
8816 else
8817 {
8818 found_tls_get_addr_arg = 0;
8819 continue;
8820 }
8821 }
8822 else
8823 /* Symbols referenced by TLS relocs must be of type
8824 STT_TLS. So no need for .opd local sym adjust. */
8825 value = sym->st_value;
8826
8827 ok_tprel = FALSE;
8828 is_local = FALSE;
8829 if (h == NULL
8830 || !h->def_dynamic)
8831 {
8832 is_local = TRUE;
8833 if (h != NULL
8834 && h->root.type == bfd_link_hash_undefweak)
8835 ok_tprel = TRUE;
8836 else if (sym_sec != NULL
8837 && sym_sec->output_section != NULL)
8838 {
8839 value += sym_sec->output_offset;
8840 value += sym_sec->output_section->vma;
8841 value -= htab->elf.tls_sec->vma;
8842 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8843 < (bfd_vma) 1 << 32);
8844 }
8845 }
8846
8847 r_type = ELF64_R_TYPE (rel->r_info);
8848 /* If this section has old-style __tls_get_addr calls
8849 without marker relocs, then check that each
8850 __tls_get_addr call reloc is preceded by a reloc
8851 that conceivably belongs to the __tls_get_addr arg
8852 setup insn. If we don't find matching arg setup
8853 relocs, don't do any tls optimization. */
8854 if (pass == 0
8855 && sec->has_tls_get_addr_call
8856 && h != NULL
8857 && (h == &htab->tls_get_addr->elf
8858 || h == &htab->tls_get_addr_fd->elf)
8859 && !found_tls_get_addr_arg
8860 && is_branch_reloc (r_type))
8861 {
8862 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8863 "TLS optimization disabled\n"),
8864 ibfd, sec, rel->r_offset);
8865 ret = TRUE;
8866 goto err_free_rel;
8867 }
8868
8869 found_tls_get_addr_arg = 0;
8870 switch (r_type)
8871 {
8872 case R_PPC64_GOT_TLSLD16:
8873 case R_PPC64_GOT_TLSLD16_LO:
8874 expecting_tls_get_addr = 1;
8875 found_tls_get_addr_arg = 1;
8876 /* Fall through. */
8877
8878 case R_PPC64_GOT_TLSLD16_HI:
8879 case R_PPC64_GOT_TLSLD16_HA:
8880 /* These relocs should never be against a symbol
8881 defined in a shared lib. Leave them alone if
8882 that turns out to be the case. */
8883 if (!is_local)
8884 continue;
8885
8886 /* LD -> LE */
8887 tls_set = 0;
8888 tls_clear = TLS_LD;
8889 tls_type = TLS_TLS | TLS_LD;
8890 break;
8891
8892 case R_PPC64_GOT_TLSGD16:
8893 case R_PPC64_GOT_TLSGD16_LO:
8894 expecting_tls_get_addr = 1;
8895 found_tls_get_addr_arg = 1;
8896 /* Fall through. */
8897
8898 case R_PPC64_GOT_TLSGD16_HI:
8899 case R_PPC64_GOT_TLSGD16_HA:
8900 if (ok_tprel)
8901 /* GD -> LE */
8902 tls_set = 0;
8903 else
8904 /* GD -> IE */
8905 tls_set = TLS_TLS | TLS_TPRELGD;
8906 tls_clear = TLS_GD;
8907 tls_type = TLS_TLS | TLS_GD;
8908 break;
8909
8910 case R_PPC64_GOT_TPREL16_DS:
8911 case R_PPC64_GOT_TPREL16_LO_DS:
8912 case R_PPC64_GOT_TPREL16_HI:
8913 case R_PPC64_GOT_TPREL16_HA:
8914 if (ok_tprel)
8915 {
8916 /* IE -> LE */
8917 tls_set = 0;
8918 tls_clear = TLS_TPREL;
8919 tls_type = TLS_TLS | TLS_TPREL;
8920 break;
8921 }
8922 continue;
8923
8924 case R_PPC64_TLSGD:
8925 case R_PPC64_TLSLD:
8926 if (rel + 1 < relend
8927 && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8928 {
8929 if (pass != 0
8930 && (ELF64_R_TYPE (rel[1].r_info)
8931 != R_PPC64_PLTSEQ))
8932 {
8933 r_symndx = ELF64_R_SYM (rel[1].r_info);
8934 if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8935 r_symndx, ibfd))
8936 goto err_free_rel;
8937 if (h != NULL)
8938 {
8939 struct plt_entry *ent = NULL;
8940
8941 for (ent = h->plt.plist;
8942 ent != NULL;
8943 ent = ent->next)
8944 if (ent->addend == rel[1].r_addend)
8945 break;
8946
8947 if (ent != NULL
8948 && ent->plt.refcount > 0)
8949 ent->plt.refcount -= 1;
8950 }
8951 }
8952 continue;
8953 }
8954 found_tls_get_addr_arg = 1;
8955 /* Fall through. */
8956
8957 case R_PPC64_TLS:
8958 case R_PPC64_TOC16:
8959 case R_PPC64_TOC16_LO:
8960 if (sym_sec == NULL || sym_sec != toc)
8961 continue;
8962
8963 /* Mark this toc entry as referenced by a TLS
8964 code sequence. We can do that now in the
8965 case of R_PPC64_TLS, and after checking for
8966 tls_get_addr for the TOC16 relocs. */
8967 if (toc_ref == NULL)
8968 toc_ref
8969 = bfd_zmalloc (toc->output_section->rawsize / 8);
8970 if (toc_ref == NULL)
8971 goto err_free_rel;
8972
8973 if (h != NULL)
8974 value = h->root.u.def.value;
8975 else
8976 value = sym->st_value;
8977 value += rel->r_addend;
8978 if (value % 8 != 0)
8979 continue;
8980 BFD_ASSERT (value < toc->size
8981 && toc->output_offset % 8 == 0);
8982 toc_ref_index = (value + toc->output_offset) / 8;
8983 if (r_type == R_PPC64_TLS
8984 || r_type == R_PPC64_TLSGD
8985 || r_type == R_PPC64_TLSLD)
8986 {
8987 toc_ref[toc_ref_index] = 1;
8988 continue;
8989 }
8990
8991 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8992 continue;
8993
8994 tls_set = 0;
8995 tls_clear = 0;
8996 expecting_tls_get_addr = 2;
8997 break;
8998
8999 case R_PPC64_TPREL64:
9000 if (pass == 0
9001 || sec != toc
9002 || toc_ref == NULL
9003 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
9004 continue;
9005 if (ok_tprel)
9006 {
9007 /* IE -> LE */
9008 tls_set = TLS_EXPLICIT;
9009 tls_clear = TLS_TPREL;
9010 break;
9011 }
9012 continue;
9013
9014 case R_PPC64_DTPMOD64:
9015 if (pass == 0
9016 || sec != toc
9017 || toc_ref == NULL
9018 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
9019 continue;
9020 if (rel + 1 < relend
9021 && (rel[1].r_info
9022 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
9023 && rel[1].r_offset == rel->r_offset + 8)
9024 {
9025 if (ok_tprel)
9026 /* GD -> LE */
9027 tls_set = TLS_EXPLICIT | TLS_GD;
9028 else
9029 /* GD -> IE */
9030 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
9031 tls_clear = TLS_GD;
9032 }
9033 else
9034 {
9035 if (!is_local)
9036 continue;
9037
9038 /* LD -> LE */
9039 tls_set = TLS_EXPLICIT;
9040 tls_clear = TLS_LD;
9041 }
9042 break;
9043
9044 default:
9045 continue;
9046 }
9047
9048 if (pass == 0)
9049 {
9050 if (!expecting_tls_get_addr
9051 || !sec->has_tls_get_addr_call)
9052 continue;
9053
9054 if (rel + 1 < relend
9055 && branch_reloc_hash_match (ibfd, rel + 1,
9056 htab->tls_get_addr,
9057 htab->tls_get_addr_fd))
9058 {
9059 if (expecting_tls_get_addr == 2)
9060 {
9061 /* Check for toc tls entries. */
9062 unsigned char *toc_tls;
9063 int retval;
9064
9065 retval = get_tls_mask (&toc_tls, NULL, NULL,
9066 &locsyms,
9067 rel, ibfd);
9068 if (retval == 0)
9069 goto err_free_rel;
9070 if (toc_tls != NULL)
9071 {
9072 if ((*toc_tls & TLS_TLS) != 0
9073 && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
9074 found_tls_get_addr_arg = 1;
9075 if (retval > 1)
9076 toc_ref[toc_ref_index] = 1;
9077 }
9078 }
9079 continue;
9080 }
9081
9082 /* Uh oh, we didn't find the expected call. We
9083 could just mark this symbol to exclude it
9084 from tls optimization but it's safer to skip
9085 the entire optimization. */
9086 /* xgettext:c-format */
9087 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
9088 "TLS optimization disabled\n"),
9089 ibfd, sec, rel->r_offset);
9090 ret = TRUE;
9091 goto err_free_rel;
9092 }
9093
9094 /* If we don't have old-style __tls_get_addr calls
9095 without TLSGD/TLSLD marker relocs, and we haven't
9096 found a new-style __tls_get_addr call with a
9097 marker for this symbol, then we either have a
9098 broken object file or an -mlongcall style
9099 indirect call to __tls_get_addr without a marker.
9100 Disable optimization in this case. */
9101 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
9102 && (tls_set & TLS_EXPLICIT) == 0
9103 && !sec->has_tls_get_addr_call
9104 && ((*tls_mask & (TLS_TLS | TLS_MARK))
9105 != (TLS_TLS | TLS_MARK)))
9106 continue;
9107
9108 if (expecting_tls_get_addr)
9109 {
9110 struct plt_entry *ent = NULL;
9111
9112 if (htab->tls_get_addr != NULL)
9113 for (ent = htab->tls_get_addr->elf.plt.plist;
9114 ent != NULL;
9115 ent = ent->next)
9116 if (ent->addend == 0)
9117 break;
9118
9119 if (ent == NULL && htab->tls_get_addr_fd != NULL)
9120 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
9121 ent != NULL;
9122 ent = ent->next)
9123 if (ent->addend == 0)
9124 break;
9125
9126 if (ent != NULL
9127 && ent->plt.refcount > 0)
9128 ent->plt.refcount -= 1;
9129 }
9130
9131 if (tls_clear == 0)
9132 continue;
9133
9134 if ((tls_set & TLS_EXPLICIT) == 0)
9135 {
9136 struct got_entry *ent;
9137
9138 /* Adjust got entry for this reloc. */
9139 if (h != NULL)
9140 ent = h->got.glist;
9141 else
9142 ent = elf_local_got_ents (ibfd)[r_symndx];
9143
9144 for (; ent != NULL; ent = ent->next)
9145 if (ent->addend == rel->r_addend
9146 && ent->owner == ibfd
9147 && ent->tls_type == tls_type)
9148 break;
9149 if (ent == NULL)
9150 abort ();
9151
9152 if (tls_set == 0)
9153 {
9154 /* We managed to get rid of a got entry. */
9155 if (ent->got.refcount > 0)
9156 ent->got.refcount -= 1;
9157 }
9158 }
9159 else
9160 {
9161 /* If we got rid of a DTPMOD/DTPREL reloc pair then
9162 we'll lose one or two dyn relocs. */
9163 if (!dec_dynrel_count (rel->r_info, sec, info,
9164 NULL, h, sym))
9165 return FALSE;
9166
9167 if (tls_set == (TLS_EXPLICIT | TLS_GD))
9168 {
9169 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9170 NULL, h, sym))
9171 return FALSE;
9172 }
9173 }
9174
9175 *tls_mask |= tls_set;
9176 *tls_mask &= ~tls_clear;
9177 }
9178
9179 if (elf_section_data (sec)->relocs != relstart)
9180 free (relstart);
9181 }
9182
9183 if (locsyms != NULL
9184 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9185 {
9186 if (!info->keep_memory)
9187 free (locsyms);
9188 else
9189 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9190 }
9191 }
9192
9193 if (toc_ref != NULL)
9194 free (toc_ref);
9195 htab->do_tls_opt = 1;
9196 return TRUE;
9197 }
9198
9199 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9200 the values of any global symbols in a toc section that has been
9201 edited. Globals in toc sections should be a rarity, so this function
9202 sets a flag if any are found in toc sections other than the one just
9203 edited, so that further hash table traversals can be avoided. */
9204
9205 struct adjust_toc_info
9206 {
9207 asection *toc;
9208 unsigned long *skip;
9209 bfd_boolean global_toc_syms;
9210 };
9211
9212 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9213
9214 static bfd_boolean
9215 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9216 {
9217 struct ppc_link_hash_entry *eh;
9218 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9219 unsigned long i;
9220
9221 if (h->root.type != bfd_link_hash_defined
9222 && h->root.type != bfd_link_hash_defweak)
9223 return TRUE;
9224
9225 eh = (struct ppc_link_hash_entry *) h;
9226 if (eh->adjust_done)
9227 return TRUE;
9228
9229 if (eh->elf.root.u.def.section == toc_inf->toc)
9230 {
9231 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9232 i = toc_inf->toc->rawsize >> 3;
9233 else
9234 i = eh->elf.root.u.def.value >> 3;
9235
9236 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9237 {
9238 _bfd_error_handler
9239 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9240 do
9241 ++i;
9242 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9243 eh->elf.root.u.def.value = (bfd_vma) i << 3;
9244 }
9245
9246 eh->elf.root.u.def.value -= toc_inf->skip[i];
9247 eh->adjust_done = 1;
9248 }
9249 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9250 toc_inf->global_toc_syms = TRUE;
9251
9252 return TRUE;
9253 }
9254
9255 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9256 on a _LO variety toc/got reloc. */
9257
9258 static bfd_boolean
9259 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9260 {
9261 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9262 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9263 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9264 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9265 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9266 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9267 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9268 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9269 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9270 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9271 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9272 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9273 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9274 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9275 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9276 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9277 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9278 /* Exclude lfqu by testing reloc. If relocs are ever
9279 defined for the reduced D field in psq_lu then those
9280 will need testing too. */
9281 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9282 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9283 && (insn & 1) == 0)
9284 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9285 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9286 /* Exclude stfqu. psq_stu as above for psq_lu. */
9287 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9288 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9289 && (insn & 1) == 0));
9290 }
9291
9292 /* Examine all relocs referencing .toc sections in order to remove
9293 unused .toc entries. */
9294
9295 bfd_boolean
9296 ppc64_elf_edit_toc (struct bfd_link_info *info)
9297 {
9298 bfd *ibfd;
9299 struct adjust_toc_info toc_inf;
9300 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9301
9302 htab->do_toc_opt = 1;
9303 toc_inf.global_toc_syms = TRUE;
9304 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9305 {
9306 asection *toc, *sec;
9307 Elf_Internal_Shdr *symtab_hdr;
9308 Elf_Internal_Sym *local_syms;
9309 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9310 unsigned long *skip, *drop;
9311 unsigned char *used;
9312 unsigned char *keep, last, some_unused;
9313
9314 if (!is_ppc64_elf (ibfd))
9315 continue;
9316
9317 toc = bfd_get_section_by_name (ibfd, ".toc");
9318 if (toc == NULL
9319 || toc->size == 0
9320 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9321 || discarded_section (toc))
9322 continue;
9323
9324 toc_relocs = NULL;
9325 local_syms = NULL;
9326 symtab_hdr = &elf_symtab_hdr (ibfd);
9327
9328 /* Look at sections dropped from the final link. */
9329 skip = NULL;
9330 relstart = NULL;
9331 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9332 {
9333 if (sec->reloc_count == 0
9334 || !discarded_section (sec)
9335 || get_opd_info (sec)
9336 || (sec->flags & SEC_ALLOC) == 0
9337 || (sec->flags & SEC_DEBUGGING) != 0)
9338 continue;
9339
9340 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9341 if (relstart == NULL)
9342 goto error_ret;
9343
9344 /* Run through the relocs to see which toc entries might be
9345 unused. */
9346 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9347 {
9348 enum elf_ppc64_reloc_type r_type;
9349 unsigned long r_symndx;
9350 asection *sym_sec;
9351 struct elf_link_hash_entry *h;
9352 Elf_Internal_Sym *sym;
9353 bfd_vma val;
9354
9355 r_type = ELF64_R_TYPE (rel->r_info);
9356 switch (r_type)
9357 {
9358 default:
9359 continue;
9360
9361 case R_PPC64_TOC16:
9362 case R_PPC64_TOC16_LO:
9363 case R_PPC64_TOC16_HI:
9364 case R_PPC64_TOC16_HA:
9365 case R_PPC64_TOC16_DS:
9366 case R_PPC64_TOC16_LO_DS:
9367 break;
9368 }
9369
9370 r_symndx = ELF64_R_SYM (rel->r_info);
9371 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9372 r_symndx, ibfd))
9373 goto error_ret;
9374
9375 if (sym_sec != toc)
9376 continue;
9377
9378 if (h != NULL)
9379 val = h->root.u.def.value;
9380 else
9381 val = sym->st_value;
9382 val += rel->r_addend;
9383
9384 if (val >= toc->size)
9385 continue;
9386
9387 /* Anything in the toc ought to be aligned to 8 bytes.
9388 If not, don't mark as unused. */
9389 if (val & 7)
9390 continue;
9391
9392 if (skip == NULL)
9393 {
9394 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9395 if (skip == NULL)
9396 goto error_ret;
9397 }
9398
9399 skip[val >> 3] = ref_from_discarded;
9400 }
9401
9402 if (elf_section_data (sec)->relocs != relstart)
9403 free (relstart);
9404 }
9405
9406 /* For largetoc loads of address constants, we can convert
9407 . addis rx,2,addr@got@ha
9408 . ld ry,addr@got@l(rx)
9409 to
9410 . addis rx,2,addr@toc@ha
9411 . addi ry,rx,addr@toc@l
9412 when addr is within 2G of the toc pointer. This then means
9413 that the word storing "addr" in the toc is no longer needed. */
9414
9415 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9416 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9417 && toc->reloc_count != 0)
9418 {
9419 /* Read toc relocs. */
9420 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9421 info->keep_memory);
9422 if (toc_relocs == NULL)
9423 goto error_ret;
9424
9425 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9426 {
9427 enum elf_ppc64_reloc_type r_type;
9428 unsigned long r_symndx;
9429 asection *sym_sec;
9430 struct elf_link_hash_entry *h;
9431 Elf_Internal_Sym *sym;
9432 bfd_vma val, addr;
9433
9434 r_type = ELF64_R_TYPE (rel->r_info);
9435 if (r_type != R_PPC64_ADDR64)
9436 continue;
9437
9438 r_symndx = ELF64_R_SYM (rel->r_info);
9439 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9440 r_symndx, ibfd))
9441 goto error_ret;
9442
9443 if (sym_sec == NULL
9444 || sym_sec->output_section == NULL
9445 || discarded_section (sym_sec))
9446 continue;
9447
9448 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9449 continue;
9450
9451 if (h != NULL)
9452 {
9453 if (h->type == STT_GNU_IFUNC)
9454 continue;
9455 val = h->root.u.def.value;
9456 }
9457 else
9458 {
9459 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9460 continue;
9461 val = sym->st_value;
9462 }
9463 val += rel->r_addend;
9464 val += sym_sec->output_section->vma + sym_sec->output_offset;
9465
9466 /* We don't yet know the exact toc pointer value, but we
9467 know it will be somewhere in the toc section. Don't
9468 optimize if the difference from any possible toc
9469 pointer is outside [ff..f80008000, 7fff7fff]. */
9470 addr = toc->output_section->vma + TOC_BASE_OFF;
9471 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9472 continue;
9473
9474 addr = toc->output_section->vma + toc->output_section->rawsize;
9475 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9476 continue;
9477
9478 if (skip == NULL)
9479 {
9480 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9481 if (skip == NULL)
9482 goto error_ret;
9483 }
9484
9485 skip[rel->r_offset >> 3]
9486 |= can_optimize | ((rel - toc_relocs) << 2);
9487 }
9488 }
9489
9490 if (skip == NULL)
9491 continue;
9492
9493 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9494 if (used == NULL)
9495 {
9496 error_ret:
9497 if (local_syms != NULL
9498 && symtab_hdr->contents != (unsigned char *) local_syms)
9499 free (local_syms);
9500 if (sec != NULL
9501 && relstart != NULL
9502 && elf_section_data (sec)->relocs != relstart)
9503 free (relstart);
9504 if (toc_relocs != NULL
9505 && elf_section_data (toc)->relocs != toc_relocs)
9506 free (toc_relocs);
9507 if (skip != NULL)
9508 free (skip);
9509 return FALSE;
9510 }
9511
9512 /* Now check all kept sections that might reference the toc.
9513 Check the toc itself last. */
9514 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9515 : ibfd->sections);
9516 sec != NULL;
9517 sec = (sec == toc ? NULL
9518 : sec->next == NULL ? toc
9519 : sec->next == toc && toc->next ? toc->next
9520 : sec->next))
9521 {
9522 int repeat;
9523
9524 if (sec->reloc_count == 0
9525 || discarded_section (sec)
9526 || get_opd_info (sec)
9527 || (sec->flags & SEC_ALLOC) == 0
9528 || (sec->flags & SEC_DEBUGGING) != 0)
9529 continue;
9530
9531 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9532 info->keep_memory);
9533 if (relstart == NULL)
9534 {
9535 free (used);
9536 goto error_ret;
9537 }
9538
9539 /* Mark toc entries referenced as used. */
9540 do
9541 {
9542 repeat = 0;
9543 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9544 {
9545 enum elf_ppc64_reloc_type r_type;
9546 unsigned long r_symndx;
9547 asection *sym_sec;
9548 struct elf_link_hash_entry *h;
9549 Elf_Internal_Sym *sym;
9550 bfd_vma val;
9551 enum {no_check, check_lo, check_ha} insn_check;
9552
9553 r_type = ELF64_R_TYPE (rel->r_info);
9554 switch (r_type)
9555 {
9556 default:
9557 insn_check = no_check;
9558 break;
9559
9560 case R_PPC64_GOT_TLSLD16_HA:
9561 case R_PPC64_GOT_TLSGD16_HA:
9562 case R_PPC64_GOT_TPREL16_HA:
9563 case R_PPC64_GOT_DTPREL16_HA:
9564 case R_PPC64_GOT16_HA:
9565 case R_PPC64_TOC16_HA:
9566 insn_check = check_ha;
9567 break;
9568
9569 case R_PPC64_GOT_TLSLD16_LO:
9570 case R_PPC64_GOT_TLSGD16_LO:
9571 case R_PPC64_GOT_TPREL16_LO_DS:
9572 case R_PPC64_GOT_DTPREL16_LO_DS:
9573 case R_PPC64_GOT16_LO:
9574 case R_PPC64_GOT16_LO_DS:
9575 case R_PPC64_TOC16_LO:
9576 case R_PPC64_TOC16_LO_DS:
9577 insn_check = check_lo;
9578 break;
9579 }
9580
9581 if (insn_check != no_check)
9582 {
9583 bfd_vma off = rel->r_offset & ~3;
9584 unsigned char buf[4];
9585 unsigned int insn;
9586
9587 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9588 {
9589 free (used);
9590 goto error_ret;
9591 }
9592 insn = bfd_get_32 (ibfd, buf);
9593 if (insn_check == check_lo
9594 ? !ok_lo_toc_insn (insn, r_type)
9595 : ((insn & ((0x3f << 26) | 0x1f << 16))
9596 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9597 {
9598 char str[12];
9599
9600 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9601 sprintf (str, "%#08x", insn);
9602 info->callbacks->einfo
9603 /* xgettext:c-format */
9604 (_("%H: toc optimization is not supported for"
9605 " %s instruction\n"),
9606 ibfd, sec, rel->r_offset & ~3, str);
9607 }
9608 }
9609
9610 switch (r_type)
9611 {
9612 case R_PPC64_TOC16:
9613 case R_PPC64_TOC16_LO:
9614 case R_PPC64_TOC16_HI:
9615 case R_PPC64_TOC16_HA:
9616 case R_PPC64_TOC16_DS:
9617 case R_PPC64_TOC16_LO_DS:
9618 /* In case we're taking addresses of toc entries. */
9619 case R_PPC64_ADDR64:
9620 break;
9621
9622 default:
9623 continue;
9624 }
9625
9626 r_symndx = ELF64_R_SYM (rel->r_info);
9627 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9628 r_symndx, ibfd))
9629 {
9630 free (used);
9631 goto error_ret;
9632 }
9633
9634 if (sym_sec != toc)
9635 continue;
9636
9637 if (h != NULL)
9638 val = h->root.u.def.value;
9639 else
9640 val = sym->st_value;
9641 val += rel->r_addend;
9642
9643 if (val >= toc->size)
9644 continue;
9645
9646 if ((skip[val >> 3] & can_optimize) != 0)
9647 {
9648 bfd_vma off;
9649 unsigned char opc;
9650
9651 switch (r_type)
9652 {
9653 case R_PPC64_TOC16_HA:
9654 break;
9655
9656 case R_PPC64_TOC16_LO_DS:
9657 off = rel->r_offset;
9658 off += (bfd_big_endian (ibfd) ? -2 : 3);
9659 if (!bfd_get_section_contents (ibfd, sec, &opc,
9660 off, 1))
9661 {
9662 free (used);
9663 goto error_ret;
9664 }
9665 if ((opc & (0x3f << 2)) == (58u << 2))
9666 break;
9667 /* Fall through. */
9668
9669 default:
9670 /* Wrong sort of reloc, or not a ld. We may
9671 as well clear ref_from_discarded too. */
9672 skip[val >> 3] = 0;
9673 }
9674 }
9675
9676 if (sec != toc)
9677 used[val >> 3] = 1;
9678 /* For the toc section, we only mark as used if this
9679 entry itself isn't unused. */
9680 else if ((used[rel->r_offset >> 3]
9681 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9682 && !used[val >> 3])
9683 {
9684 /* Do all the relocs again, to catch reference
9685 chains. */
9686 repeat = 1;
9687 used[val >> 3] = 1;
9688 }
9689 }
9690 }
9691 while (repeat);
9692
9693 if (elf_section_data (sec)->relocs != relstart)
9694 free (relstart);
9695 }
9696
9697 /* Merge the used and skip arrays. Assume that TOC
9698 doublewords not appearing as either used or unused belong
9699 to an entry more than one doubleword in size. */
9700 for (drop = skip, keep = used, last = 0, some_unused = 0;
9701 drop < skip + (toc->size + 7) / 8;
9702 ++drop, ++keep)
9703 {
9704 if (*keep)
9705 {
9706 *drop &= ~ref_from_discarded;
9707 if ((*drop & can_optimize) != 0)
9708 some_unused = 1;
9709 last = 0;
9710 }
9711 else if ((*drop & ref_from_discarded) != 0)
9712 {
9713 some_unused = 1;
9714 last = ref_from_discarded;
9715 }
9716 else
9717 *drop = last;
9718 }
9719
9720 free (used);
9721
9722 if (some_unused)
9723 {
9724 bfd_byte *contents, *src;
9725 unsigned long off;
9726 Elf_Internal_Sym *sym;
9727 bfd_boolean local_toc_syms = FALSE;
9728
9729 /* Shuffle the toc contents, and at the same time convert the
9730 skip array from booleans into offsets. */
9731 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9732 goto error_ret;
9733
9734 elf_section_data (toc)->this_hdr.contents = contents;
9735
9736 for (src = contents, off = 0, drop = skip;
9737 src < contents + toc->size;
9738 src += 8, ++drop)
9739 {
9740 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9741 off += 8;
9742 else if (off != 0)
9743 {
9744 *drop = off;
9745 memcpy (src - off, src, 8);
9746 }
9747 }
9748 *drop = off;
9749 toc->rawsize = toc->size;
9750 toc->size = src - contents - off;
9751
9752 /* Adjust addends for relocs against the toc section sym,
9753 and optimize any accesses we can. */
9754 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9755 {
9756 if (sec->reloc_count == 0
9757 || discarded_section (sec))
9758 continue;
9759
9760 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9761 info->keep_memory);
9762 if (relstart == NULL)
9763 goto error_ret;
9764
9765 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9766 {
9767 enum elf_ppc64_reloc_type r_type;
9768 unsigned long r_symndx;
9769 asection *sym_sec;
9770 struct elf_link_hash_entry *h;
9771 bfd_vma val;
9772
9773 r_type = ELF64_R_TYPE (rel->r_info);
9774 switch (r_type)
9775 {
9776 default:
9777 continue;
9778
9779 case R_PPC64_TOC16:
9780 case R_PPC64_TOC16_LO:
9781 case R_PPC64_TOC16_HI:
9782 case R_PPC64_TOC16_HA:
9783 case R_PPC64_TOC16_DS:
9784 case R_PPC64_TOC16_LO_DS:
9785 case R_PPC64_ADDR64:
9786 break;
9787 }
9788
9789 r_symndx = ELF64_R_SYM (rel->r_info);
9790 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9791 r_symndx, ibfd))
9792 goto error_ret;
9793
9794 if (sym_sec != toc)
9795 continue;
9796
9797 if (h != NULL)
9798 val = h->root.u.def.value;
9799 else
9800 {
9801 val = sym->st_value;
9802 if (val != 0)
9803 local_toc_syms = TRUE;
9804 }
9805
9806 val += rel->r_addend;
9807
9808 if (val > toc->rawsize)
9809 val = toc->rawsize;
9810 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9811 continue;
9812 else if ((skip[val >> 3] & can_optimize) != 0)
9813 {
9814 Elf_Internal_Rela *tocrel
9815 = toc_relocs + (skip[val >> 3] >> 2);
9816 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9817
9818 switch (r_type)
9819 {
9820 case R_PPC64_TOC16_HA:
9821 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9822 break;
9823
9824 case R_PPC64_TOC16_LO_DS:
9825 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9826 break;
9827
9828 default:
9829 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9830 ppc_howto_init ();
9831 info->callbacks->einfo
9832 /* xgettext:c-format */
9833 (_("%H: %s references "
9834 "optimized away TOC entry\n"),
9835 ibfd, sec, rel->r_offset,
9836 ppc64_elf_howto_table[r_type]->name);
9837 bfd_set_error (bfd_error_bad_value);
9838 goto error_ret;
9839 }
9840 rel->r_addend = tocrel->r_addend;
9841 elf_section_data (sec)->relocs = relstart;
9842 continue;
9843 }
9844
9845 if (h != NULL || sym->st_value != 0)
9846 continue;
9847
9848 rel->r_addend -= skip[val >> 3];
9849 elf_section_data (sec)->relocs = relstart;
9850 }
9851
9852 if (elf_section_data (sec)->relocs != relstart)
9853 free (relstart);
9854 }
9855
9856 /* We shouldn't have local or global symbols defined in the TOC,
9857 but handle them anyway. */
9858 if (local_syms != NULL)
9859 for (sym = local_syms;
9860 sym < local_syms + symtab_hdr->sh_info;
9861 ++sym)
9862 if (sym->st_value != 0
9863 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9864 {
9865 unsigned long i;
9866
9867 if (sym->st_value > toc->rawsize)
9868 i = toc->rawsize >> 3;
9869 else
9870 i = sym->st_value >> 3;
9871
9872 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9873 {
9874 if (local_toc_syms)
9875 _bfd_error_handler
9876 (_("%s defined on removed toc entry"),
9877 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9878 do
9879 ++i;
9880 while ((skip[i] & (ref_from_discarded | can_optimize)));
9881 sym->st_value = (bfd_vma) i << 3;
9882 }
9883
9884 sym->st_value -= skip[i];
9885 symtab_hdr->contents = (unsigned char *) local_syms;
9886 }
9887
9888 /* Adjust any global syms defined in this toc input section. */
9889 if (toc_inf.global_toc_syms)
9890 {
9891 toc_inf.toc = toc;
9892 toc_inf.skip = skip;
9893 toc_inf.global_toc_syms = FALSE;
9894 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9895 &toc_inf);
9896 }
9897
9898 if (toc->reloc_count != 0)
9899 {
9900 Elf_Internal_Shdr *rel_hdr;
9901 Elf_Internal_Rela *wrel;
9902 bfd_size_type sz;
9903
9904 /* Remove unused toc relocs, and adjust those we keep. */
9905 if (toc_relocs == NULL)
9906 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9907 info->keep_memory);
9908 if (toc_relocs == NULL)
9909 goto error_ret;
9910
9911 wrel = toc_relocs;
9912 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9913 if ((skip[rel->r_offset >> 3]
9914 & (ref_from_discarded | can_optimize)) == 0)
9915 {
9916 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9917 wrel->r_info = rel->r_info;
9918 wrel->r_addend = rel->r_addend;
9919 ++wrel;
9920 }
9921 else if (!dec_dynrel_count (rel->r_info, toc, info,
9922 &local_syms, NULL, NULL))
9923 goto error_ret;
9924
9925 elf_section_data (toc)->relocs = toc_relocs;
9926 toc->reloc_count = wrel - toc_relocs;
9927 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9928 sz = rel_hdr->sh_entsize;
9929 rel_hdr->sh_size = toc->reloc_count * sz;
9930 }
9931 }
9932 else if (toc_relocs != NULL
9933 && elf_section_data (toc)->relocs != toc_relocs)
9934 free (toc_relocs);
9935
9936 if (local_syms != NULL
9937 && symtab_hdr->contents != (unsigned char *) local_syms)
9938 {
9939 if (!info->keep_memory)
9940 free (local_syms);
9941 else
9942 symtab_hdr->contents = (unsigned char *) local_syms;
9943 }
9944 free (skip);
9945 }
9946
9947 return TRUE;
9948 }
9949
9950 /* Return true iff input section I references the TOC using
9951 instructions limited to +/-32k offsets. */
9952
9953 bfd_boolean
9954 ppc64_elf_has_small_toc_reloc (asection *i)
9955 {
9956 return (is_ppc64_elf (i->owner)
9957 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9958 }
9959
9960 /* Allocate space for one GOT entry. */
9961
9962 static void
9963 allocate_got (struct elf_link_hash_entry *h,
9964 struct bfd_link_info *info,
9965 struct got_entry *gent)
9966 {
9967 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9968 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9969 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9970 ? 16 : 8);
9971 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9972 ? 2 : 1) * sizeof (Elf64_External_Rela);
9973 asection *got = ppc64_elf_tdata (gent->owner)->got;
9974
9975 gent->got.offset = got->size;
9976 got->size += entsize;
9977
9978 if (h->type == STT_GNU_IFUNC)
9979 {
9980 htab->elf.irelplt->size += rentsize;
9981 htab->got_reli_size += rentsize;
9982 }
9983 else if (((bfd_link_pic (info)
9984 && !((gent->tls_type & TLS_TPREL) != 0
9985 && bfd_link_executable (info)
9986 && SYMBOL_REFERENCES_LOCAL (info, h)))
9987 || (htab->elf.dynamic_sections_created
9988 && h->dynindx != -1
9989 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9990 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9991 {
9992 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9993 relgot->size += rentsize;
9994 }
9995 }
9996
9997 /* This function merges got entries in the same toc group. */
9998
9999 static void
10000 merge_got_entries (struct got_entry **pent)
10001 {
10002 struct got_entry *ent, *ent2;
10003
10004 for (ent = *pent; ent != NULL; ent = ent->next)
10005 if (!ent->is_indirect)
10006 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
10007 if (!ent2->is_indirect
10008 && ent2->addend == ent->addend
10009 && ent2->tls_type == ent->tls_type
10010 && elf_gp (ent2->owner) == elf_gp (ent->owner))
10011 {
10012 ent2->is_indirect = TRUE;
10013 ent2->got.ent = ent;
10014 }
10015 }
10016
10017 /* If H is undefined, make it dynamic if that makes sense. */
10018
10019 static bfd_boolean
10020 ensure_undef_dynamic (struct bfd_link_info *info,
10021 struct elf_link_hash_entry *h)
10022 {
10023 struct elf_link_hash_table *htab = elf_hash_table (info);
10024
10025 if (htab->dynamic_sections_created
10026 && ((info->dynamic_undefined_weak != 0
10027 && h->root.type == bfd_link_hash_undefweak)
10028 || h->root.type == bfd_link_hash_undefined)
10029 && h->dynindx == -1
10030 && !h->forced_local
10031 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
10032 return bfd_elf_link_record_dynamic_symbol (info, h);
10033 return TRUE;
10034 }
10035
10036 /* Allocate space in .plt, .got and associated reloc sections for
10037 dynamic relocs. */
10038
10039 static bfd_boolean
10040 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
10041 {
10042 struct bfd_link_info *info;
10043 struct ppc_link_hash_table *htab;
10044 asection *s;
10045 struct ppc_link_hash_entry *eh;
10046 struct got_entry **pgent, *gent;
10047
10048 if (h->root.type == bfd_link_hash_indirect)
10049 return TRUE;
10050
10051 info = (struct bfd_link_info *) inf;
10052 htab = ppc_hash_table (info);
10053 if (htab == NULL)
10054 return FALSE;
10055
10056 eh = (struct ppc_link_hash_entry *) h;
10057 /* Run through the TLS GD got entries first if we're changing them
10058 to TPREL. */
10059 if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
10060 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10061 if (gent->got.refcount > 0
10062 && (gent->tls_type & TLS_GD) != 0)
10063 {
10064 /* This was a GD entry that has been converted to TPREL. If
10065 there happens to be a TPREL entry we can use that one. */
10066 struct got_entry *ent;
10067 for (ent = h->got.glist; ent != NULL; ent = ent->next)
10068 if (ent->got.refcount > 0
10069 && (ent->tls_type & TLS_TPREL) != 0
10070 && ent->addend == gent->addend
10071 && ent->owner == gent->owner)
10072 {
10073 gent->got.refcount = 0;
10074 break;
10075 }
10076
10077 /* If not, then we'll be using our own TPREL entry. */
10078 if (gent->got.refcount != 0)
10079 gent->tls_type = TLS_TLS | TLS_TPREL;
10080 }
10081
10082 /* Remove any list entry that won't generate a word in the GOT before
10083 we call merge_got_entries. Otherwise we risk merging to empty
10084 entries. */
10085 pgent = &h->got.glist;
10086 while ((gent = *pgent) != NULL)
10087 if (gent->got.refcount > 0)
10088 {
10089 if ((gent->tls_type & TLS_LD) != 0
10090 && !h->def_dynamic)
10091 {
10092 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
10093 *pgent = gent->next;
10094 }
10095 else
10096 pgent = &gent->next;
10097 }
10098 else
10099 *pgent = gent->next;
10100
10101 if (!htab->do_multi_toc)
10102 merge_got_entries (&h->got.glist);
10103
10104 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10105 if (!gent->is_indirect)
10106 {
10107 /* Make sure this symbol is output as a dynamic symbol. */
10108 if (!ensure_undef_dynamic (info, h))
10109 return FALSE;
10110
10111 if (!is_ppc64_elf (gent->owner))
10112 abort ();
10113
10114 allocate_got (h, info, gent);
10115 }
10116
10117 /* If no dynamic sections we can't have dynamic relocs, except for
10118 IFUNCs which are handled even in static executables. */
10119 if (!htab->elf.dynamic_sections_created
10120 && h->type != STT_GNU_IFUNC)
10121 eh->dyn_relocs = NULL;
10122
10123 /* Discard relocs on undefined symbols that must be local. */
10124 else if (h->root.type == bfd_link_hash_undefined
10125 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10126 eh->dyn_relocs = NULL;
10127
10128 /* Also discard relocs on undefined weak syms with non-default
10129 visibility, or when dynamic_undefined_weak says so. */
10130 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10131 eh->dyn_relocs = NULL;
10132
10133 if (eh->dyn_relocs != NULL)
10134 {
10135 struct elf_dyn_relocs *p, **pp;
10136
10137 /* In the shared -Bsymbolic case, discard space allocated for
10138 dynamic pc-relative relocs against symbols which turn out to
10139 be defined in regular objects. For the normal shared case,
10140 discard space for relocs that have become local due to symbol
10141 visibility changes. */
10142
10143 if (bfd_link_pic (info))
10144 {
10145 /* Relocs that use pc_count are those that appear on a call
10146 insn, or certain REL relocs (see must_be_dyn_reloc) that
10147 can be generated via assembly. We want calls to
10148 protected symbols to resolve directly to the function
10149 rather than going via the plt. If people want function
10150 pointer comparisons to work as expected then they should
10151 avoid writing weird assembly. */
10152 if (SYMBOL_CALLS_LOCAL (info, h))
10153 {
10154 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10155 {
10156 p->count -= p->pc_count;
10157 p->pc_count = 0;
10158 if (p->count == 0)
10159 *pp = p->next;
10160 else
10161 pp = &p->next;
10162 }
10163 }
10164
10165 if (eh->dyn_relocs != NULL)
10166 {
10167 /* Make sure this symbol is output as a dynamic symbol. */
10168 if (!ensure_undef_dynamic (info, h))
10169 return FALSE;
10170 }
10171 }
10172 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10173 {
10174 /* For the non-pic case, discard space for relocs against
10175 symbols which turn out to need copy relocs or are not
10176 dynamic. */
10177 if (h->dynamic_adjusted
10178 && !h->def_regular
10179 && !ELF_COMMON_DEF_P (h))
10180 {
10181 /* Make sure this symbol is output as a dynamic symbol. */
10182 if (!ensure_undef_dynamic (info, h))
10183 return FALSE;
10184
10185 if (h->dynindx == -1)
10186 eh->dyn_relocs = NULL;
10187 }
10188 else
10189 eh->dyn_relocs = NULL;
10190 }
10191
10192 /* Finally, allocate space. */
10193 for (p = eh->dyn_relocs; p != NULL; p = p->next)
10194 {
10195 asection *sreloc = elf_section_data (p->sec)->sreloc;
10196 if (eh->elf.type == STT_GNU_IFUNC)
10197 sreloc = htab->elf.irelplt;
10198 sreloc->size += p->count * sizeof (Elf64_External_Rela);
10199 }
10200 }
10201
10202 /* We might need a PLT entry when the symbol
10203 a) is dynamic, or
10204 b) is an ifunc, or
10205 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10206 d) has plt16 relocs and we are linking statically. */
10207 if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10208 || h->type == STT_GNU_IFUNC
10209 || (h->needs_plt && h->dynamic_adjusted)
10210 || (h->needs_plt
10211 && h->def_regular
10212 && !htab->elf.dynamic_sections_created
10213 && !htab->can_convert_all_inline_plt
10214 && (((struct ppc_link_hash_entry *) h)->tls_mask
10215 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10216 {
10217 struct plt_entry *pent;
10218 bfd_boolean doneone = FALSE;
10219 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10220 if (pent->plt.refcount > 0)
10221 {
10222 if (!htab->elf.dynamic_sections_created
10223 || h->dynindx == -1)
10224 {
10225 if (h->type == STT_GNU_IFUNC)
10226 {
10227 s = htab->elf.iplt;
10228 pent->plt.offset = s->size;
10229 s->size += PLT_ENTRY_SIZE (htab);
10230 s = htab->elf.irelplt;
10231 }
10232 else
10233 {
10234 s = htab->pltlocal;
10235 pent->plt.offset = s->size;
10236 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10237 s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10238 }
10239 }
10240 else
10241 {
10242 /* If this is the first .plt entry, make room for the special
10243 first entry. */
10244 s = htab->elf.splt;
10245 if (s->size == 0)
10246 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10247
10248 pent->plt.offset = s->size;
10249
10250 /* Make room for this entry. */
10251 s->size += PLT_ENTRY_SIZE (htab);
10252
10253 /* Make room for the .glink code. */
10254 s = htab->glink;
10255 if (s->size == 0)
10256 s->size += GLINK_PLTRESOLVE_SIZE (htab);
10257 if (htab->opd_abi)
10258 {
10259 /* We need bigger stubs past index 32767. */
10260 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10261 s->size += 4;
10262 s->size += 2*4;
10263 }
10264 else
10265 s->size += 4;
10266
10267 /* We also need to make an entry in the .rela.plt section. */
10268 s = htab->elf.srelplt;
10269 }
10270 if (s != NULL)
10271 s->size += sizeof (Elf64_External_Rela);
10272 doneone = TRUE;
10273 }
10274 else
10275 pent->plt.offset = (bfd_vma) -1;
10276 if (!doneone)
10277 {
10278 h->plt.plist = NULL;
10279 h->needs_plt = 0;
10280 }
10281 }
10282 else
10283 {
10284 h->plt.plist = NULL;
10285 h->needs_plt = 0;
10286 }
10287
10288 return TRUE;
10289 }
10290
10291 #define PPC_LO(v) ((v) & 0xffff)
10292 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10293 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10294
10295 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10296 to set up space for global entry stubs. These are put in glink,
10297 after the branch table. */
10298
10299 static bfd_boolean
10300 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10301 {
10302 struct bfd_link_info *info;
10303 struct ppc_link_hash_table *htab;
10304 struct plt_entry *pent;
10305 asection *s, *plt;
10306
10307 if (h->root.type == bfd_link_hash_indirect)
10308 return TRUE;
10309
10310 if (!h->pointer_equality_needed)
10311 return TRUE;
10312
10313 if (h->def_regular)
10314 return TRUE;
10315
10316 info = inf;
10317 htab = ppc_hash_table (info);
10318 if (htab == NULL)
10319 return FALSE;
10320
10321 s = htab->global_entry;
10322 plt = htab->elf.splt;
10323 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10324 if (pent->plt.offset != (bfd_vma) -1
10325 && pent->addend == 0)
10326 {
10327 /* For ELFv2, if this symbol is not defined in a regular file
10328 and we are not generating a shared library or pie, then we
10329 need to define the symbol in the executable on a call stub.
10330 This is to avoid text relocations. */
10331 bfd_vma off, stub_align, stub_off, stub_size;
10332 unsigned int align_power;
10333
10334 stub_size = 16;
10335 stub_off = s->size;
10336 if (htab->params->plt_stub_align >= 0)
10337 align_power = htab->params->plt_stub_align;
10338 else
10339 align_power = -htab->params->plt_stub_align;
10340 /* Setting section alignment is delayed until we know it is
10341 non-empty. Otherwise the .text output section will be
10342 aligned at least to plt_stub_align even when no global
10343 entry stubs are needed. */
10344 if (s->alignment_power < align_power)
10345 s->alignment_power = align_power;
10346 stub_align = (bfd_vma) 1 << align_power;
10347 if (htab->params->plt_stub_align >= 0
10348 || ((((stub_off + stub_size - 1) & -stub_align)
10349 - (stub_off & -stub_align))
10350 > ((stub_size - 1) & -stub_align)))
10351 stub_off = (stub_off + stub_align - 1) & -stub_align;
10352 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10353 off -= stub_off + s->output_offset + s->output_section->vma;
10354 /* Note that for --plt-stub-align negative we have a possible
10355 dependency between stub offset and size. Break that
10356 dependency by assuming the max stub size when calculating
10357 the stub offset. */
10358 if (PPC_HA (off) == 0)
10359 stub_size -= 4;
10360 h->root.type = bfd_link_hash_defined;
10361 h->root.u.def.section = s;
10362 h->root.u.def.value = stub_off;
10363 s->size = stub_off + stub_size;
10364 break;
10365 }
10366 return TRUE;
10367 }
10368
10369 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10370 read-only sections. */
10371
10372 static bfd_boolean
10373 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10374 {
10375 asection *sec;
10376
10377 if (h->root.type == bfd_link_hash_indirect)
10378 return TRUE;
10379
10380 sec = readonly_dynrelocs (h);
10381 if (sec != NULL)
10382 {
10383 struct bfd_link_info *info = (struct bfd_link_info *) inf;
10384
10385 info->flags |= DF_TEXTREL;
10386 info->callbacks->minfo (_("%pB: dynamic relocation against `%pT'"
10387 " in read-only section `%pA'\n"),
10388 sec->owner, h->root.root.string, sec);
10389
10390 /* Not an error, just cut short the traversal. */
10391 return FALSE;
10392 }
10393 return TRUE;
10394 }
10395
10396 /* Set the sizes of the dynamic sections. */
10397
10398 static bfd_boolean
10399 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10400 struct bfd_link_info *info)
10401 {
10402 struct ppc_link_hash_table *htab;
10403 bfd *dynobj;
10404 asection *s;
10405 bfd_boolean relocs;
10406 bfd *ibfd;
10407 struct got_entry *first_tlsld;
10408
10409 htab = ppc_hash_table (info);
10410 if (htab == NULL)
10411 return FALSE;
10412
10413 dynobj = htab->elf.dynobj;
10414 if (dynobj == NULL)
10415 abort ();
10416
10417 if (htab->elf.dynamic_sections_created)
10418 {
10419 /* Set the contents of the .interp section to the interpreter. */
10420 if (bfd_link_executable (info) && !info->nointerp)
10421 {
10422 s = bfd_get_linker_section (dynobj, ".interp");
10423 if (s == NULL)
10424 abort ();
10425 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10426 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10427 }
10428 }
10429
10430 /* Set up .got offsets for local syms, and space for local dynamic
10431 relocs. */
10432 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10433 {
10434 struct got_entry **lgot_ents;
10435 struct got_entry **end_lgot_ents;
10436 struct plt_entry **local_plt;
10437 struct plt_entry **end_local_plt;
10438 unsigned char *lgot_masks;
10439 bfd_size_type locsymcount;
10440 Elf_Internal_Shdr *symtab_hdr;
10441
10442 if (!is_ppc64_elf (ibfd))
10443 continue;
10444
10445 for (s = ibfd->sections; s != NULL; s = s->next)
10446 {
10447 struct ppc_dyn_relocs *p;
10448
10449 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10450 {
10451 if (!bfd_is_abs_section (p->sec)
10452 && bfd_is_abs_section (p->sec->output_section))
10453 {
10454 /* Input section has been discarded, either because
10455 it is a copy of a linkonce section or due to
10456 linker script /DISCARD/, so we'll be discarding
10457 the relocs too. */
10458 }
10459 else if (p->count != 0)
10460 {
10461 asection *srel = elf_section_data (p->sec)->sreloc;
10462 if (p->ifunc)
10463 srel = htab->elf.irelplt;
10464 srel->size += p->count * sizeof (Elf64_External_Rela);
10465 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10466 info->flags |= DF_TEXTREL;
10467 }
10468 }
10469 }
10470
10471 lgot_ents = elf_local_got_ents (ibfd);
10472 if (!lgot_ents)
10473 continue;
10474
10475 symtab_hdr = &elf_symtab_hdr (ibfd);
10476 locsymcount = symtab_hdr->sh_info;
10477 end_lgot_ents = lgot_ents + locsymcount;
10478 local_plt = (struct plt_entry **) end_lgot_ents;
10479 end_local_plt = local_plt + locsymcount;
10480 lgot_masks = (unsigned char *) end_local_plt;
10481 s = ppc64_elf_tdata (ibfd)->got;
10482 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10483 {
10484 struct got_entry **pent, *ent;
10485
10486 pent = lgot_ents;
10487 while ((ent = *pent) != NULL)
10488 if (ent->got.refcount > 0)
10489 {
10490 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10491 {
10492 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10493 *pent = ent->next;
10494 }
10495 else
10496 {
10497 unsigned int ent_size = 8;
10498 unsigned int rel_size = sizeof (Elf64_External_Rela);
10499
10500 ent->got.offset = s->size;
10501 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10502 {
10503 ent_size *= 2;
10504 rel_size *= 2;
10505 }
10506 s->size += ent_size;
10507 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10508 {
10509 htab->elf.irelplt->size += rel_size;
10510 htab->got_reli_size += rel_size;
10511 }
10512 else if (bfd_link_pic (info)
10513 && !((ent->tls_type & TLS_TPREL) != 0
10514 && bfd_link_executable (info)))
10515 {
10516 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10517 srel->size += rel_size;
10518 }
10519 pent = &ent->next;
10520 }
10521 }
10522 else
10523 *pent = ent->next;
10524 }
10525
10526 /* Allocate space for plt calls to local syms. */
10527 lgot_masks = (unsigned char *) end_local_plt;
10528 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10529 {
10530 struct plt_entry *ent;
10531
10532 for (ent = *local_plt; ent != NULL; ent = ent->next)
10533 if (ent->plt.refcount > 0)
10534 {
10535 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10536 {
10537 s = htab->elf.iplt;
10538 ent->plt.offset = s->size;
10539 s->size += PLT_ENTRY_SIZE (htab);
10540 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10541 }
10542 else if (htab->can_convert_all_inline_plt
10543 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10544 ent->plt.offset = (bfd_vma) -1;
10545 else
10546 {
10547 s = htab->pltlocal;
10548 ent->plt.offset = s->size;
10549 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10550 if (bfd_link_pic (info))
10551 htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10552 }
10553 }
10554 else
10555 ent->plt.offset = (bfd_vma) -1;
10556 }
10557 }
10558
10559 /* Allocate global sym .plt and .got entries, and space for global
10560 sym dynamic relocs. */
10561 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10562
10563 if (!htab->opd_abi && !bfd_link_pic (info))
10564 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10565
10566 first_tlsld = NULL;
10567 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10568 {
10569 struct got_entry *ent;
10570
10571 if (!is_ppc64_elf (ibfd))
10572 continue;
10573
10574 ent = ppc64_tlsld_got (ibfd);
10575 if (ent->got.refcount > 0)
10576 {
10577 if (!htab->do_multi_toc && first_tlsld != NULL)
10578 {
10579 ent->is_indirect = TRUE;
10580 ent->got.ent = first_tlsld;
10581 }
10582 else
10583 {
10584 if (first_tlsld == NULL)
10585 first_tlsld = ent;
10586 s = ppc64_elf_tdata (ibfd)->got;
10587 ent->got.offset = s->size;
10588 ent->owner = ibfd;
10589 s->size += 16;
10590 if (bfd_link_pic (info))
10591 {
10592 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10593 srel->size += sizeof (Elf64_External_Rela);
10594 }
10595 }
10596 }
10597 else
10598 ent->got.offset = (bfd_vma) -1;
10599 }
10600
10601 /* We now have determined the sizes of the various dynamic sections.
10602 Allocate memory for them. */
10603 relocs = FALSE;
10604 for (s = dynobj->sections; s != NULL; s = s->next)
10605 {
10606 if ((s->flags & SEC_LINKER_CREATED) == 0)
10607 continue;
10608
10609 if (s == htab->brlt || s == htab->relbrlt)
10610 /* These haven't been allocated yet; don't strip. */
10611 continue;
10612 else if (s == htab->elf.sgot
10613 || s == htab->elf.splt
10614 || s == htab->elf.iplt
10615 || s == htab->pltlocal
10616 || s == htab->glink
10617 || s == htab->global_entry
10618 || s == htab->elf.sdynbss
10619 || s == htab->elf.sdynrelro)
10620 {
10621 /* Strip this section if we don't need it; see the
10622 comment below. */
10623 }
10624 else if (s == htab->glink_eh_frame)
10625 {
10626 if (!bfd_is_abs_section (s->output_section))
10627 /* Not sized yet. */
10628 continue;
10629 }
10630 else if (CONST_STRNEQ (s->name, ".rela"))
10631 {
10632 if (s->size != 0)
10633 {
10634 if (s != htab->elf.srelplt)
10635 relocs = TRUE;
10636
10637 /* We use the reloc_count field as a counter if we need
10638 to copy relocs into the output file. */
10639 s->reloc_count = 0;
10640 }
10641 }
10642 else
10643 {
10644 /* It's not one of our sections, so don't allocate space. */
10645 continue;
10646 }
10647
10648 if (s->size == 0)
10649 {
10650 /* If we don't need this section, strip it from the
10651 output file. This is mostly to handle .rela.bss and
10652 .rela.plt. We must create both sections in
10653 create_dynamic_sections, because they must be created
10654 before the linker maps input sections to output
10655 sections. The linker does that before
10656 adjust_dynamic_symbol is called, and it is that
10657 function which decides whether anything needs to go
10658 into these sections. */
10659 s->flags |= SEC_EXCLUDE;
10660 continue;
10661 }
10662
10663 if (bfd_is_abs_section (s->output_section))
10664 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10665 s->name);
10666
10667 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10668 continue;
10669
10670 /* Allocate memory for the section contents. We use bfd_zalloc
10671 here in case unused entries are not reclaimed before the
10672 section's contents are written out. This should not happen,
10673 but this way if it does we get a R_PPC64_NONE reloc in .rela
10674 sections instead of garbage.
10675 We also rely on the section contents being zero when writing
10676 the GOT and .dynrelro. */
10677 s->contents = bfd_zalloc (dynobj, s->size);
10678 if (s->contents == NULL)
10679 return FALSE;
10680 }
10681
10682 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10683 {
10684 if (!is_ppc64_elf (ibfd))
10685 continue;
10686
10687 s = ppc64_elf_tdata (ibfd)->got;
10688 if (s != NULL && s != htab->elf.sgot)
10689 {
10690 if (s->size == 0)
10691 s->flags |= SEC_EXCLUDE;
10692 else
10693 {
10694 s->contents = bfd_zalloc (ibfd, s->size);
10695 if (s->contents == NULL)
10696 return FALSE;
10697 }
10698 }
10699 s = ppc64_elf_tdata (ibfd)->relgot;
10700 if (s != NULL)
10701 {
10702 if (s->size == 0)
10703 s->flags |= SEC_EXCLUDE;
10704 else
10705 {
10706 s->contents = bfd_zalloc (ibfd, s->size);
10707 if (s->contents == NULL)
10708 return FALSE;
10709 relocs = TRUE;
10710 s->reloc_count = 0;
10711 }
10712 }
10713 }
10714
10715 if (htab->elf.dynamic_sections_created)
10716 {
10717 bfd_boolean tls_opt;
10718
10719 /* Add some entries to the .dynamic section. We fill in the
10720 values later, in ppc64_elf_finish_dynamic_sections, but we
10721 must add the entries now so that we get the correct size for
10722 the .dynamic section. The DT_DEBUG entry is filled in by the
10723 dynamic linker and used by the debugger. */
10724 #define add_dynamic_entry(TAG, VAL) \
10725 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10726
10727 if (bfd_link_executable (info))
10728 {
10729 if (!add_dynamic_entry (DT_DEBUG, 0))
10730 return FALSE;
10731 }
10732
10733 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10734 {
10735 if (!add_dynamic_entry (DT_PLTGOT, 0)
10736 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10737 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10738 || !add_dynamic_entry (DT_JMPREL, 0)
10739 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10740 return FALSE;
10741 }
10742
10743 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10744 {
10745 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10746 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10747 return FALSE;
10748 }
10749
10750 tls_opt = (htab->params->tls_get_addr_opt
10751 && htab->tls_get_addr_fd != NULL
10752 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10753 if (tls_opt || !htab->opd_abi)
10754 {
10755 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10756 return FALSE;
10757 }
10758
10759 if (relocs)
10760 {
10761 if (!add_dynamic_entry (DT_RELA, 0)
10762 || !add_dynamic_entry (DT_RELASZ, 0)
10763 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10764 return FALSE;
10765
10766 /* If any dynamic relocs apply to a read-only section,
10767 then we need a DT_TEXTREL entry. */
10768 if ((info->flags & DF_TEXTREL) == 0)
10769 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10770
10771 if ((info->flags & DF_TEXTREL) != 0)
10772 {
10773 if (!add_dynamic_entry (DT_TEXTREL, 0))
10774 return FALSE;
10775 }
10776 }
10777 }
10778 #undef add_dynamic_entry
10779
10780 return TRUE;
10781 }
10782
10783 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10784
10785 static bfd_boolean
10786 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10787 {
10788 if (h->plt.plist != NULL
10789 && !h->def_regular
10790 && !h->pointer_equality_needed)
10791 return FALSE;
10792
10793 return _bfd_elf_hash_symbol (h);
10794 }
10795
10796 /* Determine the type of stub needed, if any, for a call. */
10797
10798 static inline enum ppc_stub_type
10799 ppc_type_of_stub (asection *input_sec,
10800 const Elf_Internal_Rela *rel,
10801 struct ppc_link_hash_entry **hash,
10802 struct plt_entry **plt_ent,
10803 bfd_vma destination,
10804 unsigned long local_off)
10805 {
10806 struct ppc_link_hash_entry *h = *hash;
10807 bfd_vma location;
10808 bfd_vma branch_offset;
10809 bfd_vma max_branch_offset;
10810 enum elf_ppc64_reloc_type r_type;
10811
10812 if (h != NULL)
10813 {
10814 struct plt_entry *ent;
10815 struct ppc_link_hash_entry *fdh = h;
10816 if (h->oh != NULL
10817 && h->oh->is_func_descriptor)
10818 {
10819 fdh = ppc_follow_link (h->oh);
10820 *hash = fdh;
10821 }
10822
10823 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10824 if (ent->addend == rel->r_addend
10825 && ent->plt.offset != (bfd_vma) -1)
10826 {
10827 *plt_ent = ent;
10828 return ppc_stub_plt_call;
10829 }
10830
10831 /* Here, we know we don't have a plt entry. If we don't have a
10832 either a defined function descriptor or a defined entry symbol
10833 in a regular object file, then it is pointless trying to make
10834 any other type of stub. */
10835 if (!is_static_defined (&fdh->elf)
10836 && !is_static_defined (&h->elf))
10837 return ppc_stub_none;
10838 }
10839 else if (elf_local_got_ents (input_sec->owner) != NULL)
10840 {
10841 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10842 struct plt_entry **local_plt = (struct plt_entry **)
10843 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10844 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10845
10846 if (local_plt[r_symndx] != NULL)
10847 {
10848 struct plt_entry *ent;
10849
10850 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10851 if (ent->addend == rel->r_addend
10852 && ent->plt.offset != (bfd_vma) -1)
10853 {
10854 *plt_ent = ent;
10855 return ppc_stub_plt_call;
10856 }
10857 }
10858 }
10859
10860 /* Determine where the call point is. */
10861 location = (input_sec->output_offset
10862 + input_sec->output_section->vma
10863 + rel->r_offset);
10864
10865 branch_offset = destination - location;
10866 r_type = ELF64_R_TYPE (rel->r_info);
10867
10868 /* Determine if a long branch stub is needed. */
10869 max_branch_offset = 1 << 25;
10870 if (r_type == R_PPC64_REL14
10871 || r_type == R_PPC64_REL14_BRTAKEN
10872 || r_type == R_PPC64_REL14_BRNTAKEN)
10873 max_branch_offset = 1 << 15;
10874
10875 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10876 /* We need a stub. Figure out whether a long_branch or plt_branch
10877 is needed later. */
10878 return ppc_stub_long_branch;
10879
10880 return ppc_stub_none;
10881 }
10882
10883 /* Builds a 64-bit offset in r12 then adds it to r11 (LOAD false) or
10884 loads r12 from r11+r12 (LOAD true).
10885 . lis %r12,xxx-1b@highest
10886 . ori %r12,xxx-1b@higher
10887 . sldi %r12,%r12,32
10888 . oris %r12,%r12,xxx-1b@hi
10889 . ori %r12,%r12,xxx-1b@l
10890 . add %r12,%r11,%r12 */
10891
10892 static bfd_byte *
10893 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10894 {
10895 if (off + 0x8000 < 0x10000)
10896 {
10897 if (load)
10898 bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10899 else
10900 bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10901 p += 4;
10902 }
10903 else if (off + 0x80008000ULL < 0x100000000ULL)
10904 {
10905 bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10906 p += 4;
10907 if (load)
10908 bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10909 else
10910 bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10911 p += 4;
10912 }
10913 else
10914 {
10915 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10916 {
10917 bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10918 p += 4;
10919 }
10920 else
10921 {
10922 bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10923 p += 4;
10924 if (((off >> 32) & 0xffff) != 0)
10925 {
10926 bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10927 p += 4;
10928 }
10929 }
10930 if (((off >> 32) & 0xffffffffULL) != 0)
10931 {
10932 bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10933 p += 4;
10934 }
10935 if (PPC_HI (off) != 0)
10936 {
10937 bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10938 p += 4;
10939 }
10940 if (PPC_LO (off) != 0)
10941 {
10942 bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10943 p += 4;
10944 }
10945 if (load)
10946 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10947 else
10948 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10949 p += 4;
10950 }
10951 return p;
10952 }
10953
10954 static unsigned int
10955 size_offset (bfd_vma off)
10956 {
10957 unsigned int size;
10958 if (off + 0x8000 < 0x10000)
10959 size = 4;
10960 else if (off + 0x80008000ULL < 0x100000000ULL)
10961 size = 8;
10962 else
10963 {
10964 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10965 size = 4;
10966 else
10967 {
10968 size = 4;
10969 if (((off >> 32) & 0xffff) != 0)
10970 size += 4;
10971 }
10972 if (((off >> 32) & 0xffffffffULL) != 0)
10973 size += 4;
10974 if (PPC_HI (off) != 0)
10975 size += 4;
10976 if (PPC_LO (off) != 0)
10977 size += 4;
10978 size += 4;
10979 }
10980 return size;
10981 }
10982
10983 /* Emit .eh_frame opcode to advance pc by DELTA. */
10984
10985 static bfd_byte *
10986 eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
10987 {
10988 delta /= 4;
10989 if (delta < 64)
10990 *eh++ = DW_CFA_advance_loc + delta;
10991 else if (delta < 256)
10992 {
10993 *eh++ = DW_CFA_advance_loc1;
10994 *eh++ = delta;
10995 }
10996 else if (delta < 65536)
10997 {
10998 *eh++ = DW_CFA_advance_loc2;
10999 bfd_put_16 (abfd, delta, eh);
11000 eh += 2;
11001 }
11002 else
11003 {
11004 *eh++ = DW_CFA_advance_loc4;
11005 bfd_put_32 (abfd, delta, eh);
11006 eh += 4;
11007 }
11008 return eh;
11009 }
11010
11011 /* Size of required .eh_frame opcode to advance pc by DELTA. */
11012
11013 static unsigned int
11014 eh_advance_size (unsigned int delta)
11015 {
11016 if (delta < 64 * 4)
11017 /* DW_CFA_advance_loc+[1..63]. */
11018 return 1;
11019 if (delta < 256 * 4)
11020 /* DW_CFA_advance_loc1, byte. */
11021 return 2;
11022 if (delta < 65536 * 4)
11023 /* DW_CFA_advance_loc2, 2 bytes. */
11024 return 3;
11025 /* DW_CFA_advance_loc4, 4 bytes. */
11026 return 5;
11027 }
11028
11029 /* With power7 weakly ordered memory model, it is possible for ld.so
11030 to update a plt entry in one thread and have another thread see a
11031 stale zero toc entry. To avoid this we need some sort of acquire
11032 barrier in the call stub. One solution is to make the load of the
11033 toc word seem to appear to depend on the load of the function entry
11034 word. Another solution is to test for r2 being zero, and branch to
11035 the appropriate glink entry if so.
11036
11037 . fake dep barrier compare
11038 . ld 12,xxx(2) ld 12,xxx(2)
11039 . mtctr 12 mtctr 12
11040 . xor 11,12,12 ld 2,xxx+8(2)
11041 . add 2,2,11 cmpldi 2,0
11042 . ld 2,xxx+8(2) bnectr+
11043 . bctr b <glink_entry>
11044
11045 The solution involving the compare turns out to be faster, so
11046 that's what we use unless the branch won't reach. */
11047
11048 #define ALWAYS_USE_FAKE_DEP 0
11049 #define ALWAYS_EMIT_R2SAVE 0
11050
11051 static inline unsigned int
11052 plt_stub_size (struct ppc_link_hash_table *htab,
11053 struct ppc_stub_hash_entry *stub_entry,
11054 bfd_vma off)
11055 {
11056 unsigned size;
11057
11058 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11059 {
11060 size = 24 + size_offset (off);
11061 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11062 size += 4;
11063 return size;
11064 }
11065
11066 size = 12;
11067 if (ALWAYS_EMIT_R2SAVE
11068 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11069 size += 4;
11070 if (PPC_HA (off) != 0)
11071 size += 4;
11072 if (htab->opd_abi)
11073 {
11074 size += 4;
11075 if (htab->params->plt_static_chain)
11076 size += 4;
11077 if (htab->params->plt_thread_safe
11078 && htab->elf.dynamic_sections_created
11079 && stub_entry->h != NULL
11080 && stub_entry->h->elf.dynindx != -1)
11081 size += 8;
11082 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
11083 size += 4;
11084 }
11085 if (stub_entry->h != NULL
11086 && (stub_entry->h == htab->tls_get_addr_fd
11087 || stub_entry->h == htab->tls_get_addr)
11088 && htab->params->tls_get_addr_opt)
11089 {
11090 size += 7 * 4;
11091 if (stub_entry->stub_type == ppc_stub_plt_call_r2save)
11092 size += 6 * 4;
11093 }
11094 return size;
11095 }
11096
11097 /* Depending on the sign of plt_stub_align:
11098 If positive, return the padding to align to a 2**plt_stub_align
11099 boundary.
11100 If negative, if this stub would cross fewer 2**plt_stub_align
11101 boundaries if we align, then return the padding needed to do so. */
11102
11103 static inline unsigned int
11104 plt_stub_pad (struct ppc_link_hash_table *htab,
11105 struct ppc_stub_hash_entry *stub_entry,
11106 bfd_vma plt_off)
11107 {
11108 int stub_align;
11109 unsigned stub_size;
11110 bfd_vma stub_off = stub_entry->group->stub_sec->size;
11111
11112 if (htab->params->plt_stub_align >= 0)
11113 {
11114 stub_align = 1 << htab->params->plt_stub_align;
11115 if ((stub_off & (stub_align - 1)) != 0)
11116 return stub_align - (stub_off & (stub_align - 1));
11117 return 0;
11118 }
11119
11120 stub_align = 1 << -htab->params->plt_stub_align;
11121 stub_size = plt_stub_size (htab, stub_entry, plt_off);
11122 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11123 > ((stub_size - 1) & -stub_align))
11124 return stub_align - (stub_off & (stub_align - 1));
11125 return 0;
11126 }
11127
11128 /* Build a .plt call stub. */
11129
11130 static inline bfd_byte *
11131 build_plt_stub (struct ppc_link_hash_table *htab,
11132 struct ppc_stub_hash_entry *stub_entry,
11133 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11134 {
11135 bfd *obfd = htab->params->stub_bfd;
11136 bfd_boolean plt_load_toc = htab->opd_abi;
11137 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
11138 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
11139 && htab->elf.dynamic_sections_created
11140 && stub_entry->h != NULL
11141 && stub_entry->h->elf.dynindx != -1);
11142 bfd_boolean use_fake_dep = plt_thread_safe;
11143 bfd_vma cmp_branch_off = 0;
11144
11145 if (!ALWAYS_USE_FAKE_DEP
11146 && plt_load_toc
11147 && plt_thread_safe
11148 && !((stub_entry->h == htab->tls_get_addr_fd
11149 || stub_entry->h == htab->tls_get_addr)
11150 && htab->params->tls_get_addr_opt))
11151 {
11152 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11153 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11154 / PLT_ENTRY_SIZE (htab));
11155 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11156 bfd_vma to, from;
11157
11158 if (pltindex > 32768)
11159 glinkoff += (pltindex - 32768) * 4;
11160 to = (glinkoff
11161 + htab->glink->output_offset
11162 + htab->glink->output_section->vma);
11163 from = (p - stub_entry->group->stub_sec->contents
11164 + 4 * (ALWAYS_EMIT_R2SAVE
11165 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11166 + 4 * (PPC_HA (offset) != 0)
11167 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11168 != PPC_HA (offset))
11169 + 4 * (plt_static_chain != 0)
11170 + 20
11171 + stub_entry->group->stub_sec->output_offset
11172 + stub_entry->group->stub_sec->output_section->vma);
11173 cmp_branch_off = to - from;
11174 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11175 }
11176
11177 if (PPC_HA (offset) != 0)
11178 {
11179 if (r != NULL)
11180 {
11181 if (ALWAYS_EMIT_R2SAVE
11182 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11183 r[0].r_offset += 4;
11184 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11185 r[1].r_offset = r[0].r_offset + 4;
11186 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11187 r[1].r_addend = r[0].r_addend;
11188 if (plt_load_toc)
11189 {
11190 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11191 {
11192 r[2].r_offset = r[1].r_offset + 4;
11193 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11194 r[2].r_addend = r[0].r_addend;
11195 }
11196 else
11197 {
11198 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11199 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11200 r[2].r_addend = r[0].r_addend + 8;
11201 if (plt_static_chain)
11202 {
11203 r[3].r_offset = r[2].r_offset + 4;
11204 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11205 r[3].r_addend = r[0].r_addend + 16;
11206 }
11207 }
11208 }
11209 }
11210 if (ALWAYS_EMIT_R2SAVE
11211 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11212 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11213 if (plt_load_toc)
11214 {
11215 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11216 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
11217 }
11218 else
11219 {
11220 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11221 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
11222 }
11223 if (plt_load_toc
11224 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11225 {
11226 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11227 offset = 0;
11228 }
11229 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11230 if (plt_load_toc)
11231 {
11232 if (use_fake_dep)
11233 {
11234 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
11235 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
11236 }
11237 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11238 if (plt_static_chain)
11239 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11240 }
11241 }
11242 else
11243 {
11244 if (r != NULL)
11245 {
11246 if (ALWAYS_EMIT_R2SAVE
11247 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11248 r[0].r_offset += 4;
11249 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11250 if (plt_load_toc)
11251 {
11252 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11253 {
11254 r[1].r_offset = r[0].r_offset + 4;
11255 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11256 r[1].r_addend = r[0].r_addend;
11257 }
11258 else
11259 {
11260 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11261 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11262 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11263 if (plt_static_chain)
11264 {
11265 r[2].r_offset = r[1].r_offset + 4;
11266 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11267 r[2].r_addend = r[0].r_addend + 8;
11268 }
11269 }
11270 }
11271 }
11272 if (ALWAYS_EMIT_R2SAVE
11273 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11274 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11275 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
11276 if (plt_load_toc
11277 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11278 {
11279 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
11280 offset = 0;
11281 }
11282 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11283 if (plt_load_toc)
11284 {
11285 if (use_fake_dep)
11286 {
11287 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
11288 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
11289 }
11290 if (plt_static_chain)
11291 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11292 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11293 }
11294 }
11295 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11296 {
11297 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
11298 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
11299 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11300 }
11301 else
11302 bfd_put_32 (obfd, BCTR, p), p += 4;
11303 return p;
11304 }
11305
11306 /* Build a special .plt call stub for __tls_get_addr. */
11307
11308 #define LD_R11_0R3 0xe9630000
11309 #define LD_R12_0R3 0xe9830000
11310 #define MR_R0_R3 0x7c601b78
11311 #define CMPDI_R11_0 0x2c2b0000
11312 #define ADD_R3_R12_R13 0x7c6c6a14
11313 #define BEQLR 0x4d820020
11314 #define MR_R3_R0 0x7c030378
11315 #define STD_R11_0R1 0xf9610000
11316 #define BCTRL 0x4e800421
11317 #define LD_R11_0R1 0xe9610000
11318 #define MTLR_R11 0x7d6803a6
11319
11320 static inline bfd_byte *
11321 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11322 struct ppc_stub_hash_entry *stub_entry,
11323 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11324 {
11325 bfd *obfd = htab->params->stub_bfd;
11326 bfd_byte *loc = p;
11327
11328 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
11329 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
11330 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
11331 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
11332 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
11333 bfd_put_32 (obfd, BEQLR, p), p += 4;
11334 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
11335 if (r != NULL)
11336 r[0].r_offset += 7 * 4;
11337 if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
11338 return build_plt_stub (htab, stub_entry, p, offset, r);
11339
11340 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
11341 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11342
11343 if (r != NULL)
11344 r[0].r_offset += 2 * 4;
11345 p = build_plt_stub (htab, stub_entry, p, offset, r);
11346 bfd_put_32 (obfd, BCTRL, p - 4);
11347
11348 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
11349 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11350 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
11351 bfd_put_32 (obfd, BLR, p), p += 4;
11352
11353 if (htab->glink_eh_frame != NULL
11354 && htab->glink_eh_frame->size != 0)
11355 {
11356 bfd_byte *base, *eh;
11357 unsigned int lr_used, delta;
11358
11359 base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
11360 eh = base + stub_entry->group->eh_size;
11361 lr_used = stub_entry->stub_offset + (p - 20 - loc);
11362 delta = lr_used - stub_entry->group->lr_restore;
11363 stub_entry->group->lr_restore = lr_used + 16;
11364 eh = eh_advance (htab->elf.dynobj, eh, delta);
11365 *eh++ = DW_CFA_offset_extended_sf;
11366 *eh++ = 65;
11367 *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
11368 *eh++ = DW_CFA_advance_loc + 4;
11369 *eh++ = DW_CFA_restore_extended;
11370 *eh++ = 65;
11371 stub_entry->group->eh_size = eh - base;
11372 }
11373 return p;
11374 }
11375
11376 static Elf_Internal_Rela *
11377 get_relocs (asection *sec, int count)
11378 {
11379 Elf_Internal_Rela *relocs;
11380 struct bfd_elf_section_data *elfsec_data;
11381
11382 elfsec_data = elf_section_data (sec);
11383 relocs = elfsec_data->relocs;
11384 if (relocs == NULL)
11385 {
11386 bfd_size_type relsize;
11387 relsize = sec->reloc_count * sizeof (*relocs);
11388 relocs = bfd_alloc (sec->owner, relsize);
11389 if (relocs == NULL)
11390 return NULL;
11391 elfsec_data->relocs = relocs;
11392 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11393 sizeof (Elf_Internal_Shdr));
11394 if (elfsec_data->rela.hdr == NULL)
11395 return NULL;
11396 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11397 * sizeof (Elf64_External_Rela));
11398 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11399 sec->reloc_count = 0;
11400 }
11401 relocs += sec->reloc_count;
11402 sec->reloc_count += count;
11403 return relocs;
11404 }
11405
11406 static bfd_vma
11407 get_r2off (struct bfd_link_info *info,
11408 struct ppc_stub_hash_entry *stub_entry)
11409 {
11410 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11411 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11412
11413 if (r2off == 0)
11414 {
11415 /* Support linking -R objects. Get the toc pointer from the
11416 opd entry. */
11417 char buf[8];
11418 if (!htab->opd_abi)
11419 return r2off;
11420 asection *opd = stub_entry->h->elf.root.u.def.section;
11421 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11422
11423 if (strcmp (opd->name, ".opd") != 0
11424 || opd->reloc_count != 0)
11425 {
11426 info->callbacks->einfo
11427 (_("%P: cannot find opd entry toc for `%pT'\n"),
11428 stub_entry->h->elf.root.root.string);
11429 bfd_set_error (bfd_error_bad_value);
11430 return (bfd_vma) -1;
11431 }
11432 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11433 return (bfd_vma) -1;
11434 r2off = bfd_get_64 (opd->owner, buf);
11435 r2off -= elf_gp (info->output_bfd);
11436 }
11437 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11438 return r2off;
11439 }
11440
11441 static bfd_boolean
11442 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11443 {
11444 struct ppc_stub_hash_entry *stub_entry;
11445 struct ppc_branch_hash_entry *br_entry;
11446 struct bfd_link_info *info;
11447 struct ppc_link_hash_table *htab;
11448 bfd_byte *loc;
11449 bfd_byte *p;
11450 bfd_vma targ, off;
11451 Elf_Internal_Rela *r;
11452 asection *plt;
11453
11454 /* Massage our args to the form they really have. */
11455 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11456 info = in_arg;
11457
11458 htab = ppc_hash_table (info);
11459 if (htab == NULL)
11460 return FALSE;
11461
11462 BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11463 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11464
11465 htab->stub_count[stub_entry->stub_type - 1] += 1;
11466 switch (stub_entry->stub_type)
11467 {
11468 case ppc_stub_long_branch:
11469 case ppc_stub_long_branch_r2off:
11470 /* Branches are relative. This is where we are going to. */
11471 targ = (stub_entry->target_value
11472 + stub_entry->target_section->output_offset
11473 + stub_entry->target_section->output_section->vma);
11474 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11475
11476 /* And this is where we are coming from. */
11477 off = (stub_entry->stub_offset
11478 + stub_entry->group->stub_sec->output_offset
11479 + stub_entry->group->stub_sec->output_section->vma);
11480 off = targ - off;
11481
11482 p = loc;
11483 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11484 {
11485 bfd_vma r2off = get_r2off (info, stub_entry);
11486
11487 if (r2off == (bfd_vma) -1)
11488 {
11489 htab->stub_error = TRUE;
11490 return FALSE;
11491 }
11492 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11493 p += 4;
11494 if (PPC_HA (r2off) != 0)
11495 {
11496 bfd_put_32 (htab->params->stub_bfd,
11497 ADDIS_R2_R2 | PPC_HA (r2off), p);
11498 p += 4;
11499 }
11500 if (PPC_LO (r2off) != 0)
11501 {
11502 bfd_put_32 (htab->params->stub_bfd,
11503 ADDI_R2_R2 | PPC_LO (r2off), p);
11504 p += 4;
11505 }
11506 off -= p - loc;
11507 }
11508 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11509 p += 4;
11510
11511 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11512 {
11513 _bfd_error_handler
11514 (_("long branch stub `%s' offset overflow"),
11515 stub_entry->root.string);
11516 htab->stub_error = TRUE;
11517 return FALSE;
11518 }
11519
11520 if (info->emitrelocations)
11521 {
11522 r = get_relocs (stub_entry->group->stub_sec, 1);
11523 if (r == NULL)
11524 return FALSE;
11525 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11526 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11527 r->r_addend = targ;
11528 if (stub_entry->h != NULL)
11529 {
11530 struct elf_link_hash_entry **hashes;
11531 unsigned long symndx;
11532 struct ppc_link_hash_entry *h;
11533
11534 hashes = elf_sym_hashes (htab->params->stub_bfd);
11535 if (hashes == NULL)
11536 {
11537 bfd_size_type hsize;
11538
11539 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11540 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11541 if (hashes == NULL)
11542 return FALSE;
11543 elf_sym_hashes (htab->params->stub_bfd) = hashes;
11544 htab->stub_globals = 1;
11545 }
11546 symndx = htab->stub_globals++;
11547 h = stub_entry->h;
11548 hashes[symndx] = &h->elf;
11549 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11550 if (h->oh != NULL && h->oh->is_func)
11551 h = ppc_follow_link (h->oh);
11552 if (h->elf.root.u.def.section != stub_entry->target_section)
11553 /* H is an opd symbol. The addend must be zero. */
11554 r->r_addend = 0;
11555 else
11556 {
11557 off = (h->elf.root.u.def.value
11558 + h->elf.root.u.def.section->output_offset
11559 + h->elf.root.u.def.section->output_section->vma);
11560 r->r_addend -= off;
11561 }
11562 }
11563 }
11564 break;
11565
11566 case ppc_stub_plt_branch:
11567 case ppc_stub_plt_branch_r2off:
11568 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11569 stub_entry->root.string + 9,
11570 FALSE, FALSE);
11571 if (br_entry == NULL)
11572 {
11573 _bfd_error_handler (_("can't find branch stub `%s'"),
11574 stub_entry->root.string);
11575 htab->stub_error = TRUE;
11576 return FALSE;
11577 }
11578
11579 targ = (stub_entry->target_value
11580 + stub_entry->target_section->output_offset
11581 + stub_entry->target_section->output_section->vma);
11582 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11583 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11584
11585 bfd_put_64 (htab->brlt->owner, targ,
11586 htab->brlt->contents + br_entry->offset);
11587
11588 if (br_entry->iter == htab->stub_iteration)
11589 {
11590 br_entry->iter = 0;
11591
11592 if (htab->relbrlt != NULL)
11593 {
11594 /* Create a reloc for the branch lookup table entry. */
11595 Elf_Internal_Rela rela;
11596 bfd_byte *rl;
11597
11598 rela.r_offset = (br_entry->offset
11599 + htab->brlt->output_offset
11600 + htab->brlt->output_section->vma);
11601 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11602 rela.r_addend = targ;
11603
11604 rl = htab->relbrlt->contents;
11605 rl += (htab->relbrlt->reloc_count++
11606 * sizeof (Elf64_External_Rela));
11607 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11608 }
11609 else if (info->emitrelocations)
11610 {
11611 r = get_relocs (htab->brlt, 1);
11612 if (r == NULL)
11613 return FALSE;
11614 /* brlt, being SEC_LINKER_CREATED does not go through the
11615 normal reloc processing. Symbols and offsets are not
11616 translated from input file to output file form, so
11617 set up the offset per the output file. */
11618 r->r_offset = (br_entry->offset
11619 + htab->brlt->output_offset
11620 + htab->brlt->output_section->vma);
11621 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11622 r->r_addend = targ;
11623 }
11624 }
11625
11626 targ = (br_entry->offset
11627 + htab->brlt->output_offset
11628 + htab->brlt->output_section->vma);
11629
11630 off = (elf_gp (info->output_bfd)
11631 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11632 off = targ - off;
11633
11634 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11635 {
11636 info->callbacks->einfo
11637 (_("%P: linkage table error against `%pT'\n"),
11638 stub_entry->root.string);
11639 bfd_set_error (bfd_error_bad_value);
11640 htab->stub_error = TRUE;
11641 return FALSE;
11642 }
11643
11644 if (info->emitrelocations)
11645 {
11646 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11647 if (r == NULL)
11648 return FALSE;
11649 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11650 if (bfd_big_endian (info->output_bfd))
11651 r[0].r_offset += 2;
11652 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11653 r[0].r_offset += 4;
11654 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11655 r[0].r_addend = targ;
11656 if (PPC_HA (off) != 0)
11657 {
11658 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11659 r[1].r_offset = r[0].r_offset + 4;
11660 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11661 r[1].r_addend = r[0].r_addend;
11662 }
11663 }
11664
11665 p = loc;
11666 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11667 {
11668 if (PPC_HA (off) != 0)
11669 {
11670 bfd_put_32 (htab->params->stub_bfd,
11671 ADDIS_R12_R2 | PPC_HA (off), p);
11672 p += 4;
11673 bfd_put_32 (htab->params->stub_bfd,
11674 LD_R12_0R12 | PPC_LO (off), p);
11675 }
11676 else
11677 bfd_put_32 (htab->params->stub_bfd,
11678 LD_R12_0R2 | PPC_LO (off), p);
11679 }
11680 else
11681 {
11682 bfd_vma r2off = get_r2off (info, stub_entry);
11683
11684 if (r2off == (bfd_vma) -1)
11685 {
11686 htab->stub_error = TRUE;
11687 return FALSE;
11688 }
11689
11690 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11691 p += 4;
11692 if (PPC_HA (off) != 0)
11693 {
11694 bfd_put_32 (htab->params->stub_bfd,
11695 ADDIS_R12_R2 | PPC_HA (off), p);
11696 p += 4;
11697 bfd_put_32 (htab->params->stub_bfd,
11698 LD_R12_0R12 | PPC_LO (off), p);
11699 }
11700 else
11701 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11702
11703 if (PPC_HA (r2off) != 0)
11704 {
11705 p += 4;
11706 bfd_put_32 (htab->params->stub_bfd,
11707 ADDIS_R2_R2 | PPC_HA (r2off), p);
11708 }
11709 if (PPC_LO (r2off) != 0)
11710 {
11711 p += 4;
11712 bfd_put_32 (htab->params->stub_bfd,
11713 ADDI_R2_R2 | PPC_LO (r2off), p);
11714 }
11715 }
11716 p += 4;
11717 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11718 p += 4;
11719 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11720 p += 4;
11721 break;
11722
11723 case ppc_stub_long_branch_notoc:
11724 case ppc_stub_long_branch_both:
11725 case ppc_stub_plt_branch_notoc:
11726 case ppc_stub_plt_branch_both:
11727 case ppc_stub_plt_call_notoc:
11728 case ppc_stub_plt_call_both:
11729 p = loc;
11730 off = (8 + stub_entry->stub_offset
11731 + stub_entry->group->stub_sec->output_offset
11732 + stub_entry->group->stub_sec->output_section->vma);
11733 if (stub_entry->stub_type == ppc_stub_long_branch_both
11734 || stub_entry->stub_type == ppc_stub_plt_branch_both
11735 || stub_entry->stub_type == ppc_stub_plt_call_both)
11736 {
11737 off += 4;
11738 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11739 p += 4;
11740 }
11741 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11742 {
11743 targ = stub_entry->plt_ent->plt.offset & ~1;
11744 if (targ >= (bfd_vma) -2)
11745 abort ();
11746
11747 plt = htab->elf.splt;
11748 if (!htab->elf.dynamic_sections_created
11749 || stub_entry->h == NULL
11750 || stub_entry->h->elf.dynindx == -1)
11751 {
11752 if (stub_entry->symtype == STT_GNU_IFUNC)
11753 plt = htab->elf.iplt;
11754 else
11755 plt = htab->pltlocal;
11756 }
11757 targ += plt->output_offset + plt->output_section->vma;
11758 }
11759 else
11760 targ = (stub_entry->target_value
11761 + stub_entry->target_section->output_offset
11762 + stub_entry->target_section->output_section->vma);
11763 off = targ - off;
11764 bfd_put_32 (htab->params->stub_bfd, MFLR_R12, p);
11765 p += 4;
11766 bfd_put_32 (htab->params->stub_bfd, BCL_20_31, p);
11767 p += 4;
11768 bfd_put_32 (htab->params->stub_bfd, MFLR_R11, p);
11769 p += 4;
11770 bfd_put_32 (htab->params->stub_bfd, MTLR_R12, p);
11771 p += 4;
11772 p = build_offset (htab->params->stub_bfd, p, off,
11773 stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11774 if (stub_entry->stub_type == ppc_stub_long_branch_notoc)
11775 {
11776 off += 8;
11777 bfd_put_32 (htab->params->stub_bfd,
11778 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11779 }
11780 else if (stub_entry->stub_type == ppc_stub_long_branch_both)
11781 {
11782 off += 12;
11783 bfd_put_32 (htab->params->stub_bfd,
11784 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11785 }
11786 else
11787 {
11788 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11789 p += 4;
11790 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11791 }
11792 p += 4;
11793
11794 if (htab->glink_eh_frame != NULL
11795 && htab->glink_eh_frame->size != 0)
11796 {
11797 bfd_byte *base, *eh;
11798 unsigned int lr_used, delta;
11799
11800 base = (htab->glink_eh_frame->contents
11801 + stub_entry->group->eh_base + 17);
11802 eh = base + stub_entry->group->eh_size;
11803 lr_used = stub_entry->stub_offset + 8;
11804 if (stub_entry->stub_type == ppc_stub_long_branch_both
11805 || stub_entry->stub_type == ppc_stub_plt_branch_both
11806 || stub_entry->stub_type == ppc_stub_plt_call_both)
11807 lr_used += 4;
11808 delta = lr_used - stub_entry->group->lr_restore;
11809 stub_entry->group->lr_restore = lr_used + 8;
11810 eh = eh_advance (htab->elf.dynobj, eh, delta);
11811 *eh++ = DW_CFA_register;
11812 *eh++ = 65;
11813 *eh++ = 12;
11814 *eh++ = DW_CFA_advance_loc + 2;
11815 *eh++ = DW_CFA_restore_extended;
11816 *eh++ = 65;
11817 stub_entry->group->eh_size = eh - base;
11818 }
11819 break;
11820
11821 case ppc_stub_plt_call:
11822 case ppc_stub_plt_call_r2save:
11823 if (stub_entry->h != NULL
11824 && stub_entry->h->is_func_descriptor
11825 && stub_entry->h->oh != NULL)
11826 {
11827 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11828
11829 /* If the old-ABI "dot-symbol" is undefined make it weak so
11830 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11831 if (fh->elf.root.type == bfd_link_hash_undefined
11832 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11833 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11834 fh->elf.root.type = bfd_link_hash_undefweak;
11835 }
11836
11837 /* Now build the stub. */
11838 targ = stub_entry->plt_ent->plt.offset & ~1;
11839 if (targ >= (bfd_vma) -2)
11840 abort ();
11841
11842 plt = htab->elf.splt;
11843 if (!htab->elf.dynamic_sections_created
11844 || stub_entry->h == NULL
11845 || stub_entry->h->elf.dynindx == -1)
11846 {
11847 if (stub_entry->symtype == STT_GNU_IFUNC)
11848 plt = htab->elf.iplt;
11849 else
11850 plt = htab->pltlocal;
11851 }
11852 targ += plt->output_offset + plt->output_section->vma;
11853
11854 off = (elf_gp (info->output_bfd)
11855 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11856 off = targ - off;
11857
11858 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11859 {
11860 info->callbacks->einfo
11861 /* xgettext:c-format */
11862 (_("%P: linkage table error against `%pT'\n"),
11863 stub_entry->h != NULL
11864 ? stub_entry->h->elf.root.root.string
11865 : "<local sym>");
11866 bfd_set_error (bfd_error_bad_value);
11867 htab->stub_error = TRUE;
11868 return FALSE;
11869 }
11870
11871 r = NULL;
11872 if (info->emitrelocations)
11873 {
11874 r = get_relocs (stub_entry->group->stub_sec,
11875 ((PPC_HA (off) != 0)
11876 + (htab->opd_abi
11877 ? 2 + (htab->params->plt_static_chain
11878 && PPC_HA (off + 16) == PPC_HA (off))
11879 : 1)));
11880 if (r == NULL)
11881 return FALSE;
11882 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11883 if (bfd_big_endian (info->output_bfd))
11884 r[0].r_offset += 2;
11885 r[0].r_addend = targ;
11886 }
11887 if (stub_entry->h != NULL
11888 && (stub_entry->h == htab->tls_get_addr_fd
11889 || stub_entry->h == htab->tls_get_addr)
11890 && htab->params->tls_get_addr_opt)
11891 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11892 else
11893 p = build_plt_stub (htab, stub_entry, loc, off, r);
11894 break;
11895
11896 case ppc_stub_save_res:
11897 return TRUE;
11898
11899 default:
11900 BFD_FAIL ();
11901 return FALSE;
11902 }
11903
11904 stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11905
11906 if (htab->params->emit_stub_syms)
11907 {
11908 struct elf_link_hash_entry *h;
11909 size_t len1, len2;
11910 char *name;
11911 const char *const stub_str[] = { "long_branch",
11912 "long_branch",
11913 "long_branch",
11914 "long_branch",
11915 "plt_branch",
11916 "plt_branch",
11917 "plt_branch",
11918 "plt_branch",
11919 "plt_call",
11920 "plt_call",
11921 "plt_call",
11922 "plt_call" };
11923
11924 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11925 len2 = strlen (stub_entry->root.string);
11926 name = bfd_malloc (len1 + len2 + 2);
11927 if (name == NULL)
11928 return FALSE;
11929 memcpy (name, stub_entry->root.string, 9);
11930 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11931 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11932 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11933 if (h == NULL)
11934 return FALSE;
11935 if (h->root.type == bfd_link_hash_new)
11936 {
11937 h->root.type = bfd_link_hash_defined;
11938 h->root.u.def.section = stub_entry->group->stub_sec;
11939 h->root.u.def.value = stub_entry->stub_offset;
11940 h->ref_regular = 1;
11941 h->def_regular = 1;
11942 h->ref_regular_nonweak = 1;
11943 h->forced_local = 1;
11944 h->non_elf = 0;
11945 h->root.linker_def = 1;
11946 }
11947 }
11948
11949 return TRUE;
11950 }
11951
11952 /* As above, but don't actually build the stub. Just bump offset so
11953 we know stub section sizes, and select plt_branch stubs where
11954 long_branch stubs won't do. */
11955
11956 static bfd_boolean
11957 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11958 {
11959 struct ppc_stub_hash_entry *stub_entry;
11960 struct bfd_link_info *info;
11961 struct ppc_link_hash_table *htab;
11962 bfd_vma targ, off;
11963 int size;
11964
11965 /* Massage our args to the form they really have. */
11966 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11967 info = in_arg;
11968
11969 htab = ppc_hash_table (info);
11970 if (htab == NULL)
11971 return FALSE;
11972
11973 /* Make a note of the offset within the stubs for this entry. */
11974 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11975
11976 if (stub_entry->h != NULL
11977 && stub_entry->h->save_res
11978 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11979 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11980 {
11981 /* Don't make stubs to out-of-line register save/restore
11982 functions. Instead, emit copies of the functions. */
11983 stub_entry->group->needs_save_res = 1;
11984 stub_entry->stub_type = ppc_stub_save_res;
11985 return TRUE;
11986 }
11987
11988 if (stub_entry->stub_type >= ppc_stub_plt_call
11989 && stub_entry->stub_type <= ppc_stub_plt_call_both)
11990 {
11991 asection *plt;
11992 targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11993 if (targ >= (bfd_vma) -2)
11994 abort ();
11995 plt = htab->elf.splt;
11996 if (!htab->elf.dynamic_sections_created
11997 || stub_entry->h == NULL
11998 || stub_entry->h->elf.dynindx == -1)
11999 {
12000 if (stub_entry->symtype == STT_GNU_IFUNC)
12001 plt = htab->elf.iplt;
12002 else
12003 plt = htab->pltlocal;
12004 }
12005 targ += plt->output_offset + plt->output_section->vma;
12006
12007 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12008 {
12009 off = (8 + stub_entry->stub_offset
12010 + stub_entry->group->stub_sec->output_offset
12011 + stub_entry->group->stub_sec->output_section->vma);
12012 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12013 off += 4;
12014 }
12015 else
12016 off = (elf_gp (info->output_bfd)
12017 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12018
12019 if (htab->params->plt_stub_align != 0)
12020 {
12021 unsigned pad = plt_stub_pad (htab, stub_entry, targ - off);
12022
12023 stub_entry->group->stub_sec->size += pad;
12024 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
12025 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12026 off += pad;
12027 }
12028
12029 off = targ - off;
12030 size = plt_stub_size (htab, stub_entry, off);
12031
12032 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12033 {
12034 /* After the bcl, lr has been modified so we need to emit
12035 .eh_frame info saying the return address is in r12. */
12036 unsigned int lr_used = stub_entry->stub_offset + 8;
12037 unsigned int delta;
12038 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12039 lr_used += 4;
12040 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12041 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12042 DW_CFA_restore_extended 65. */
12043 delta = lr_used - stub_entry->group->lr_restore;
12044 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12045 stub_entry->group->lr_restore = lr_used + 8;
12046 }
12047 else
12048 {
12049 if (stub_entry->h != NULL
12050 && (stub_entry->h == htab->tls_get_addr_fd
12051 || stub_entry->h == htab->tls_get_addr)
12052 && htab->params->tls_get_addr_opt
12053 && stub_entry->stub_type == ppc_stub_plt_call_r2save)
12054 {
12055 /* After the bctrl, lr has been modified so we need to
12056 emit .eh_frame info saying the return address is
12057 on the stack. In fact we put the EH info specifying
12058 that the return address is on the stack *at* the
12059 call rather than after it, because the EH info for a
12060 call needs to be specified by that point.
12061 See libgcc/unwind-dw2.c execute_cfa_program. */
12062 unsigned int lr_used = stub_entry->stub_offset + size - 20;
12063 unsigned int delta;
12064 /* The eh_frame info will consist of a DW_CFA_advance_loc
12065 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12066 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12067 delta = lr_used - stub_entry->group->lr_restore;
12068 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12069 stub_entry->group->lr_restore = size - 4;
12070 }
12071
12072 if (info->emitrelocations)
12073 {
12074 stub_entry->group->stub_sec->reloc_count
12075 += ((PPC_HA (off) != 0)
12076 + (htab->opd_abi
12077 ? 2 + (htab->params->plt_static_chain
12078 && PPC_HA (off + 16) == PPC_HA (off))
12079 : 1));
12080 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12081 }
12082 }
12083 }
12084 else
12085 {
12086 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
12087 variants. */
12088 bfd_vma r2off = 0;
12089 bfd_vma local_off = 0;
12090
12091 targ = (stub_entry->target_value
12092 + stub_entry->target_section->output_offset
12093 + stub_entry->target_section->output_section->vma);
12094 off = (stub_entry->stub_offset
12095 + stub_entry->group->stub_sec->output_offset
12096 + stub_entry->group->stub_sec->output_section->vma);
12097
12098 /* Reset the stub type from the plt variant in case we now
12099 can reach with a shorter stub. */
12100 if (stub_entry->stub_type >= ppc_stub_plt_branch)
12101 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
12102
12103 size = 4;
12104 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
12105 {
12106 r2off = get_r2off (info, stub_entry);
12107 if (r2off == (bfd_vma) -1)
12108 {
12109 htab->stub_error = TRUE;
12110 return FALSE;
12111 }
12112 size = 8;
12113 if (PPC_HA (r2off) != 0)
12114 size += 4;
12115 if (PPC_LO (r2off) != 0)
12116 size += 4;
12117 off += size - 4;
12118 }
12119 else if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12120 {
12121 size = 20 + size_offset (targ - (off + 8));
12122 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12123 size += 4;
12124 off += size - 4;
12125 }
12126 off = targ - off;
12127
12128 if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12129 {
12130 /* After the bcl, lr has been modified so we need to emit
12131 .eh_frame info saying the return address is in r12. */
12132 unsigned int lr_used = stub_entry->stub_offset + 8;
12133 unsigned int delta;
12134 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12135 lr_used += 4;
12136 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12137 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12138 DW_CFA_restore_extended 65. */
12139 delta = lr_used - stub_entry->group->lr_restore;
12140 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12141 stub_entry->group->lr_restore = lr_used + 8;
12142
12143 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
12144 {
12145 stub_entry->stub_type += (ppc_stub_plt_branch_notoc
12146 - ppc_stub_long_branch_notoc);
12147 size += 4;
12148 }
12149 }
12150 else
12151 {
12152 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12153
12154 /* If the branch offset is too big, use a ppc_stub_plt_branch.
12155 Do the same for -R objects without function descriptors. */
12156 if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
12157 && r2off == 0
12158 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12159 || off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off)
12160 {
12161 struct ppc_branch_hash_entry *br_entry;
12162
12163 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12164 stub_entry->root.string + 9,
12165 TRUE, FALSE);
12166 if (br_entry == NULL)
12167 {
12168 _bfd_error_handler (_("can't build branch stub `%s'"),
12169 stub_entry->root.string);
12170 htab->stub_error = TRUE;
12171 return FALSE;
12172 }
12173
12174 if (br_entry->iter != htab->stub_iteration)
12175 {
12176 br_entry->iter = htab->stub_iteration;
12177 br_entry->offset = htab->brlt->size;
12178 htab->brlt->size += 8;
12179
12180 if (htab->relbrlt != NULL)
12181 htab->relbrlt->size += sizeof (Elf64_External_Rela);
12182 else if (info->emitrelocations)
12183 {
12184 htab->brlt->reloc_count += 1;
12185 htab->brlt->flags |= SEC_RELOC;
12186 }
12187 }
12188
12189 targ = (br_entry->offset
12190 + htab->brlt->output_offset
12191 + htab->brlt->output_section->vma);
12192 off = (elf_gp (info->output_bfd)
12193 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12194 off = targ - off;
12195
12196 if (info->emitrelocations)
12197 {
12198 stub_entry->group->stub_sec->reloc_count
12199 += 1 + (PPC_HA (off) != 0);
12200 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12201 }
12202
12203 stub_entry->stub_type
12204 += ppc_stub_plt_branch - ppc_stub_long_branch;
12205 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
12206 {
12207 size = 12;
12208 if (PPC_HA (off) != 0)
12209 size = 16;
12210 }
12211 else
12212 {
12213 size = 16;
12214 if (PPC_HA (off) != 0)
12215 size += 4;
12216
12217 if (PPC_HA (r2off) != 0)
12218 size += 4;
12219 if (PPC_LO (r2off) != 0)
12220 size += 4;
12221 }
12222 }
12223 else if (info->emitrelocations)
12224 {
12225 stub_entry->group->stub_sec->reloc_count += 1;
12226 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12227 }
12228 }
12229 }
12230
12231 stub_entry->group->stub_sec->size += size;
12232 return TRUE;
12233 }
12234
12235 /* Set up various things so that we can make a list of input sections
12236 for each output section included in the link. Returns -1 on error,
12237 0 when no stubs will be needed, and 1 on success. */
12238
12239 int
12240 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12241 {
12242 unsigned int id;
12243 bfd_size_type amt;
12244 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12245
12246 if (htab == NULL)
12247 return -1;
12248
12249 htab->sec_info_arr_size = _bfd_section_id;
12250 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12251 htab->sec_info = bfd_zmalloc (amt);
12252 if (htab->sec_info == NULL)
12253 return -1;
12254
12255 /* Set toc_off for com, und, abs and ind sections. */
12256 for (id = 0; id < 3; id++)
12257 htab->sec_info[id].toc_off = TOC_BASE_OFF;
12258
12259 return 1;
12260 }
12261
12262 /* Set up for first pass at multitoc partitioning. */
12263
12264 void
12265 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12266 {
12267 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12268
12269 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12270 htab->toc_bfd = NULL;
12271 htab->toc_first_sec = NULL;
12272 }
12273
12274 /* The linker repeatedly calls this function for each TOC input section
12275 and linker generated GOT section. Group input bfds such that the toc
12276 within a group is less than 64k in size. */
12277
12278 bfd_boolean
12279 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12280 {
12281 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12282 bfd_vma addr, off, limit;
12283
12284 if (htab == NULL)
12285 return FALSE;
12286
12287 if (!htab->second_toc_pass)
12288 {
12289 /* Keep track of the first .toc or .got section for this input bfd. */
12290 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
12291
12292 if (new_bfd)
12293 {
12294 htab->toc_bfd = isec->owner;
12295 htab->toc_first_sec = isec;
12296 }
12297
12298 addr = isec->output_offset + isec->output_section->vma;
12299 off = addr - htab->toc_curr;
12300 limit = 0x80008000;
12301 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12302 limit = 0x10000;
12303 if (off + isec->size > limit)
12304 {
12305 addr = (htab->toc_first_sec->output_offset
12306 + htab->toc_first_sec->output_section->vma);
12307 htab->toc_curr = addr;
12308 htab->toc_curr &= -TOC_BASE_ALIGN;
12309 }
12310
12311 /* toc_curr is the base address of this toc group. Set elf_gp
12312 for the input section to be the offset relative to the
12313 output toc base plus 0x8000. Making the input elf_gp an
12314 offset allows us to move the toc as a whole without
12315 recalculating input elf_gp. */
12316 off = htab->toc_curr - elf_gp (info->output_bfd);
12317 off += TOC_BASE_OFF;
12318
12319 /* Die if someone uses a linker script that doesn't keep input
12320 file .toc and .got together. */
12321 if (new_bfd
12322 && elf_gp (isec->owner) != 0
12323 && elf_gp (isec->owner) != off)
12324 return FALSE;
12325
12326 elf_gp (isec->owner) = off;
12327 return TRUE;
12328 }
12329
12330 /* During the second pass toc_first_sec points to the start of
12331 a toc group, and toc_curr is used to track the old elf_gp.
12332 We use toc_bfd to ensure we only look at each bfd once. */
12333 if (htab->toc_bfd == isec->owner)
12334 return TRUE;
12335 htab->toc_bfd = isec->owner;
12336
12337 if (htab->toc_first_sec == NULL
12338 || htab->toc_curr != elf_gp (isec->owner))
12339 {
12340 htab->toc_curr = elf_gp (isec->owner);
12341 htab->toc_first_sec = isec;
12342 }
12343 addr = (htab->toc_first_sec->output_offset
12344 + htab->toc_first_sec->output_section->vma);
12345 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12346 elf_gp (isec->owner) = off;
12347
12348 return TRUE;
12349 }
12350
12351 /* Called via elf_link_hash_traverse to merge GOT entries for global
12352 symbol H. */
12353
12354 static bfd_boolean
12355 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12356 {
12357 if (h->root.type == bfd_link_hash_indirect)
12358 return TRUE;
12359
12360 merge_got_entries (&h->got.glist);
12361
12362 return TRUE;
12363 }
12364
12365 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12366 symbol H. */
12367
12368 static bfd_boolean
12369 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12370 {
12371 struct got_entry *gent;
12372
12373 if (h->root.type == bfd_link_hash_indirect)
12374 return TRUE;
12375
12376 for (gent = h->got.glist; gent != NULL; gent = gent->next)
12377 if (!gent->is_indirect)
12378 allocate_got (h, (struct bfd_link_info *) inf, gent);
12379 return TRUE;
12380 }
12381
12382 /* Called on the first multitoc pass after the last call to
12383 ppc64_elf_next_toc_section. This function removes duplicate GOT
12384 entries. */
12385
12386 bfd_boolean
12387 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12388 {
12389 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12390 struct bfd *ibfd, *ibfd2;
12391 bfd_boolean done_something;
12392
12393 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12394
12395 if (!htab->do_multi_toc)
12396 return FALSE;
12397
12398 /* Merge global sym got entries within a toc group. */
12399 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12400
12401 /* And tlsld_got. */
12402 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12403 {
12404 struct got_entry *ent, *ent2;
12405
12406 if (!is_ppc64_elf (ibfd))
12407 continue;
12408
12409 ent = ppc64_tlsld_got (ibfd);
12410 if (!ent->is_indirect
12411 && ent->got.offset != (bfd_vma) -1)
12412 {
12413 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12414 {
12415 if (!is_ppc64_elf (ibfd2))
12416 continue;
12417
12418 ent2 = ppc64_tlsld_got (ibfd2);
12419 if (!ent2->is_indirect
12420 && ent2->got.offset != (bfd_vma) -1
12421 && elf_gp (ibfd2) == elf_gp (ibfd))
12422 {
12423 ent2->is_indirect = TRUE;
12424 ent2->got.ent = ent;
12425 }
12426 }
12427 }
12428 }
12429
12430 /* Zap sizes of got sections. */
12431 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12432 htab->elf.irelplt->size -= htab->got_reli_size;
12433 htab->got_reli_size = 0;
12434
12435 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12436 {
12437 asection *got, *relgot;
12438
12439 if (!is_ppc64_elf (ibfd))
12440 continue;
12441
12442 got = ppc64_elf_tdata (ibfd)->got;
12443 if (got != NULL)
12444 {
12445 got->rawsize = got->size;
12446 got->size = 0;
12447 relgot = ppc64_elf_tdata (ibfd)->relgot;
12448 relgot->rawsize = relgot->size;
12449 relgot->size = 0;
12450 }
12451 }
12452
12453 /* Now reallocate the got, local syms first. We don't need to
12454 allocate section contents again since we never increase size. */
12455 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12456 {
12457 struct got_entry **lgot_ents;
12458 struct got_entry **end_lgot_ents;
12459 struct plt_entry **local_plt;
12460 struct plt_entry **end_local_plt;
12461 unsigned char *lgot_masks;
12462 bfd_size_type locsymcount;
12463 Elf_Internal_Shdr *symtab_hdr;
12464 asection *s;
12465
12466 if (!is_ppc64_elf (ibfd))
12467 continue;
12468
12469 lgot_ents = elf_local_got_ents (ibfd);
12470 if (!lgot_ents)
12471 continue;
12472
12473 symtab_hdr = &elf_symtab_hdr (ibfd);
12474 locsymcount = symtab_hdr->sh_info;
12475 end_lgot_ents = lgot_ents + locsymcount;
12476 local_plt = (struct plt_entry **) end_lgot_ents;
12477 end_local_plt = local_plt + locsymcount;
12478 lgot_masks = (unsigned char *) end_local_plt;
12479 s = ppc64_elf_tdata (ibfd)->got;
12480 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12481 {
12482 struct got_entry *ent;
12483
12484 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12485 {
12486 unsigned int ent_size = 8;
12487 unsigned int rel_size = sizeof (Elf64_External_Rela);
12488
12489 ent->got.offset = s->size;
12490 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12491 {
12492 ent_size *= 2;
12493 rel_size *= 2;
12494 }
12495 s->size += ent_size;
12496 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12497 {
12498 htab->elf.irelplt->size += rel_size;
12499 htab->got_reli_size += rel_size;
12500 }
12501 else if (bfd_link_pic (info)
12502 && !((ent->tls_type & TLS_TPREL) != 0
12503 && bfd_link_executable (info)))
12504 {
12505 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12506 srel->size += rel_size;
12507 }
12508 }
12509 }
12510 }
12511
12512 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12513
12514 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12515 {
12516 struct got_entry *ent;
12517
12518 if (!is_ppc64_elf (ibfd))
12519 continue;
12520
12521 ent = ppc64_tlsld_got (ibfd);
12522 if (!ent->is_indirect
12523 && ent->got.offset != (bfd_vma) -1)
12524 {
12525 asection *s = ppc64_elf_tdata (ibfd)->got;
12526 ent->got.offset = s->size;
12527 s->size += 16;
12528 if (bfd_link_pic (info))
12529 {
12530 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12531 srel->size += sizeof (Elf64_External_Rela);
12532 }
12533 }
12534 }
12535
12536 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12537 if (!done_something)
12538 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12539 {
12540 asection *got;
12541
12542 if (!is_ppc64_elf (ibfd))
12543 continue;
12544
12545 got = ppc64_elf_tdata (ibfd)->got;
12546 if (got != NULL)
12547 {
12548 done_something = got->rawsize != got->size;
12549 if (done_something)
12550 break;
12551 }
12552 }
12553
12554 if (done_something)
12555 (*htab->params->layout_sections_again) ();
12556
12557 /* Set up for second pass over toc sections to recalculate elf_gp
12558 on input sections. */
12559 htab->toc_bfd = NULL;
12560 htab->toc_first_sec = NULL;
12561 htab->second_toc_pass = TRUE;
12562 return done_something;
12563 }
12564
12565 /* Called after second pass of multitoc partitioning. */
12566
12567 void
12568 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12569 {
12570 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12571
12572 /* After the second pass, toc_curr tracks the TOC offset used
12573 for code sections below in ppc64_elf_next_input_section. */
12574 htab->toc_curr = TOC_BASE_OFF;
12575 }
12576
12577 /* No toc references were found in ISEC. If the code in ISEC makes no
12578 calls, then there's no need to use toc adjusting stubs when branching
12579 into ISEC. Actually, indirect calls from ISEC are OK as they will
12580 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12581 needed, and 2 if a cyclical call-graph was found but no other reason
12582 for a stub was detected. If called from the top level, a return of
12583 2 means the same as a return of 0. */
12584
12585 static int
12586 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12587 {
12588 int ret;
12589
12590 /* Mark this section as checked. */
12591 isec->call_check_done = 1;
12592
12593 /* We know none of our code bearing sections will need toc stubs. */
12594 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12595 return 0;
12596
12597 if (isec->size == 0)
12598 return 0;
12599
12600 if (isec->output_section == NULL)
12601 return 0;
12602
12603 ret = 0;
12604 if (isec->reloc_count != 0)
12605 {
12606 Elf_Internal_Rela *relstart, *rel;
12607 Elf_Internal_Sym *local_syms;
12608 struct ppc_link_hash_table *htab;
12609
12610 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12611 info->keep_memory);
12612 if (relstart == NULL)
12613 return -1;
12614
12615 /* Look for branches to outside of this section. */
12616 local_syms = NULL;
12617 htab = ppc_hash_table (info);
12618 if (htab == NULL)
12619 return -1;
12620
12621 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12622 {
12623 enum elf_ppc64_reloc_type r_type;
12624 unsigned long r_symndx;
12625 struct elf_link_hash_entry *h;
12626 struct ppc_link_hash_entry *eh;
12627 Elf_Internal_Sym *sym;
12628 asection *sym_sec;
12629 struct _opd_sec_data *opd;
12630 bfd_vma sym_value;
12631 bfd_vma dest;
12632
12633 r_type = ELF64_R_TYPE (rel->r_info);
12634 if (r_type != R_PPC64_REL24
12635 && r_type != R_PPC64_REL24_NOTOC
12636 && r_type != R_PPC64_REL14
12637 && r_type != R_PPC64_REL14_BRTAKEN
12638 && r_type != R_PPC64_REL14_BRNTAKEN
12639 && r_type != R_PPC64_PLTCALL)
12640 continue;
12641
12642 r_symndx = ELF64_R_SYM (rel->r_info);
12643 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12644 isec->owner))
12645 {
12646 ret = -1;
12647 break;
12648 }
12649
12650 /* Calls to dynamic lib functions go through a plt call stub
12651 that uses r2. */
12652 eh = (struct ppc_link_hash_entry *) h;
12653 if (eh != NULL
12654 && (eh->elf.plt.plist != NULL
12655 || (eh->oh != NULL
12656 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12657 {
12658 ret = 1;
12659 break;
12660 }
12661
12662 if (sym_sec == NULL)
12663 /* Ignore other undefined symbols. */
12664 continue;
12665
12666 /* Assume branches to other sections not included in the
12667 link need stubs too, to cover -R and absolute syms. */
12668 if (sym_sec->output_section == NULL)
12669 {
12670 ret = 1;
12671 break;
12672 }
12673
12674 if (h == NULL)
12675 sym_value = sym->st_value;
12676 else
12677 {
12678 if (h->root.type != bfd_link_hash_defined
12679 && h->root.type != bfd_link_hash_defweak)
12680 abort ();
12681 sym_value = h->root.u.def.value;
12682 }
12683 sym_value += rel->r_addend;
12684
12685 /* If this branch reloc uses an opd sym, find the code section. */
12686 opd = get_opd_info (sym_sec);
12687 if (opd != NULL)
12688 {
12689 if (h == NULL && opd->adjust != NULL)
12690 {
12691 long adjust;
12692
12693 adjust = opd->adjust[OPD_NDX (sym_value)];
12694 if (adjust == -1)
12695 /* Assume deleted functions won't ever be called. */
12696 continue;
12697 sym_value += adjust;
12698 }
12699
12700 dest = opd_entry_value (sym_sec, sym_value,
12701 &sym_sec, NULL, FALSE);
12702 if (dest == (bfd_vma) -1)
12703 continue;
12704 }
12705 else
12706 dest = (sym_value
12707 + sym_sec->output_offset
12708 + sym_sec->output_section->vma);
12709
12710 /* Ignore branch to self. */
12711 if (sym_sec == isec)
12712 continue;
12713
12714 /* If the called function uses the toc, we need a stub. */
12715 if (sym_sec->has_toc_reloc
12716 || sym_sec->makes_toc_func_call)
12717 {
12718 ret = 1;
12719 break;
12720 }
12721
12722 /* Assume any branch that needs a long branch stub might in fact
12723 need a plt_branch stub. A plt_branch stub uses r2. */
12724 else if (dest - (isec->output_offset
12725 + isec->output_section->vma
12726 + rel->r_offset) + (1 << 25)
12727 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12728 ? h->other
12729 : sym->st_other))
12730 {
12731 ret = 1;
12732 break;
12733 }
12734
12735 /* If calling back to a section in the process of being
12736 tested, we can't say for sure that no toc adjusting stubs
12737 are needed, so don't return zero. */
12738 else if (sym_sec->call_check_in_progress)
12739 ret = 2;
12740
12741 /* Branches to another section that itself doesn't have any TOC
12742 references are OK. Recursively call ourselves to check. */
12743 else if (!sym_sec->call_check_done)
12744 {
12745 int recur;
12746
12747 /* Mark current section as indeterminate, so that other
12748 sections that call back to current won't be marked as
12749 known. */
12750 isec->call_check_in_progress = 1;
12751 recur = toc_adjusting_stub_needed (info, sym_sec);
12752 isec->call_check_in_progress = 0;
12753
12754 if (recur != 0)
12755 {
12756 ret = recur;
12757 if (recur != 2)
12758 break;
12759 }
12760 }
12761 }
12762
12763 if (local_syms != NULL
12764 && (elf_symtab_hdr (isec->owner).contents
12765 != (unsigned char *) local_syms))
12766 free (local_syms);
12767 if (elf_section_data (isec)->relocs != relstart)
12768 free (relstart);
12769 }
12770
12771 if ((ret & 1) == 0
12772 && isec->map_head.s != NULL
12773 && (strcmp (isec->output_section->name, ".init") == 0
12774 || strcmp (isec->output_section->name, ".fini") == 0))
12775 {
12776 if (isec->map_head.s->has_toc_reloc
12777 || isec->map_head.s->makes_toc_func_call)
12778 ret = 1;
12779 else if (!isec->map_head.s->call_check_done)
12780 {
12781 int recur;
12782 isec->call_check_in_progress = 1;
12783 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12784 isec->call_check_in_progress = 0;
12785 if (recur != 0)
12786 ret = recur;
12787 }
12788 }
12789
12790 if (ret == 1)
12791 isec->makes_toc_func_call = 1;
12792
12793 return ret;
12794 }
12795
12796 /* The linker repeatedly calls this function for each input section,
12797 in the order that input sections are linked into output sections.
12798 Build lists of input sections to determine groupings between which
12799 we may insert linker stubs. */
12800
12801 bfd_boolean
12802 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12803 {
12804 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12805
12806 if (htab == NULL)
12807 return FALSE;
12808
12809 if ((isec->output_section->flags & SEC_CODE) != 0
12810 && isec->output_section->id < htab->sec_info_arr_size)
12811 {
12812 /* This happens to make the list in reverse order,
12813 which is what we want. */
12814 htab->sec_info[isec->id].u.list
12815 = htab->sec_info[isec->output_section->id].u.list;
12816 htab->sec_info[isec->output_section->id].u.list = isec;
12817 }
12818
12819 if (htab->multi_toc_needed)
12820 {
12821 /* Analyse sections that aren't already flagged as needing a
12822 valid toc pointer. Exclude .fixup for the linux kernel.
12823 .fixup contains branches, but only back to the function that
12824 hit an exception. */
12825 if (!(isec->has_toc_reloc
12826 || (isec->flags & SEC_CODE) == 0
12827 || strcmp (isec->name, ".fixup") == 0
12828 || isec->call_check_done))
12829 {
12830 if (toc_adjusting_stub_needed (info, isec) < 0)
12831 return FALSE;
12832 }
12833 /* Make all sections use the TOC assigned for this object file.
12834 This will be wrong for pasted sections; We fix that in
12835 check_pasted_section(). */
12836 if (elf_gp (isec->owner) != 0)
12837 htab->toc_curr = elf_gp (isec->owner);
12838 }
12839
12840 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12841 return TRUE;
12842 }
12843
12844 /* Check that all .init and .fini sections use the same toc, if they
12845 have toc relocs. */
12846
12847 static bfd_boolean
12848 check_pasted_section (struct bfd_link_info *info, const char *name)
12849 {
12850 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12851
12852 if (o != NULL)
12853 {
12854 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12855 bfd_vma toc_off = 0;
12856 asection *i;
12857
12858 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12859 if (i->has_toc_reloc)
12860 {
12861 if (toc_off == 0)
12862 toc_off = htab->sec_info[i->id].toc_off;
12863 else if (toc_off != htab->sec_info[i->id].toc_off)
12864 return FALSE;
12865 }
12866
12867 if (toc_off == 0)
12868 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12869 if (i->makes_toc_func_call)
12870 {
12871 toc_off = htab->sec_info[i->id].toc_off;
12872 break;
12873 }
12874
12875 /* Make sure the whole pasted function uses the same toc offset. */
12876 if (toc_off != 0)
12877 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12878 htab->sec_info[i->id].toc_off = toc_off;
12879 }
12880 return TRUE;
12881 }
12882
12883 bfd_boolean
12884 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12885 {
12886 return (check_pasted_section (info, ".init")
12887 & check_pasted_section (info, ".fini"));
12888 }
12889
12890 /* See whether we can group stub sections together. Grouping stub
12891 sections may result in fewer stubs. More importantly, we need to
12892 put all .init* and .fini* stubs at the beginning of the .init or
12893 .fini output sections respectively, because glibc splits the
12894 _init and _fini functions into multiple parts. Putting a stub in
12895 the middle of a function is not a good idea. */
12896
12897 static bfd_boolean
12898 group_sections (struct bfd_link_info *info,
12899 bfd_size_type stub_group_size,
12900 bfd_boolean stubs_always_before_branch)
12901 {
12902 struct ppc_link_hash_table *htab;
12903 asection *osec;
12904 bfd_boolean suppress_size_errors;
12905
12906 htab = ppc_hash_table (info);
12907 if (htab == NULL)
12908 return FALSE;
12909
12910 suppress_size_errors = FALSE;
12911 if (stub_group_size == 1)
12912 {
12913 /* Default values. */
12914 if (stubs_always_before_branch)
12915 stub_group_size = 0x1e00000;
12916 else
12917 stub_group_size = 0x1c00000;
12918 suppress_size_errors = TRUE;
12919 }
12920
12921 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12922 {
12923 asection *tail;
12924
12925 if (osec->id >= htab->sec_info_arr_size)
12926 continue;
12927
12928 tail = htab->sec_info[osec->id].u.list;
12929 while (tail != NULL)
12930 {
12931 asection *curr;
12932 asection *prev;
12933 bfd_size_type total;
12934 bfd_boolean big_sec;
12935 bfd_vma curr_toc;
12936 struct map_stub *group;
12937 bfd_size_type group_size;
12938
12939 curr = tail;
12940 total = tail->size;
12941 group_size = (ppc64_elf_section_data (tail) != NULL
12942 && ppc64_elf_section_data (tail)->has_14bit_branch
12943 ? stub_group_size >> 10 : stub_group_size);
12944
12945 big_sec = total > group_size;
12946 if (big_sec && !suppress_size_errors)
12947 /* xgettext:c-format */
12948 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12949 tail->owner, tail);
12950 curr_toc = htab->sec_info[tail->id].toc_off;
12951
12952 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12953 && ((total += curr->output_offset - prev->output_offset)
12954 < (ppc64_elf_section_data (prev) != NULL
12955 && ppc64_elf_section_data (prev)->has_14bit_branch
12956 ? (group_size = stub_group_size >> 10) : group_size))
12957 && htab->sec_info[prev->id].toc_off == curr_toc)
12958 curr = prev;
12959
12960 /* OK, the size from the start of CURR to the end is less
12961 than group_size and thus can be handled by one stub
12962 section. (or the tail section is itself larger than
12963 group_size, in which case we may be toast.) We should
12964 really be keeping track of the total size of stubs added
12965 here, as stubs contribute to the final output section
12966 size. That's a little tricky, and this way will only
12967 break if stubs added make the total size more than 2^25,
12968 ie. for the default stub_group_size, if stubs total more
12969 than 2097152 bytes, or nearly 75000 plt call stubs. */
12970 group = bfd_alloc (curr->owner, sizeof (*group));
12971 if (group == NULL)
12972 return FALSE;
12973 group->link_sec = curr;
12974 group->stub_sec = NULL;
12975 group->needs_save_res = 0;
12976 group->lr_restore = 0;
12977 group->eh_size = 0;
12978 group->eh_base = 0;
12979 group->next = htab->group;
12980 htab->group = group;
12981 do
12982 {
12983 prev = htab->sec_info[tail->id].u.list;
12984 /* Set up this stub group. */
12985 htab->sec_info[tail->id].u.group = group;
12986 }
12987 while (tail != curr && (tail = prev) != NULL);
12988
12989 /* But wait, there's more! Input sections up to group_size
12990 bytes before the stub section can be handled by it too.
12991 Don't do this if we have a really large section after the
12992 stubs, as adding more stubs increases the chance that
12993 branches may not reach into the stub section. */
12994 if (!stubs_always_before_branch && !big_sec)
12995 {
12996 total = 0;
12997 while (prev != NULL
12998 && ((total += tail->output_offset - prev->output_offset)
12999 < (ppc64_elf_section_data (prev) != NULL
13000 && ppc64_elf_section_data (prev)->has_14bit_branch
13001 ? (group_size = stub_group_size >> 10)
13002 : group_size))
13003 && htab->sec_info[prev->id].toc_off == curr_toc)
13004 {
13005 tail = prev;
13006 prev = htab->sec_info[tail->id].u.list;
13007 htab->sec_info[tail->id].u.group = group;
13008 }
13009 }
13010 tail = prev;
13011 }
13012 }
13013 return TRUE;
13014 }
13015
13016 static const unsigned char glink_eh_frame_cie[] =
13017 {
13018 0, 0, 0, 16, /* length. */
13019 0, 0, 0, 0, /* id. */
13020 1, /* CIE version. */
13021 'z', 'R', 0, /* Augmentation string. */
13022 4, /* Code alignment. */
13023 0x78, /* Data alignment. */
13024 65, /* RA reg. */
13025 1, /* Augmentation size. */
13026 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
13027 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
13028 };
13029
13030 /* Stripping output sections is normally done before dynamic section
13031 symbols have been allocated. This function is called later, and
13032 handles cases like htab->brlt which is mapped to its own output
13033 section. */
13034
13035 static void
13036 maybe_strip_output (struct bfd_link_info *info, asection *isec)
13037 {
13038 if (isec->size == 0
13039 && isec->output_section->size == 0
13040 && !(isec->output_section->flags & SEC_KEEP)
13041 && !bfd_section_removed_from_list (info->output_bfd,
13042 isec->output_section)
13043 && elf_section_data (isec->output_section)->dynindx == 0)
13044 {
13045 isec->output_section->flags |= SEC_EXCLUDE;
13046 bfd_section_list_remove (info->output_bfd, isec->output_section);
13047 info->output_bfd->section_count--;
13048 }
13049 }
13050
13051 /* Determine and set the size of the stub section for a final link.
13052
13053 The basic idea here is to examine all the relocations looking for
13054 PC-relative calls to a target that is unreachable with a "bl"
13055 instruction. */
13056
13057 bfd_boolean
13058 ppc64_elf_size_stubs (struct bfd_link_info *info)
13059 {
13060 bfd_size_type stub_group_size;
13061 bfd_boolean stubs_always_before_branch;
13062 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13063
13064 if (htab == NULL)
13065 return FALSE;
13066
13067 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
13068 htab->params->plt_thread_safe = 1;
13069 if (!htab->opd_abi)
13070 htab->params->plt_thread_safe = 0;
13071 else if (htab->params->plt_thread_safe == -1)
13072 {
13073 static const char *const thread_starter[] =
13074 {
13075 "pthread_create",
13076 /* libstdc++ */
13077 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13078 /* librt */
13079 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13080 "mq_notify", "create_timer",
13081 /* libanl */
13082 "getaddrinfo_a",
13083 /* libgomp */
13084 "GOMP_parallel",
13085 "GOMP_parallel_start",
13086 "GOMP_parallel_loop_static",
13087 "GOMP_parallel_loop_static_start",
13088 "GOMP_parallel_loop_dynamic",
13089 "GOMP_parallel_loop_dynamic_start",
13090 "GOMP_parallel_loop_guided",
13091 "GOMP_parallel_loop_guided_start",
13092 "GOMP_parallel_loop_runtime",
13093 "GOMP_parallel_loop_runtime_start",
13094 "GOMP_parallel_sections",
13095 "GOMP_parallel_sections_start",
13096 /* libgo */
13097 "__go_go",
13098 };
13099 unsigned i;
13100
13101 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
13102 {
13103 struct elf_link_hash_entry *h;
13104 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
13105 FALSE, FALSE, TRUE);
13106 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
13107 if (htab->params->plt_thread_safe)
13108 break;
13109 }
13110 }
13111 stubs_always_before_branch = htab->params->group_size < 0;
13112 if (htab->params->group_size < 0)
13113 stub_group_size = -htab->params->group_size;
13114 else
13115 stub_group_size = htab->params->group_size;
13116
13117 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
13118 return FALSE;
13119
13120 #define STUB_SHRINK_ITER 20
13121 /* Loop until no stubs added. After iteration 20 of this loop we may
13122 exit on a stub section shrinking. This is to break out of a
13123 pathological case where adding stubs on one iteration decreases
13124 section gaps (perhaps due to alignment), which then requires
13125 fewer or smaller stubs on the next iteration. */
13126
13127 while (1)
13128 {
13129 bfd *input_bfd;
13130 unsigned int bfd_indx;
13131 struct map_stub *group;
13132
13133 htab->stub_iteration += 1;
13134
13135 for (input_bfd = info->input_bfds, bfd_indx = 0;
13136 input_bfd != NULL;
13137 input_bfd = input_bfd->link.next, bfd_indx++)
13138 {
13139 Elf_Internal_Shdr *symtab_hdr;
13140 asection *section;
13141 Elf_Internal_Sym *local_syms = NULL;
13142
13143 if (!is_ppc64_elf (input_bfd))
13144 continue;
13145
13146 /* We'll need the symbol table in a second. */
13147 symtab_hdr = &elf_symtab_hdr (input_bfd);
13148 if (symtab_hdr->sh_info == 0)
13149 continue;
13150
13151 /* Walk over each section attached to the input bfd. */
13152 for (section = input_bfd->sections;
13153 section != NULL;
13154 section = section->next)
13155 {
13156 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13157
13158 /* If there aren't any relocs, then there's nothing more
13159 to do. */
13160 if ((section->flags & SEC_RELOC) == 0
13161 || (section->flags & SEC_ALLOC) == 0
13162 || (section->flags & SEC_LOAD) == 0
13163 || (section->flags & SEC_CODE) == 0
13164 || section->reloc_count == 0)
13165 continue;
13166
13167 /* If this section is a link-once section that will be
13168 discarded, then don't create any stubs. */
13169 if (section->output_section == NULL
13170 || section->output_section->owner != info->output_bfd)
13171 continue;
13172
13173 /* Get the relocs. */
13174 internal_relocs
13175 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13176 info->keep_memory);
13177 if (internal_relocs == NULL)
13178 goto error_ret_free_local;
13179
13180 /* Now examine each relocation. */
13181 irela = internal_relocs;
13182 irelaend = irela + section->reloc_count;
13183 for (; irela < irelaend; irela++)
13184 {
13185 enum elf_ppc64_reloc_type r_type;
13186 unsigned int r_indx;
13187 enum ppc_stub_type stub_type;
13188 struct ppc_stub_hash_entry *stub_entry;
13189 asection *sym_sec, *code_sec;
13190 bfd_vma sym_value, code_value;
13191 bfd_vma destination;
13192 unsigned long local_off;
13193 bfd_boolean ok_dest;
13194 struct ppc_link_hash_entry *hash;
13195 struct ppc_link_hash_entry *fdh;
13196 struct elf_link_hash_entry *h;
13197 Elf_Internal_Sym *sym;
13198 char *stub_name;
13199 const asection *id_sec;
13200 struct _opd_sec_data *opd;
13201 struct plt_entry *plt_ent;
13202
13203 r_type = ELF64_R_TYPE (irela->r_info);
13204 r_indx = ELF64_R_SYM (irela->r_info);
13205
13206 if (r_type >= R_PPC64_max)
13207 {
13208 bfd_set_error (bfd_error_bad_value);
13209 goto error_ret_free_internal;
13210 }
13211
13212 /* Only look for stubs on branch instructions. */
13213 if (r_type != R_PPC64_REL24
13214 && r_type != R_PPC64_REL24_NOTOC
13215 && r_type != R_PPC64_REL14
13216 && r_type != R_PPC64_REL14_BRTAKEN
13217 && r_type != R_PPC64_REL14_BRNTAKEN)
13218 continue;
13219
13220 /* Now determine the call target, its name, value,
13221 section. */
13222 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13223 r_indx, input_bfd))
13224 goto error_ret_free_internal;
13225 hash = (struct ppc_link_hash_entry *) h;
13226
13227 ok_dest = FALSE;
13228 fdh = NULL;
13229 sym_value = 0;
13230 if (hash == NULL)
13231 {
13232 sym_value = sym->st_value;
13233 if (sym_sec != NULL
13234 && sym_sec->output_section != NULL)
13235 ok_dest = TRUE;
13236 }
13237 else if (hash->elf.root.type == bfd_link_hash_defined
13238 || hash->elf.root.type == bfd_link_hash_defweak)
13239 {
13240 sym_value = hash->elf.root.u.def.value;
13241 if (sym_sec->output_section != NULL)
13242 ok_dest = TRUE;
13243 }
13244 else if (hash->elf.root.type == bfd_link_hash_undefweak
13245 || hash->elf.root.type == bfd_link_hash_undefined)
13246 {
13247 /* Recognise an old ABI func code entry sym, and
13248 use the func descriptor sym instead if it is
13249 defined. */
13250 if (hash->elf.root.root.string[0] == '.'
13251 && hash->oh != NULL)
13252 {
13253 fdh = ppc_follow_link (hash->oh);
13254 if (fdh->elf.root.type == bfd_link_hash_defined
13255 || fdh->elf.root.type == bfd_link_hash_defweak)
13256 {
13257 sym_sec = fdh->elf.root.u.def.section;
13258 sym_value = fdh->elf.root.u.def.value;
13259 if (sym_sec->output_section != NULL)
13260 ok_dest = TRUE;
13261 }
13262 else
13263 fdh = NULL;
13264 }
13265 }
13266 else
13267 {
13268 bfd_set_error (bfd_error_bad_value);
13269 goto error_ret_free_internal;
13270 }
13271
13272 destination = 0;
13273 local_off = 0;
13274 if (ok_dest)
13275 {
13276 sym_value += irela->r_addend;
13277 destination = (sym_value
13278 + sym_sec->output_offset
13279 + sym_sec->output_section->vma);
13280 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
13281 ? hash->elf.other
13282 : sym->st_other);
13283 }
13284
13285 code_sec = sym_sec;
13286 code_value = sym_value;
13287 opd = get_opd_info (sym_sec);
13288 if (opd != NULL)
13289 {
13290 bfd_vma dest;
13291
13292 if (hash == NULL && opd->adjust != NULL)
13293 {
13294 long adjust = opd->adjust[OPD_NDX (sym_value)];
13295 if (adjust == -1)
13296 continue;
13297 code_value += adjust;
13298 sym_value += adjust;
13299 }
13300 dest = opd_entry_value (sym_sec, sym_value,
13301 &code_sec, &code_value, FALSE);
13302 if (dest != (bfd_vma) -1)
13303 {
13304 destination = dest;
13305 if (fdh != NULL)
13306 {
13307 /* Fixup old ABI sym to point at code
13308 entry. */
13309 hash->elf.root.type = bfd_link_hash_defweak;
13310 hash->elf.root.u.def.section = code_sec;
13311 hash->elf.root.u.def.value = code_value;
13312 }
13313 }
13314 }
13315
13316 /* Determine what (if any) linker stub is needed. */
13317 plt_ent = NULL;
13318 stub_type = ppc_type_of_stub (section, irela, &hash,
13319 &plt_ent, destination,
13320 local_off);
13321
13322 if (r_type == R_PPC64_REL24_NOTOC)
13323 {
13324 if (stub_type == ppc_stub_plt_call)
13325 stub_type = ppc_stub_plt_call_notoc;
13326 else if (stub_type == ppc_stub_long_branch
13327 || (code_sec != NULL
13328 && code_sec->output_section != NULL
13329 && (((hash ? hash->elf.other : sym->st_other)
13330 & STO_PPC64_LOCAL_MASK)
13331 != 1 << STO_PPC64_LOCAL_BIT)))
13332 stub_type = ppc_stub_long_branch_notoc;
13333 }
13334 else if (stub_type != ppc_stub_plt_call)
13335 {
13336 /* Check whether we need a TOC adjusting stub.
13337 Since the linker pastes together pieces from
13338 different object files when creating the
13339 _init and _fini functions, it may be that a
13340 call to what looks like a local sym is in
13341 fact a call needing a TOC adjustment. */
13342 if ((code_sec != NULL
13343 && code_sec->output_section != NULL
13344 && (htab->sec_info[code_sec->id].toc_off
13345 != htab->sec_info[section->id].toc_off)
13346 && (code_sec->has_toc_reloc
13347 || code_sec->makes_toc_func_call))
13348 || (((hash ? hash->elf.other : sym->st_other)
13349 & STO_PPC64_LOCAL_MASK)
13350 == 1 << STO_PPC64_LOCAL_BIT))
13351 stub_type = ppc_stub_long_branch_r2off;
13352 }
13353
13354 if (stub_type == ppc_stub_none)
13355 continue;
13356
13357 /* __tls_get_addr calls might be eliminated. */
13358 if (stub_type != ppc_stub_plt_call
13359 && stub_type != ppc_stub_plt_call_notoc
13360 && hash != NULL
13361 && (hash == htab->tls_get_addr
13362 || hash == htab->tls_get_addr_fd)
13363 && section->has_tls_reloc
13364 && irela != internal_relocs)
13365 {
13366 /* Get tls info. */
13367 unsigned char *tls_mask;
13368
13369 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13370 irela - 1, input_bfd))
13371 goto error_ret_free_internal;
13372 if ((*tls_mask & TLS_TLS) != 0)
13373 continue;
13374 }
13375
13376 if (stub_type == ppc_stub_plt_call)
13377 {
13378 if (!htab->opd_abi
13379 && htab->params->plt_localentry0 != 0
13380 && is_elfv2_localentry0 (&hash->elf))
13381 htab->has_plt_localentry0 = 1;
13382 else if (irela + 1 < irelaend
13383 && irela[1].r_offset == irela->r_offset + 4
13384 && (ELF64_R_TYPE (irela[1].r_info)
13385 == R_PPC64_TOCSAVE))
13386 {
13387 if (!tocsave_find (htab, INSERT,
13388 &local_syms, irela + 1, input_bfd))
13389 goto error_ret_free_internal;
13390 }
13391 else
13392 stub_type = ppc_stub_plt_call_r2save;
13393 }
13394
13395 /* Support for grouping stub sections. */
13396 id_sec = htab->sec_info[section->id].u.group->link_sec;
13397
13398 /* Get the name of this stub. */
13399 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13400 if (!stub_name)
13401 goto error_ret_free_internal;
13402
13403 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13404 stub_name, FALSE, FALSE);
13405 if (stub_entry != NULL)
13406 {
13407 enum ppc_stub_type old_type;
13408 /* A stub has already been created, but it may
13409 not be the required type. We shouldn't be
13410 transitioning from plt_call to long_branch
13411 stubs or vice versa, but we might be
13412 upgrading from plt_call to plt_call_r2save or
13413 from long_branch to long_branch_r2off. */
13414 free (stub_name);
13415 old_type = stub_entry->stub_type;
13416 switch (old_type)
13417 {
13418 default:
13419 abort ();
13420
13421 case ppc_stub_save_res:
13422 continue;
13423
13424 case ppc_stub_plt_call:
13425 case ppc_stub_plt_call_r2save:
13426 case ppc_stub_plt_call_notoc:
13427 case ppc_stub_plt_call_both:
13428 if (stub_type == ppc_stub_plt_call)
13429 continue;
13430 else if (stub_type == ppc_stub_plt_call_r2save)
13431 {
13432 if (old_type == ppc_stub_plt_call_notoc)
13433 stub_type = ppc_stub_plt_call_both;
13434 }
13435 else if (stub_type == ppc_stub_plt_call_notoc)
13436 {
13437 if (old_type == ppc_stub_plt_call_r2save)
13438 stub_type = ppc_stub_plt_call_both;
13439 }
13440 else
13441 abort ();
13442 break;
13443
13444 case ppc_stub_plt_branch:
13445 case ppc_stub_plt_branch_r2off:
13446 case ppc_stub_plt_branch_notoc:
13447 case ppc_stub_plt_branch_both:
13448 old_type += (ppc_stub_long_branch
13449 - ppc_stub_plt_branch);
13450 /* Fall through. */
13451 case ppc_stub_long_branch:
13452 case ppc_stub_long_branch_r2off:
13453 case ppc_stub_long_branch_notoc:
13454 case ppc_stub_long_branch_both:
13455 if (stub_type == ppc_stub_long_branch)
13456 continue;
13457 else if (stub_type == ppc_stub_long_branch_r2off)
13458 {
13459 if (old_type == ppc_stub_long_branch_notoc)
13460 stub_type = ppc_stub_long_branch_both;
13461 }
13462 else if (stub_type == ppc_stub_long_branch_notoc)
13463 {
13464 if (old_type == ppc_stub_long_branch_r2off)
13465 stub_type = ppc_stub_long_branch_both;
13466 }
13467 else
13468 abort ();
13469 break;
13470 }
13471 if (old_type < stub_type)
13472 stub_entry->stub_type = stub_type;
13473 continue;
13474 }
13475
13476 stub_entry = ppc_add_stub (stub_name, section, info);
13477 if (stub_entry == NULL)
13478 {
13479 free (stub_name);
13480 error_ret_free_internal:
13481 if (elf_section_data (section)->relocs == NULL)
13482 free (internal_relocs);
13483 error_ret_free_local:
13484 if (local_syms != NULL
13485 && (symtab_hdr->contents
13486 != (unsigned char *) local_syms))
13487 free (local_syms);
13488 return FALSE;
13489 }
13490
13491 stub_entry->stub_type = stub_type;
13492 if (stub_type >= ppc_stub_plt_call
13493 && stub_type <= ppc_stub_plt_call_both)
13494 {
13495 stub_entry->target_value = sym_value;
13496 stub_entry->target_section = sym_sec;
13497 }
13498 else
13499 {
13500 stub_entry->target_value = code_value;
13501 stub_entry->target_section = code_sec;
13502 }
13503 stub_entry->h = hash;
13504 stub_entry->plt_ent = plt_ent;
13505 stub_entry->symtype
13506 = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13507 stub_entry->other = hash ? hash->elf.other : sym->st_other;
13508
13509 if (stub_entry->h != NULL)
13510 htab->stub_globals += 1;
13511 }
13512
13513 /* We're done with the internal relocs, free them. */
13514 if (elf_section_data (section)->relocs != internal_relocs)
13515 free (internal_relocs);
13516 }
13517
13518 if (local_syms != NULL
13519 && symtab_hdr->contents != (unsigned char *) local_syms)
13520 {
13521 if (!info->keep_memory)
13522 free (local_syms);
13523 else
13524 symtab_hdr->contents = (unsigned char *) local_syms;
13525 }
13526 }
13527
13528 /* We may have added some stubs. Find out the new size of the
13529 stub sections. */
13530 for (group = htab->group; group != NULL; group = group->next)
13531 {
13532 group->lr_restore = 0;
13533 group->eh_size = 0;
13534 if (group->stub_sec != NULL)
13535 {
13536 asection *stub_sec = group->stub_sec;
13537
13538 if (htab->stub_iteration <= STUB_SHRINK_ITER
13539 || stub_sec->rawsize < stub_sec->size)
13540 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13541 stub_sec->rawsize = stub_sec->size;
13542 stub_sec->size = 0;
13543 stub_sec->reloc_count = 0;
13544 stub_sec->flags &= ~SEC_RELOC;
13545 }
13546 }
13547
13548 if (htab->stub_iteration <= STUB_SHRINK_ITER
13549 || htab->brlt->rawsize < htab->brlt->size)
13550 htab->brlt->rawsize = htab->brlt->size;
13551 htab->brlt->size = 0;
13552 htab->brlt->reloc_count = 0;
13553 htab->brlt->flags &= ~SEC_RELOC;
13554 if (htab->relbrlt != NULL)
13555 htab->relbrlt->size = 0;
13556
13557 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13558
13559 for (group = htab->group; group != NULL; group = group->next)
13560 if (group->needs_save_res)
13561 group->stub_sec->size += htab->sfpr->size;
13562
13563 if (info->emitrelocations
13564 && htab->glink != NULL && htab->glink->size != 0)
13565 {
13566 htab->glink->reloc_count = 1;
13567 htab->glink->flags |= SEC_RELOC;
13568 }
13569
13570 if (htab->glink_eh_frame != NULL
13571 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13572 && htab->glink_eh_frame->output_section->size > 8)
13573 {
13574 size_t size = 0, align = 4;
13575
13576 for (group = htab->group; group != NULL; group = group->next)
13577 if (group->eh_size != 0)
13578 size += (group->eh_size + 17 + align - 1) & -align;
13579 if (htab->glink != NULL && htab->glink->size != 0)
13580 size += (24 + align - 1) & -align;
13581 if (size != 0)
13582 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13583 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13584 size = (size + align - 1) & -align;
13585 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13586 htab->glink_eh_frame->size = size;
13587 }
13588
13589 if (htab->params->plt_stub_align != 0)
13590 for (group = htab->group; group != NULL; group = group->next)
13591 if (group->stub_sec != NULL)
13592 {
13593 int align = abs (htab->params->plt_stub_align);
13594 group->stub_sec->size
13595 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13596 }
13597
13598 for (group = htab->group; group != NULL; group = group->next)
13599 if (group->stub_sec != NULL
13600 && group->stub_sec->rawsize != group->stub_sec->size
13601 && (htab->stub_iteration <= STUB_SHRINK_ITER
13602 || group->stub_sec->rawsize < group->stub_sec->size))
13603 break;
13604
13605 if (group == NULL
13606 && (htab->brlt->rawsize == htab->brlt->size
13607 || (htab->stub_iteration > STUB_SHRINK_ITER
13608 && htab->brlt->rawsize > htab->brlt->size))
13609 && (htab->glink_eh_frame == NULL
13610 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13611 break;
13612
13613 /* Ask the linker to do its stuff. */
13614 (*htab->params->layout_sections_again) ();
13615 }
13616
13617 if (htab->glink_eh_frame != NULL
13618 && htab->glink_eh_frame->size != 0)
13619 {
13620 bfd_vma val;
13621 bfd_byte *p, *last_fde;
13622 size_t last_fde_len, size, align, pad;
13623 struct map_stub *group;
13624
13625 /* It is necessary to at least have a rough outline of the
13626 linker generated CIEs and FDEs written before
13627 bfd_elf_discard_info is run, in order for these FDEs to be
13628 indexed in .eh_frame_hdr. */
13629 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13630 if (p == NULL)
13631 return FALSE;
13632 htab->glink_eh_frame->contents = p;
13633 last_fde = p;
13634 align = 4;
13635
13636 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13637 /* CIE length (rewrite in case little-endian). */
13638 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13639 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13640 p += last_fde_len + 4;
13641
13642 for (group = htab->group; group != NULL; group = group->next)
13643 if (group->eh_size != 0)
13644 {
13645 group->eh_base = p - htab->glink_eh_frame->contents;
13646 last_fde = p;
13647 last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
13648 /* FDE length. */
13649 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13650 p += 4;
13651 /* CIE pointer. */
13652 val = p - htab->glink_eh_frame->contents;
13653 bfd_put_32 (htab->elf.dynobj, val, p);
13654 p += 4;
13655 /* Offset to stub section, written later. */
13656 p += 4;
13657 /* stub section size. */
13658 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13659 p += 4;
13660 /* Augmentation. */
13661 p += 1;
13662 /* Make sure we don't have all nops. This is enough for
13663 elf-eh-frame.c to detect the last non-nop opcode. */
13664 p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
13665 p = last_fde + last_fde_len + 4;
13666 }
13667 if (htab->glink != NULL && htab->glink->size != 0)
13668 {
13669 last_fde = p;
13670 last_fde_len = ((24 + align - 1) & -align) - 4;
13671 /* FDE length. */
13672 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13673 p += 4;
13674 /* CIE pointer. */
13675 val = p - htab->glink_eh_frame->contents;
13676 bfd_put_32 (htab->elf.dynobj, val, p);
13677 p += 4;
13678 /* Offset to .glink, written later. */
13679 p += 4;
13680 /* .glink size. */
13681 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13682 p += 4;
13683 /* Augmentation. */
13684 p += 1;
13685
13686 *p++ = DW_CFA_advance_loc + 1;
13687 *p++ = DW_CFA_register;
13688 *p++ = 65;
13689 *p++ = htab->opd_abi ? 12 : 0;
13690 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13691 *p++ = DW_CFA_restore_extended;
13692 *p++ = 65;
13693 p += ((24 + align - 1) & -align) - 24;
13694 }
13695 /* Subsume any padding into the last FDE if user .eh_frame
13696 sections are aligned more than glink_eh_frame. Otherwise any
13697 zero padding will be seen as a terminator. */
13698 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13699 size = p - htab->glink_eh_frame->contents;
13700 pad = ((size + align - 1) & -align) - size;
13701 htab->glink_eh_frame->size = size + pad;
13702 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13703 }
13704
13705 maybe_strip_output (info, htab->brlt);
13706 if (htab->glink_eh_frame != NULL)
13707 maybe_strip_output (info, htab->glink_eh_frame);
13708
13709 return TRUE;
13710 }
13711
13712 /* Called after we have determined section placement. If sections
13713 move, we'll be called again. Provide a value for TOCstart. */
13714
13715 bfd_vma
13716 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13717 {
13718 asection *s;
13719 bfd_vma TOCstart, adjust;
13720
13721 if (info != NULL)
13722 {
13723 struct elf_link_hash_entry *h;
13724 struct elf_link_hash_table *htab = elf_hash_table (info);
13725
13726 if (is_elf_hash_table (htab)
13727 && htab->hgot != NULL)
13728 h = htab->hgot;
13729 else
13730 {
13731 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13732 if (is_elf_hash_table (htab))
13733 htab->hgot = h;
13734 }
13735 if (h != NULL
13736 && h->root.type == bfd_link_hash_defined
13737 && !h->root.linker_def
13738 && (!is_elf_hash_table (htab)
13739 || h->def_regular))
13740 {
13741 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13742 + h->root.u.def.section->output_offset
13743 + h->root.u.def.section->output_section->vma);
13744 _bfd_set_gp_value (obfd, TOCstart);
13745 return TOCstart;
13746 }
13747 }
13748
13749 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13750 order. The TOC starts where the first of these sections starts. */
13751 s = bfd_get_section_by_name (obfd, ".got");
13752 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13753 s = bfd_get_section_by_name (obfd, ".toc");
13754 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13755 s = bfd_get_section_by_name (obfd, ".tocbss");
13756 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13757 s = bfd_get_section_by_name (obfd, ".plt");
13758 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13759 {
13760 /* This may happen for
13761 o references to TOC base (SYM@toc / TOC[tc0]) without a
13762 .toc directive
13763 o bad linker script
13764 o --gc-sections and empty TOC sections
13765
13766 FIXME: Warn user? */
13767
13768 /* Look for a likely section. We probably won't even be
13769 using TOCstart. */
13770 for (s = obfd->sections; s != NULL; s = s->next)
13771 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13772 | SEC_EXCLUDE))
13773 == (SEC_ALLOC | SEC_SMALL_DATA))
13774 break;
13775 if (s == NULL)
13776 for (s = obfd->sections; s != NULL; s = s->next)
13777 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13778 == (SEC_ALLOC | SEC_SMALL_DATA))
13779 break;
13780 if (s == NULL)
13781 for (s = obfd->sections; s != NULL; s = s->next)
13782 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13783 == SEC_ALLOC)
13784 break;
13785 if (s == NULL)
13786 for (s = obfd->sections; s != NULL; s = s->next)
13787 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13788 break;
13789 }
13790
13791 TOCstart = 0;
13792 if (s != NULL)
13793 TOCstart = s->output_section->vma + s->output_offset;
13794
13795 /* Force alignment. */
13796 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13797 TOCstart -= adjust;
13798 _bfd_set_gp_value (obfd, TOCstart);
13799
13800 if (info != NULL && s != NULL)
13801 {
13802 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13803
13804 if (htab != NULL)
13805 {
13806 if (htab->elf.hgot != NULL)
13807 {
13808 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13809 htab->elf.hgot->root.u.def.section = s;
13810 }
13811 }
13812 else
13813 {
13814 struct bfd_link_hash_entry *bh = NULL;
13815 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13816 s, TOC_BASE_OFF - adjust,
13817 NULL, FALSE, FALSE, &bh);
13818 }
13819 }
13820 return TOCstart;
13821 }
13822
13823 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13824 write out any global entry stubs, and PLT relocations. */
13825
13826 static bfd_boolean
13827 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13828 {
13829 struct bfd_link_info *info;
13830 struct ppc_link_hash_table *htab;
13831 struct plt_entry *ent;
13832 asection *s;
13833
13834 if (h->root.type == bfd_link_hash_indirect)
13835 return TRUE;
13836
13837 info = inf;
13838 htab = ppc_hash_table (info);
13839 if (htab == NULL)
13840 return FALSE;
13841
13842 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13843 if (ent->plt.offset != (bfd_vma) -1)
13844 {
13845 /* This symbol has an entry in the procedure linkage
13846 table. Set it up. */
13847 Elf_Internal_Rela rela;
13848 asection *plt, *relplt;
13849 bfd_byte *loc;
13850
13851 if (!htab->elf.dynamic_sections_created
13852 || h->dynindx == -1)
13853 {
13854 if (!(h->def_regular
13855 && (h->root.type == bfd_link_hash_defined
13856 || h->root.type == bfd_link_hash_defweak)))
13857 continue;
13858 if (h->type == STT_GNU_IFUNC)
13859 {
13860 plt = htab->elf.iplt;
13861 relplt = htab->elf.irelplt;
13862 htab->local_ifunc_resolver = 1;
13863 if (htab->opd_abi)
13864 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13865 else
13866 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13867 }
13868 else
13869 {
13870 plt = htab->pltlocal;
13871 if (bfd_link_pic (info))
13872 {
13873 relplt = htab->relpltlocal;
13874 if (htab->opd_abi)
13875 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13876 else
13877 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13878 }
13879 else
13880 relplt = NULL;
13881 }
13882 rela.r_addend = (h->root.u.def.value
13883 + h->root.u.def.section->output_offset
13884 + h->root.u.def.section->output_section->vma
13885 + ent->addend);
13886
13887 if (relplt == NULL)
13888 {
13889 loc = plt->contents + ent->plt.offset;
13890 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13891 if (htab->opd_abi)
13892 {
13893 bfd_vma toc = elf_gp (info->output_bfd);
13894 toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13895 bfd_put_64 (info->output_bfd, toc, loc + 8);
13896 }
13897 }
13898 else
13899 {
13900 rela.r_offset = (plt->output_section->vma
13901 + plt->output_offset
13902 + ent->plt.offset);
13903 loc = relplt->contents + (relplt->reloc_count++
13904 * sizeof (Elf64_External_Rela));
13905 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13906 }
13907 }
13908 else
13909 {
13910 rela.r_offset = (htab->elf.splt->output_section->vma
13911 + htab->elf.splt->output_offset
13912 + ent->plt.offset);
13913 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13914 rela.r_addend = ent->addend;
13915 loc = (htab->elf.srelplt->contents
13916 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13917 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13918 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13919 htab->maybe_local_ifunc_resolver = 1;
13920 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13921 }
13922 }
13923
13924 if (!h->pointer_equality_needed)
13925 return TRUE;
13926
13927 if (h->def_regular)
13928 return TRUE;
13929
13930 s = htab->global_entry;
13931 if (s == NULL || s->size == 0)
13932 return TRUE;
13933
13934 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13935 if (ent->plt.offset != (bfd_vma) -1
13936 && ent->addend == 0)
13937 {
13938 bfd_byte *p;
13939 asection *plt;
13940 bfd_vma off;
13941
13942 p = s->contents + h->root.u.def.value;
13943 plt = htab->elf.splt;
13944 if (!htab->elf.dynamic_sections_created
13945 || h->dynindx == -1)
13946 {
13947 if (h->type == STT_GNU_IFUNC)
13948 plt = htab->elf.iplt;
13949 else
13950 plt = htab->pltlocal;
13951 }
13952 off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13953 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13954
13955 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13956 {
13957 info->callbacks->einfo
13958 (_("%P: linkage table error against `%pT'\n"),
13959 h->root.root.string);
13960 bfd_set_error (bfd_error_bad_value);
13961 htab->stub_error = TRUE;
13962 }
13963
13964 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13965 if (htab->params->emit_stub_syms)
13966 {
13967 size_t len = strlen (h->root.root.string);
13968 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13969
13970 if (name == NULL)
13971 return FALSE;
13972
13973 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13974 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13975 if (h == NULL)
13976 return FALSE;
13977 if (h->root.type == bfd_link_hash_new)
13978 {
13979 h->root.type = bfd_link_hash_defined;
13980 h->root.u.def.section = s;
13981 h->root.u.def.value = p - s->contents;
13982 h->ref_regular = 1;
13983 h->def_regular = 1;
13984 h->ref_regular_nonweak = 1;
13985 h->forced_local = 1;
13986 h->non_elf = 0;
13987 h->root.linker_def = 1;
13988 }
13989 }
13990
13991 if (PPC_HA (off) != 0)
13992 {
13993 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13994 p += 4;
13995 }
13996 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13997 p += 4;
13998 bfd_put_32 (s->owner, MTCTR_R12, p);
13999 p += 4;
14000 bfd_put_32 (s->owner, BCTR, p);
14001 break;
14002 }
14003 return TRUE;
14004 }
14005
14006 /* Write PLT relocs for locals. */
14007
14008 static bfd_boolean
14009 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
14010 {
14011 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14012 bfd *ibfd;
14013
14014 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
14015 {
14016 struct got_entry **lgot_ents, **end_lgot_ents;
14017 struct plt_entry **local_plt, **lplt, **end_local_plt;
14018 Elf_Internal_Shdr *symtab_hdr;
14019 bfd_size_type locsymcount;
14020 Elf_Internal_Sym *local_syms = NULL;
14021 struct plt_entry *ent;
14022
14023 if (!is_ppc64_elf (ibfd))
14024 continue;
14025
14026 lgot_ents = elf_local_got_ents (ibfd);
14027 if (!lgot_ents)
14028 continue;
14029
14030 symtab_hdr = &elf_symtab_hdr (ibfd);
14031 locsymcount = symtab_hdr->sh_info;
14032 end_lgot_ents = lgot_ents + locsymcount;
14033 local_plt = (struct plt_entry **) end_lgot_ents;
14034 end_local_plt = local_plt + locsymcount;
14035 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
14036 for (ent = *lplt; ent != NULL; ent = ent->next)
14037 if (ent->plt.offset != (bfd_vma) -1)
14038 {
14039 Elf_Internal_Sym *sym;
14040 asection *sym_sec;
14041 asection *plt, *relplt;
14042 bfd_byte *loc;
14043 bfd_vma val;
14044
14045 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
14046 lplt - local_plt, ibfd))
14047 {
14048 if (local_syms != NULL
14049 && symtab_hdr->contents != (unsigned char *) local_syms)
14050 free (local_syms);
14051 return FALSE;
14052 }
14053
14054 val = sym->st_value + ent->addend;
14055 val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
14056 if (sym_sec != NULL && sym_sec->output_section != NULL)
14057 val += sym_sec->output_offset + sym_sec->output_section->vma;
14058
14059 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14060 {
14061 htab->local_ifunc_resolver = 1;
14062 plt = htab->elf.iplt;
14063 relplt = htab->elf.irelplt;
14064 }
14065 else
14066 {
14067 plt = htab->pltlocal;
14068 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
14069 }
14070
14071 if (relplt == NULL)
14072 {
14073 loc = plt->contents + ent->plt.offset;
14074 bfd_put_64 (info->output_bfd, val, loc);
14075 if (htab->opd_abi)
14076 {
14077 bfd_vma toc = elf_gp (ibfd);
14078 bfd_put_64 (info->output_bfd, toc, loc + 8);
14079 }
14080 }
14081 else
14082 {
14083 Elf_Internal_Rela rela;
14084 rela.r_offset = (ent->plt.offset
14085 + plt->output_offset
14086 + plt->output_section->vma);
14087 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14088 {
14089 if (htab->opd_abi)
14090 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14091 else
14092 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14093 }
14094 else
14095 {
14096 if (htab->opd_abi)
14097 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
14098 else
14099 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14100 }
14101 rela.r_addend = val;
14102 loc = relplt->contents + (relplt->reloc_count++
14103 * sizeof (Elf64_External_Rela));
14104 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
14105 }
14106 }
14107
14108 if (local_syms != NULL
14109 && symtab_hdr->contents != (unsigned char *) local_syms)
14110 {
14111 if (!info->keep_memory)
14112 free (local_syms);
14113 else
14114 symtab_hdr->contents = (unsigned char *) local_syms;
14115 }
14116 }
14117 return TRUE;
14118 }
14119
14120 /* Build all the stubs associated with the current output file.
14121 The stubs are kept in a hash table attached to the main linker
14122 hash table. This function is called via gldelf64ppc_finish. */
14123
14124 bfd_boolean
14125 ppc64_elf_build_stubs (struct bfd_link_info *info,
14126 char **stats)
14127 {
14128 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14129 struct map_stub *group;
14130 asection *stub_sec;
14131 bfd_byte *p;
14132 int stub_sec_count = 0;
14133
14134 if (htab == NULL)
14135 return FALSE;
14136
14137 /* Allocate memory to hold the linker stubs. */
14138 for (group = htab->group; group != NULL; group = group->next)
14139 {
14140 group->eh_size = 0;
14141 group->lr_restore = 0;
14142 if ((stub_sec = group->stub_sec) != NULL
14143 && stub_sec->size != 0)
14144 {
14145 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
14146 stub_sec->size);
14147 if (stub_sec->contents == NULL)
14148 return FALSE;
14149 stub_sec->size = 0;
14150 }
14151 }
14152
14153 if (htab->glink != NULL && htab->glink->size != 0)
14154 {
14155 unsigned int indx;
14156 bfd_vma plt0;
14157
14158 /* Build the .glink plt call stub. */
14159 if (htab->params->emit_stub_syms)
14160 {
14161 struct elf_link_hash_entry *h;
14162 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
14163 TRUE, FALSE, FALSE);
14164 if (h == NULL)
14165 return FALSE;
14166 if (h->root.type == bfd_link_hash_new)
14167 {
14168 h->root.type = bfd_link_hash_defined;
14169 h->root.u.def.section = htab->glink;
14170 h->root.u.def.value = 8;
14171 h->ref_regular = 1;
14172 h->def_regular = 1;
14173 h->ref_regular_nonweak = 1;
14174 h->forced_local = 1;
14175 h->non_elf = 0;
14176 h->root.linker_def = 1;
14177 }
14178 }
14179 plt0 = (htab->elf.splt->output_section->vma
14180 + htab->elf.splt->output_offset
14181 - 16);
14182 if (info->emitrelocations)
14183 {
14184 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
14185 if (r == NULL)
14186 return FALSE;
14187 r->r_offset = (htab->glink->output_offset
14188 + htab->glink->output_section->vma);
14189 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
14190 r->r_addend = plt0;
14191 }
14192 p = htab->glink->contents;
14193 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
14194 bfd_put_64 (htab->glink->owner, plt0, p);
14195 p += 8;
14196 if (htab->opd_abi)
14197 {
14198 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
14199 p += 4;
14200 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14201 p += 4;
14202 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14203 p += 4;
14204 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14205 p += 4;
14206 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
14207 p += 4;
14208 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14209 p += 4;
14210 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14211 p += 4;
14212 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
14213 p += 4;
14214 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14215 p += 4;
14216 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
14217 p += 4;
14218 }
14219 else
14220 {
14221 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
14222 p += 4;
14223 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14224 p += 4;
14225 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14226 p += 4;
14227 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
14228 p += 4;
14229 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14230 p += 4;
14231 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
14232 p += 4;
14233 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
14234 p += 4;
14235 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14236 p += 4;
14237 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
14238 p += 4;
14239 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14240 p += 4;
14241 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
14242 p += 4;
14243 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14244 p += 4;
14245 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
14246 p += 4;
14247 }
14248 bfd_put_32 (htab->glink->owner, BCTR, p);
14249 p += 4;
14250 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
14251
14252 /* Build the .glink lazy link call stubs. */
14253 indx = 0;
14254 while (p < htab->glink->contents + htab->glink->size)
14255 {
14256 if (htab->opd_abi)
14257 {
14258 if (indx < 0x8000)
14259 {
14260 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
14261 p += 4;
14262 }
14263 else
14264 {
14265 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
14266 p += 4;
14267 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
14268 p);
14269 p += 4;
14270 }
14271 }
14272 bfd_put_32 (htab->glink->owner,
14273 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
14274 indx++;
14275 p += 4;
14276 }
14277 }
14278
14279 /* Build .glink global entry stubs, and PLT relocs for globals. */
14280 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
14281
14282 if (!write_plt_relocs_for_local_syms (info))
14283 return FALSE;
14284
14285 if (htab->brlt != NULL && htab->brlt->size != 0)
14286 {
14287 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
14288 htab->brlt->size);
14289 if (htab->brlt->contents == NULL)
14290 return FALSE;
14291 }
14292 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
14293 {
14294 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
14295 htab->relbrlt->size);
14296 if (htab->relbrlt->contents == NULL)
14297 return FALSE;
14298 }
14299
14300 /* Build the stubs as directed by the stub hash table. */
14301 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
14302
14303 for (group = htab->group; group != NULL; group = group->next)
14304 if (group->needs_save_res)
14305 group->stub_sec->size += htab->sfpr->size;
14306
14307 if (htab->relbrlt != NULL)
14308 htab->relbrlt->reloc_count = 0;
14309
14310 if (htab->params->plt_stub_align != 0)
14311 for (group = htab->group; group != NULL; group = group->next)
14312 if ((stub_sec = group->stub_sec) != NULL)
14313 {
14314 int align = abs (htab->params->plt_stub_align);
14315 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
14316 }
14317
14318 for (group = htab->group; group != NULL; group = group->next)
14319 if (group->needs_save_res)
14320 {
14321 stub_sec = group->stub_sec;
14322 memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
14323 htab->sfpr->contents, htab->sfpr->size);
14324 if (htab->params->emit_stub_syms)
14325 {
14326 unsigned int i;
14327
14328 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
14329 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
14330 return FALSE;
14331 }
14332 }
14333
14334 if (htab->glink_eh_frame != NULL
14335 && htab->glink_eh_frame->size != 0)
14336 {
14337 bfd_vma val;
14338 size_t align = 4;
14339
14340 p = htab->glink_eh_frame->contents;
14341 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
14342
14343 for (group = htab->group; group != NULL; group = group->next)
14344 if (group->eh_size != 0)
14345 {
14346 /* Offset to stub section. */
14347 val = (group->stub_sec->output_section->vma
14348 + group->stub_sec->output_offset);
14349 val -= (htab->glink_eh_frame->output_section->vma
14350 + htab->glink_eh_frame->output_offset
14351 + (p + 8 - htab->glink_eh_frame->contents));
14352 if (val + 0x80000000 > 0xffffffff)
14353 {
14354 _bfd_error_handler
14355 (_("%s offset too large for .eh_frame sdata4 encoding"),
14356 group->stub_sec->name);
14357 return FALSE;
14358 }
14359 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14360 p += (group->eh_size + 17 + 3) & -4;
14361 }
14362 if (htab->glink != NULL && htab->glink->size != 0)
14363 {
14364 /* Offset to .glink. */
14365 val = (htab->glink->output_section->vma
14366 + htab->glink->output_offset
14367 + 8);
14368 val -= (htab->glink_eh_frame->output_section->vma
14369 + htab->glink_eh_frame->output_offset
14370 + (p + 8 - htab->glink_eh_frame->contents));
14371 if (val + 0x80000000 > 0xffffffff)
14372 {
14373 _bfd_error_handler
14374 (_("%s offset too large for .eh_frame sdata4 encoding"),
14375 htab->glink->name);
14376 return FALSE;
14377 }
14378 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14379 p += (24 + align - 1) & -align;
14380 }
14381 }
14382
14383 for (group = htab->group; group != NULL; group = group->next)
14384 if ((stub_sec = group->stub_sec) != NULL)
14385 {
14386 stub_sec_count += 1;
14387 if (stub_sec->rawsize != stub_sec->size
14388 && (htab->stub_iteration <= STUB_SHRINK_ITER
14389 || stub_sec->rawsize < stub_sec->size))
14390 break;
14391 }
14392
14393 if (group != NULL)
14394 {
14395 htab->stub_error = TRUE;
14396 _bfd_error_handler (_("stubs don't match calculated size"));
14397 }
14398
14399 if (htab->stub_error)
14400 return FALSE;
14401
14402 if (stats != NULL)
14403 {
14404 size_t len;
14405 *stats = bfd_malloc (500);
14406 if (*stats == NULL)
14407 return FALSE;
14408
14409 len = sprintf (*stats,
14410 ngettext ("linker stubs in %u group\n",
14411 "linker stubs in %u groups\n",
14412 stub_sec_count),
14413 stub_sec_count);
14414 sprintf (*stats + len, _(" branch %lu\n"
14415 " branch toc adj %lu\n"
14416 " branch notoc %lu\n"
14417 " branch both %lu\n"
14418 " long branch %lu\n"
14419 " long toc adj %lu\n"
14420 " long notoc %lu\n"
14421 " long both %lu\n"
14422 " plt call %lu\n"
14423 " plt call save %lu\n"
14424 " plt call notoc %lu\n"
14425 " plt call both %lu\n"
14426 " global entry %lu"),
14427 htab->stub_count[ppc_stub_long_branch - 1],
14428 htab->stub_count[ppc_stub_long_branch_r2off - 1],
14429 htab->stub_count[ppc_stub_long_branch_notoc - 1],
14430 htab->stub_count[ppc_stub_long_branch_both - 1],
14431 htab->stub_count[ppc_stub_plt_branch - 1],
14432 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14433 htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14434 htab->stub_count[ppc_stub_plt_branch_both - 1],
14435 htab->stub_count[ppc_stub_plt_call - 1],
14436 htab->stub_count[ppc_stub_plt_call_r2save - 1],
14437 htab->stub_count[ppc_stub_plt_call_notoc - 1],
14438 htab->stub_count[ppc_stub_plt_call_both - 1],
14439 htab->stub_count[ppc_stub_global_entry - 1]);
14440 }
14441 return TRUE;
14442 }
14443
14444 /* What to do when ld finds relocations against symbols defined in
14445 discarded sections. */
14446
14447 static unsigned int
14448 ppc64_elf_action_discarded (asection *sec)
14449 {
14450 if (strcmp (".opd", sec->name) == 0)
14451 return 0;
14452
14453 if (strcmp (".toc", sec->name) == 0)
14454 return 0;
14455
14456 if (strcmp (".toc1", sec->name) == 0)
14457 return 0;
14458
14459 return _bfd_elf_default_action_discarded (sec);
14460 }
14461
14462 /* The RELOCATE_SECTION function is called by the ELF backend linker
14463 to handle the relocations for a section.
14464
14465 The relocs are always passed as Rela structures; if the section
14466 actually uses Rel structures, the r_addend field will always be
14467 zero.
14468
14469 This function is responsible for adjust the section contents as
14470 necessary, and (if using Rela relocs and generating a
14471 relocatable output file) adjusting the reloc addend as
14472 necessary.
14473
14474 This function does not have to worry about setting the reloc
14475 address or the reloc symbol index.
14476
14477 LOCAL_SYMS is a pointer to the swapped in local symbols.
14478
14479 LOCAL_SECTIONS is an array giving the section in the input file
14480 corresponding to the st_shndx field of each local symbol.
14481
14482 The global hash table entry for the global symbols can be found
14483 via elf_sym_hashes (input_bfd).
14484
14485 When generating relocatable output, this function must handle
14486 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14487 going to be the section symbol corresponding to the output
14488 section, which means that the addend must be adjusted
14489 accordingly. */
14490
14491 static bfd_boolean
14492 ppc64_elf_relocate_section (bfd *output_bfd,
14493 struct bfd_link_info *info,
14494 bfd *input_bfd,
14495 asection *input_section,
14496 bfd_byte *contents,
14497 Elf_Internal_Rela *relocs,
14498 Elf_Internal_Sym *local_syms,
14499 asection **local_sections)
14500 {
14501 struct ppc_link_hash_table *htab;
14502 Elf_Internal_Shdr *symtab_hdr;
14503 struct elf_link_hash_entry **sym_hashes;
14504 Elf_Internal_Rela *rel;
14505 Elf_Internal_Rela *wrel;
14506 Elf_Internal_Rela *relend;
14507 Elf_Internal_Rela outrel;
14508 bfd_byte *loc;
14509 struct got_entry **local_got_ents;
14510 bfd_vma TOCstart;
14511 bfd_boolean ret = TRUE;
14512 bfd_boolean is_opd;
14513 /* Assume 'at' branch hints. */
14514 bfd_boolean is_isa_v2 = TRUE;
14515 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14516
14517 /* Initialize howto table if needed. */
14518 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14519 ppc_howto_init ();
14520
14521 htab = ppc_hash_table (info);
14522 if (htab == NULL)
14523 return FALSE;
14524
14525 /* Don't relocate stub sections. */
14526 if (input_section->owner == htab->params->stub_bfd)
14527 return TRUE;
14528
14529 BFD_ASSERT (is_ppc64_elf (input_bfd));
14530
14531 local_got_ents = elf_local_got_ents (input_bfd);
14532 TOCstart = elf_gp (output_bfd);
14533 symtab_hdr = &elf_symtab_hdr (input_bfd);
14534 sym_hashes = elf_sym_hashes (input_bfd);
14535 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14536
14537 rel = wrel = relocs;
14538 relend = relocs + input_section->reloc_count;
14539 for (; rel < relend; wrel++, rel++)
14540 {
14541 enum elf_ppc64_reloc_type r_type;
14542 bfd_vma addend;
14543 bfd_reloc_status_type r;
14544 Elf_Internal_Sym *sym;
14545 asection *sec;
14546 struct elf_link_hash_entry *h_elf;
14547 struct ppc_link_hash_entry *h;
14548 struct ppc_link_hash_entry *fdh;
14549 const char *sym_name;
14550 unsigned long r_symndx, toc_symndx;
14551 bfd_vma toc_addend;
14552 unsigned char tls_mask, tls_gd, tls_type;
14553 unsigned char sym_type;
14554 bfd_vma relocation;
14555 bfd_boolean unresolved_reloc, save_unresolved_reloc;
14556 bfd_boolean warned;
14557 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14558 unsigned int insn;
14559 unsigned int mask;
14560 struct ppc_stub_hash_entry *stub_entry;
14561 bfd_vma max_br_offset;
14562 bfd_vma from;
14563 Elf_Internal_Rela orig_rel;
14564 reloc_howto_type *howto;
14565 struct reloc_howto_struct alt_howto;
14566
14567 again:
14568 orig_rel = *rel;
14569
14570 r_type = ELF64_R_TYPE (rel->r_info);
14571 r_symndx = ELF64_R_SYM (rel->r_info);
14572
14573 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14574 symbol of the previous ADDR64 reloc. The symbol gives us the
14575 proper TOC base to use. */
14576 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14577 && wrel != relocs
14578 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14579 && is_opd)
14580 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14581
14582 sym = NULL;
14583 sec = NULL;
14584 h_elf = NULL;
14585 sym_name = NULL;
14586 unresolved_reloc = FALSE;
14587 warned = FALSE;
14588
14589 if (r_symndx < symtab_hdr->sh_info)
14590 {
14591 /* It's a local symbol. */
14592 struct _opd_sec_data *opd;
14593
14594 sym = local_syms + r_symndx;
14595 sec = local_sections[r_symndx];
14596 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14597 sym_type = ELF64_ST_TYPE (sym->st_info);
14598 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14599 opd = get_opd_info (sec);
14600 if (opd != NULL && opd->adjust != NULL)
14601 {
14602 long adjust = opd->adjust[OPD_NDX (sym->st_value
14603 + rel->r_addend)];
14604 if (adjust == -1)
14605 relocation = 0;
14606 else
14607 {
14608 /* If this is a relocation against the opd section sym
14609 and we have edited .opd, adjust the reloc addend so
14610 that ld -r and ld --emit-relocs output is correct.
14611 If it is a reloc against some other .opd symbol,
14612 then the symbol value will be adjusted later. */
14613 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14614 rel->r_addend += adjust;
14615 else
14616 relocation += adjust;
14617 }
14618 }
14619 }
14620 else
14621 {
14622 bfd_boolean ignored;
14623
14624 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14625 r_symndx, symtab_hdr, sym_hashes,
14626 h_elf, sec, relocation,
14627 unresolved_reloc, warned, ignored);
14628 sym_name = h_elf->root.root.string;
14629 sym_type = h_elf->type;
14630 if (sec != NULL
14631 && sec->owner == output_bfd
14632 && strcmp (sec->name, ".opd") == 0)
14633 {
14634 /* This is a symbol defined in a linker script. All
14635 such are defined in output sections, even those
14636 defined by simple assignment from a symbol defined in
14637 an input section. Transfer the symbol to an
14638 appropriate input .opd section, so that a branch to
14639 this symbol will be mapped to the location specified
14640 by the opd entry. */
14641 struct bfd_link_order *lo;
14642 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14643 if (lo->type == bfd_indirect_link_order)
14644 {
14645 asection *isec = lo->u.indirect.section;
14646 if (h_elf->root.u.def.value >= isec->output_offset
14647 && h_elf->root.u.def.value < (isec->output_offset
14648 + isec->size))
14649 {
14650 h_elf->root.u.def.value -= isec->output_offset;
14651 h_elf->root.u.def.section = isec;
14652 sec = isec;
14653 break;
14654 }
14655 }
14656 }
14657 }
14658 h = (struct ppc_link_hash_entry *) h_elf;
14659
14660 if (sec != NULL && discarded_section (sec))
14661 {
14662 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14663 input_bfd, input_section,
14664 contents + rel->r_offset);
14665 wrel->r_offset = rel->r_offset;
14666 wrel->r_info = 0;
14667 wrel->r_addend = 0;
14668
14669 /* For ld -r, remove relocations in debug sections against
14670 symbols defined in discarded sections. Not done for
14671 non-debug to preserve relocs in .eh_frame which the
14672 eh_frame editing code expects to be present. */
14673 if (bfd_link_relocatable (info)
14674 && (input_section->flags & SEC_DEBUGGING))
14675 wrel--;
14676
14677 continue;
14678 }
14679
14680 if (bfd_link_relocatable (info))
14681 goto copy_reloc;
14682
14683 if (h != NULL && &h->elf == htab->elf.hgot)
14684 {
14685 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14686 sec = bfd_abs_section_ptr;
14687 unresolved_reloc = FALSE;
14688 }
14689
14690 /* TLS optimizations. Replace instruction sequences and relocs
14691 based on information we collected in tls_optimize. We edit
14692 RELOCS so that --emit-relocs will output something sensible
14693 for the final instruction stream. */
14694 tls_mask = 0;
14695 tls_gd = 0;
14696 toc_symndx = 0;
14697 if (h != NULL)
14698 tls_mask = h->tls_mask;
14699 else if (local_got_ents != NULL)
14700 {
14701 struct plt_entry **local_plt = (struct plt_entry **)
14702 (local_got_ents + symtab_hdr->sh_info);
14703 unsigned char *lgot_masks = (unsigned char *)
14704 (local_plt + symtab_hdr->sh_info);
14705 tls_mask = lgot_masks[r_symndx];
14706 }
14707 if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14708 && (r_type == R_PPC64_TLS
14709 || r_type == R_PPC64_TLSGD
14710 || r_type == R_PPC64_TLSLD))
14711 {
14712 /* Check for toc tls entries. */
14713 unsigned char *toc_tls;
14714
14715 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14716 &local_syms, rel, input_bfd))
14717 return FALSE;
14718
14719 if (toc_tls)
14720 tls_mask = *toc_tls;
14721 }
14722
14723 /* Check that tls relocs are used with tls syms, and non-tls
14724 relocs are used with non-tls syms. */
14725 if (r_symndx != STN_UNDEF
14726 && r_type != R_PPC64_NONE
14727 && (h == NULL
14728 || h->elf.root.type == bfd_link_hash_defined
14729 || h->elf.root.type == bfd_link_hash_defweak)
14730 && (IS_PPC64_TLS_RELOC (r_type)
14731 != (sym_type == STT_TLS
14732 || (sym_type == STT_SECTION
14733 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14734 {
14735 if ((tls_mask & TLS_TLS) != 0
14736 && (r_type == R_PPC64_TLS
14737 || r_type == R_PPC64_TLSGD
14738 || r_type == R_PPC64_TLSLD))
14739 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14740 ;
14741 else
14742 info->callbacks->einfo
14743 (!IS_PPC64_TLS_RELOC (r_type)
14744 /* xgettext:c-format */
14745 ? _("%H: %s used with TLS symbol `%pT'\n")
14746 /* xgettext:c-format */
14747 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14748 input_bfd, input_section, rel->r_offset,
14749 ppc64_elf_howto_table[r_type]->name,
14750 sym_name);
14751 }
14752
14753 /* Ensure reloc mapping code below stays sane. */
14754 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14755 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14756 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
14757 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14758 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14759 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14760 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
14761 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14762 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14763 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14764 abort ();
14765
14766 switch (r_type)
14767 {
14768 default:
14769 break;
14770
14771 case R_PPC64_LO_DS_OPT:
14772 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14773 if ((insn & (0x3f << 26)) != 58u << 26)
14774 abort ();
14775 insn += (14u << 26) - (58u << 26);
14776 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14777 r_type = R_PPC64_TOC16_LO;
14778 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14779 break;
14780
14781 case R_PPC64_TOC16:
14782 case R_PPC64_TOC16_LO:
14783 case R_PPC64_TOC16_DS:
14784 case R_PPC64_TOC16_LO_DS:
14785 {
14786 /* Check for toc tls entries. */
14787 unsigned char *toc_tls;
14788 int retval;
14789
14790 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14791 &local_syms, rel, input_bfd);
14792 if (retval == 0)
14793 return FALSE;
14794
14795 if (toc_tls)
14796 {
14797 tls_mask = *toc_tls;
14798 if (r_type == R_PPC64_TOC16_DS
14799 || r_type == R_PPC64_TOC16_LO_DS)
14800 {
14801 if ((tls_mask & TLS_TLS) != 0
14802 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14803 goto toctprel;
14804 }
14805 else
14806 {
14807 /* If we found a GD reloc pair, then we might be
14808 doing a GD->IE transition. */
14809 if (retval == 2)
14810 {
14811 tls_gd = TLS_TPRELGD;
14812 if ((tls_mask & TLS_TLS) != 0
14813 && (tls_mask & TLS_GD) == 0)
14814 goto tls_ldgd_opt;
14815 }
14816 else if (retval == 3)
14817 {
14818 if ((tls_mask & TLS_TLS) != 0
14819 && (tls_mask & TLS_LD) == 0)
14820 goto tls_ldgd_opt;
14821 }
14822 }
14823 }
14824 }
14825 break;
14826
14827 case R_PPC64_GOT_TPREL16_HI:
14828 case R_PPC64_GOT_TPREL16_HA:
14829 if ((tls_mask & TLS_TLS) != 0
14830 && (tls_mask & TLS_TPREL) == 0)
14831 {
14832 rel->r_offset -= d_offset;
14833 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14834 r_type = R_PPC64_NONE;
14835 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14836 }
14837 break;
14838
14839 case R_PPC64_GOT_TPREL16_DS:
14840 case R_PPC64_GOT_TPREL16_LO_DS:
14841 if ((tls_mask & TLS_TLS) != 0
14842 && (tls_mask & TLS_TPREL) == 0)
14843 {
14844 toctprel:
14845 insn = bfd_get_32 (input_bfd,
14846 contents + rel->r_offset - d_offset);
14847 insn &= 31 << 21;
14848 insn |= 0x3c0d0000; /* addis 0,13,0 */
14849 bfd_put_32 (input_bfd, insn,
14850 contents + rel->r_offset - d_offset);
14851 r_type = R_PPC64_TPREL16_HA;
14852 if (toc_symndx != 0)
14853 {
14854 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14855 rel->r_addend = toc_addend;
14856 /* We changed the symbol. Start over in order to
14857 get h, sym, sec etc. right. */
14858 goto again;
14859 }
14860 else
14861 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14862 }
14863 break;
14864
14865 case R_PPC64_TLS:
14866 if ((tls_mask & TLS_TLS) != 0
14867 && (tls_mask & TLS_TPREL) == 0)
14868 {
14869 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14870 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14871 if (insn == 0)
14872 abort ();
14873 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14874 /* Was PPC64_TLS which sits on insn boundary, now
14875 PPC64_TPREL16_LO which is at low-order half-word. */
14876 rel->r_offset += d_offset;
14877 r_type = R_PPC64_TPREL16_LO;
14878 if (toc_symndx != 0)
14879 {
14880 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14881 rel->r_addend = toc_addend;
14882 /* We changed the symbol. Start over in order to
14883 get h, sym, sec etc. right. */
14884 goto again;
14885 }
14886 else
14887 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14888 }
14889 break;
14890
14891 case R_PPC64_GOT_TLSGD16_HI:
14892 case R_PPC64_GOT_TLSGD16_HA:
14893 tls_gd = TLS_TPRELGD;
14894 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14895 goto tls_gdld_hi;
14896 break;
14897
14898 case R_PPC64_GOT_TLSLD16_HI:
14899 case R_PPC64_GOT_TLSLD16_HA:
14900 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14901 {
14902 tls_gdld_hi:
14903 if ((tls_mask & tls_gd) != 0)
14904 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14905 + R_PPC64_GOT_TPREL16_DS);
14906 else
14907 {
14908 rel->r_offset -= d_offset;
14909 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14910 r_type = R_PPC64_NONE;
14911 }
14912 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14913 }
14914 break;
14915
14916 case R_PPC64_GOT_TLSGD16:
14917 case R_PPC64_GOT_TLSGD16_LO:
14918 tls_gd = TLS_TPRELGD;
14919 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14920 goto tls_ldgd_opt;
14921 break;
14922
14923 case R_PPC64_GOT_TLSLD16:
14924 case R_PPC64_GOT_TLSLD16_LO:
14925 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14926 {
14927 unsigned int insn1, insn2;
14928 bfd_vma offset;
14929
14930 tls_ldgd_opt:
14931 offset = (bfd_vma) -1;
14932 /* If not using the newer R_PPC64_TLSGD/LD to mark
14933 __tls_get_addr calls, we must trust that the call
14934 stays with its arg setup insns, ie. that the next
14935 reloc is the __tls_get_addr call associated with
14936 the current reloc. Edit both insns. */
14937 if (input_section->has_tls_get_addr_call
14938 && rel + 1 < relend
14939 && branch_reloc_hash_match (input_bfd, rel + 1,
14940 htab->tls_get_addr,
14941 htab->tls_get_addr_fd))
14942 offset = rel[1].r_offset;
14943 /* We read the low GOT_TLS (or TOC16) insn because we
14944 need to keep the destination reg. It may be
14945 something other than the usual r3, and moved to r3
14946 before the call by intervening code. */
14947 insn1 = bfd_get_32 (input_bfd,
14948 contents + rel->r_offset - d_offset);
14949 if ((tls_mask & tls_gd) != 0)
14950 {
14951 /* IE */
14952 insn1 &= (0x1f << 21) | (0x1f << 16);
14953 insn1 |= 58 << 26; /* ld */
14954 insn2 = 0x7c636a14; /* add 3,3,13 */
14955 if (offset != (bfd_vma) -1)
14956 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14957 if ((tls_mask & TLS_EXPLICIT) == 0)
14958 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14959 + R_PPC64_GOT_TPREL16_DS);
14960 else
14961 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14962 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14963 }
14964 else
14965 {
14966 /* LE */
14967 insn1 &= 0x1f << 21;
14968 insn1 |= 0x3c0d0000; /* addis r,13,0 */
14969 insn2 = 0x38630000; /* addi 3,3,0 */
14970 if (tls_gd == 0)
14971 {
14972 /* Was an LD reloc. */
14973 if (toc_symndx)
14974 sec = local_sections[toc_symndx];
14975 for (r_symndx = 0;
14976 r_symndx < symtab_hdr->sh_info;
14977 r_symndx++)
14978 if (local_sections[r_symndx] == sec)
14979 break;
14980 if (r_symndx >= symtab_hdr->sh_info)
14981 r_symndx = STN_UNDEF;
14982 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14983 if (r_symndx != STN_UNDEF)
14984 rel->r_addend -= (local_syms[r_symndx].st_value
14985 + sec->output_offset
14986 + sec->output_section->vma);
14987 }
14988 else if (toc_symndx != 0)
14989 {
14990 r_symndx = toc_symndx;
14991 rel->r_addend = toc_addend;
14992 }
14993 r_type = R_PPC64_TPREL16_HA;
14994 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14995 if (offset != (bfd_vma) -1)
14996 {
14997 rel[1].r_info = ELF64_R_INFO (r_symndx,
14998 R_PPC64_TPREL16_LO);
14999 rel[1].r_offset = offset + d_offset;
15000 rel[1].r_addend = rel->r_addend;
15001 }
15002 }
15003 bfd_put_32 (input_bfd, insn1,
15004 contents + rel->r_offset - d_offset);
15005 if (offset != (bfd_vma) -1)
15006 bfd_put_32 (input_bfd, insn2, contents + offset);
15007 if ((tls_mask & tls_gd) == 0
15008 && (tls_gd == 0 || toc_symndx != 0))
15009 {
15010 /* We changed the symbol. Start over in order
15011 to get h, sym, sec etc. right. */
15012 goto again;
15013 }
15014 }
15015 break;
15016
15017 case R_PPC64_TLSGD:
15018 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
15019 && rel + 1 < relend)
15020 {
15021 unsigned int insn2;
15022 bfd_vma offset = rel->r_offset;
15023
15024 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15025 {
15026 bfd_put_32 (output_bfd, NOP, contents + offset);
15027 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15028 break;
15029 }
15030
15031 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15032 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15033
15034 if ((tls_mask & TLS_TPRELGD) != 0)
15035 {
15036 /* IE */
15037 r_type = R_PPC64_NONE;
15038 insn2 = 0x7c636a14; /* add 3,3,13 */
15039 }
15040 else
15041 {
15042 /* LE */
15043 if (toc_symndx != 0)
15044 {
15045 r_symndx = toc_symndx;
15046 rel->r_addend = toc_addend;
15047 }
15048 r_type = R_PPC64_TPREL16_LO;
15049 rel->r_offset = offset + d_offset;
15050 insn2 = 0x38630000; /* addi 3,3,0 */
15051 }
15052 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15053 /* Zap the reloc on the _tls_get_addr call too. */
15054 BFD_ASSERT (offset == rel[1].r_offset);
15055 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15056 bfd_put_32 (input_bfd, insn2, contents + offset);
15057 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
15058 goto again;
15059 }
15060 break;
15061
15062 case R_PPC64_TLSLD:
15063 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
15064 && rel + 1 < relend)
15065 {
15066 unsigned int insn2;
15067 bfd_vma offset = rel->r_offset;
15068
15069 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15070 {
15071 bfd_put_32 (output_bfd, NOP, contents + offset);
15072 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15073 break;
15074 }
15075
15076 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15077 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15078
15079 if (toc_symndx)
15080 sec = local_sections[toc_symndx];
15081 for (r_symndx = 0;
15082 r_symndx < symtab_hdr->sh_info;
15083 r_symndx++)
15084 if (local_sections[r_symndx] == sec)
15085 break;
15086 if (r_symndx >= symtab_hdr->sh_info)
15087 r_symndx = STN_UNDEF;
15088 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
15089 if (r_symndx != STN_UNDEF)
15090 rel->r_addend -= (local_syms[r_symndx].st_value
15091 + sec->output_offset
15092 + sec->output_section->vma);
15093
15094 r_type = R_PPC64_TPREL16_LO;
15095 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15096 rel->r_offset = offset + d_offset;
15097 /* Zap the reloc on the _tls_get_addr call too. */
15098 BFD_ASSERT (offset == rel[1].r_offset);
15099 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15100 insn2 = 0x38630000; /* addi 3,3,0 */
15101 bfd_put_32 (input_bfd, insn2, contents + offset);
15102 goto again;
15103 }
15104 break;
15105
15106 case R_PPC64_DTPMOD64:
15107 if (rel + 1 < relend
15108 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
15109 && rel[1].r_offset == rel->r_offset + 8)
15110 {
15111 if ((tls_mask & TLS_GD) == 0)
15112 {
15113 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
15114 if ((tls_mask & TLS_TPRELGD) != 0)
15115 r_type = R_PPC64_TPREL64;
15116 else
15117 {
15118 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15119 r_type = R_PPC64_NONE;
15120 }
15121 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15122 }
15123 }
15124 else
15125 {
15126 if ((tls_mask & TLS_LD) == 0)
15127 {
15128 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15129 r_type = R_PPC64_NONE;
15130 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15131 }
15132 }
15133 break;
15134
15135 case R_PPC64_TPREL64:
15136 if ((tls_mask & TLS_TPREL) == 0)
15137 {
15138 r_type = R_PPC64_NONE;
15139 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15140 }
15141 break;
15142
15143 case R_PPC64_ENTRY:
15144 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
15145 if (!bfd_link_pic (info)
15146 && !info->traditional_format
15147 && relocation + 0x80008000 <= 0xffffffff)
15148 {
15149 unsigned int insn1, insn2;
15150
15151 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15152 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15153 if ((insn1 & ~0xfffc) == LD_R2_0R12
15154 && insn2 == ADD_R2_R2_R12)
15155 {
15156 bfd_put_32 (input_bfd,
15157 LIS_R2 + PPC_HA (relocation),
15158 contents + rel->r_offset);
15159 bfd_put_32 (input_bfd,
15160 ADDI_R2_R2 + PPC_LO (relocation),
15161 contents + rel->r_offset + 4);
15162 }
15163 }
15164 else
15165 {
15166 relocation -= (rel->r_offset
15167 + input_section->output_offset
15168 + input_section->output_section->vma);
15169 if (relocation + 0x80008000 <= 0xffffffff)
15170 {
15171 unsigned int insn1, insn2;
15172
15173 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15174 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15175 if ((insn1 & ~0xfffc) == LD_R2_0R12
15176 && insn2 == ADD_R2_R2_R12)
15177 {
15178 bfd_put_32 (input_bfd,
15179 ADDIS_R2_R12 + PPC_HA (relocation),
15180 contents + rel->r_offset);
15181 bfd_put_32 (input_bfd,
15182 ADDI_R2_R2 + PPC_LO (relocation),
15183 contents + rel->r_offset + 4);
15184 }
15185 }
15186 }
15187 break;
15188
15189 case R_PPC64_REL16_HA:
15190 /* If we are generating a non-PIC executable, edit
15191 . 0: addis 2,12,.TOC.-0b@ha
15192 . addi 2,2,.TOC.-0b@l
15193 used by ELFv2 global entry points to set up r2, to
15194 . lis 2,.TOC.@ha
15195 . addi 2,2,.TOC.@l
15196 if .TOC. is in range. */
15197 if (!bfd_link_pic (info)
15198 && !info->traditional_format
15199 && !htab->opd_abi
15200 && rel->r_addend == d_offset
15201 && h != NULL && &h->elf == htab->elf.hgot
15202 && rel + 1 < relend
15203 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
15204 && rel[1].r_offset == rel->r_offset + 4
15205 && rel[1].r_addend == rel->r_addend + 4
15206 && relocation + 0x80008000 <= 0xffffffff)
15207 {
15208 unsigned int insn1, insn2;
15209 bfd_vma offset = rel->r_offset - d_offset;
15210 insn1 = bfd_get_32 (input_bfd, contents + offset);
15211 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
15212 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
15213 && (insn2 & 0xffff0000) == ADDI_R2_R2)
15214 {
15215 r_type = R_PPC64_ADDR16_HA;
15216 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15217 rel->r_addend -= d_offset;
15218 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
15219 rel[1].r_addend -= d_offset + 4;
15220 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
15221 }
15222 }
15223 break;
15224 }
15225
15226 /* Handle other relocations that tweak non-addend part of insn. */
15227 insn = 0;
15228 max_br_offset = 1 << 25;
15229 addend = rel->r_addend;
15230 reloc_dest = DEST_NORMAL;
15231 switch (r_type)
15232 {
15233 default:
15234 break;
15235
15236 case R_PPC64_TOCSAVE:
15237 if (relocation + addend == (rel->r_offset
15238 + input_section->output_offset
15239 + input_section->output_section->vma)
15240 && tocsave_find (htab, NO_INSERT,
15241 &local_syms, rel, input_bfd))
15242 {
15243 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15244 if (insn == NOP
15245 || insn == CROR_151515 || insn == CROR_313131)
15246 bfd_put_32 (input_bfd,
15247 STD_R2_0R1 + STK_TOC (htab),
15248 contents + rel->r_offset);
15249 }
15250 break;
15251
15252 /* Branch taken prediction relocations. */
15253 case R_PPC64_ADDR14_BRTAKEN:
15254 case R_PPC64_REL14_BRTAKEN:
15255 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15256 /* Fall through. */
15257
15258 /* Branch not taken prediction relocations. */
15259 case R_PPC64_ADDR14_BRNTAKEN:
15260 case R_PPC64_REL14_BRNTAKEN:
15261 insn |= bfd_get_32 (input_bfd,
15262 contents + rel->r_offset) & ~(0x01 << 21);
15263 /* Fall through. */
15264
15265 case R_PPC64_REL14:
15266 max_br_offset = 1 << 15;
15267 /* Fall through. */
15268
15269 case R_PPC64_REL24:
15270 case R_PPC64_REL24_NOTOC:
15271 case R_PPC64_PLTCALL:
15272 /* Calls to functions with a different TOC, such as calls to
15273 shared objects, need to alter the TOC pointer. This is
15274 done using a linkage stub. A REL24 branching to these
15275 linkage stubs needs to be followed by a nop, as the nop
15276 will be replaced with an instruction to restore the TOC
15277 base pointer. */
15278 fdh = h;
15279 if (h != NULL
15280 && h->oh != NULL
15281 && h->oh->is_func_descriptor)
15282 fdh = ppc_follow_link (h->oh);
15283 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15284 htab);
15285 if (r_type == R_PPC64_PLTCALL
15286 && stub_entry != NULL
15287 && stub_entry->stub_type >= ppc_stub_plt_call
15288 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15289 stub_entry = NULL;
15290
15291 if (stub_entry != NULL
15292 && (stub_entry->stub_type == ppc_stub_plt_call
15293 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15294 || stub_entry->stub_type == ppc_stub_plt_call_both
15295 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15296 || stub_entry->stub_type == ppc_stub_plt_branch_both
15297 || stub_entry->stub_type == ppc_stub_long_branch_r2off
15298 || stub_entry->stub_type == ppc_stub_long_branch_both))
15299 {
15300 bfd_boolean can_plt_call = FALSE;
15301
15302 if (stub_entry->stub_type == ppc_stub_plt_call
15303 && !htab->opd_abi
15304 && htab->params->plt_localentry0 != 0
15305 && is_elfv2_localentry0 (&h->elf))
15306 {
15307 /* The function doesn't use or change r2. */
15308 can_plt_call = TRUE;
15309 }
15310 else if (r_type == R_PPC64_REL24_NOTOC)
15311 {
15312 /* NOTOC calls don't need to restore r2. */
15313 can_plt_call = TRUE;
15314 }
15315
15316 /* All of these stubs may modify r2, so there must be a
15317 branch and link followed by a nop. The nop is
15318 replaced by an insn to restore r2. */
15319 else if (rel->r_offset + 8 <= input_section->size)
15320 {
15321 unsigned long br;
15322
15323 br = bfd_get_32 (input_bfd,
15324 contents + rel->r_offset);
15325 if ((br & 1) != 0)
15326 {
15327 unsigned long nop;
15328
15329 nop = bfd_get_32 (input_bfd,
15330 contents + rel->r_offset + 4);
15331 if (nop == LD_R2_0R1 + STK_TOC (htab))
15332 can_plt_call = TRUE;
15333 else if (nop == NOP
15334 || nop == CROR_151515
15335 || nop == CROR_313131)
15336 {
15337 if (h != NULL
15338 && (h == htab->tls_get_addr_fd
15339 || h == htab->tls_get_addr)
15340 && htab->params->tls_get_addr_opt)
15341 {
15342 /* Special stub used, leave nop alone. */
15343 }
15344 else
15345 bfd_put_32 (input_bfd,
15346 LD_R2_0R1 + STK_TOC (htab),
15347 contents + rel->r_offset + 4);
15348 can_plt_call = TRUE;
15349 }
15350 }
15351 }
15352
15353 if (!can_plt_call && h != NULL)
15354 {
15355 const char *name = h->elf.root.root.string;
15356
15357 if (*name == '.')
15358 ++name;
15359
15360 if (strncmp (name, "__libc_start_main", 17) == 0
15361 && (name[17] == 0 || name[17] == '@'))
15362 {
15363 /* Allow crt1 branch to go via a toc adjusting
15364 stub. Other calls that never return could do
15365 the same, if we could detect such. */
15366 can_plt_call = TRUE;
15367 }
15368 }
15369
15370 if (!can_plt_call)
15371 {
15372 /* g++ as of 20130507 emits self-calls without a
15373 following nop. This is arguably wrong since we
15374 have conflicting information. On the one hand a
15375 global symbol and on the other a local call
15376 sequence, but don't error for this special case.
15377 It isn't possible to cheaply verify we have
15378 exactly such a call. Allow all calls to the same
15379 section. */
15380 asection *code_sec = sec;
15381
15382 if (get_opd_info (sec) != NULL)
15383 {
15384 bfd_vma off = (relocation + addend
15385 - sec->output_section->vma
15386 - sec->output_offset);
15387
15388 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15389 }
15390 if (code_sec == input_section)
15391 can_plt_call = TRUE;
15392 }
15393
15394 if (!can_plt_call)
15395 {
15396 if (stub_entry->stub_type >= ppc_stub_plt_call
15397 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15398 info->callbacks->einfo
15399 /* xgettext:c-format */
15400 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15401 "recompile with -fPIC\n"),
15402 input_bfd, input_section, rel->r_offset, sym_name);
15403 else
15404 info->callbacks->einfo
15405 /* xgettext:c-format */
15406 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15407 "(-mcmodel=small toc adjust stub)\n"),
15408 input_bfd, input_section, rel->r_offset, sym_name);
15409
15410 bfd_set_error (bfd_error_bad_value);
15411 ret = FALSE;
15412 }
15413
15414 if (can_plt_call
15415 && stub_entry->stub_type >= ppc_stub_plt_call
15416 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15417 unresolved_reloc = FALSE;
15418 }
15419
15420 if ((stub_entry == NULL
15421 || stub_entry->stub_type == ppc_stub_long_branch
15422 || stub_entry->stub_type == ppc_stub_plt_branch)
15423 && get_opd_info (sec) != NULL)
15424 {
15425 /* The branch destination is the value of the opd entry. */
15426 bfd_vma off = (relocation + addend
15427 - sec->output_section->vma
15428 - sec->output_offset);
15429 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15430 if (dest != (bfd_vma) -1)
15431 {
15432 relocation = dest;
15433 addend = 0;
15434 reloc_dest = DEST_OPD;
15435 }
15436 }
15437
15438 /* If the branch is out of reach we ought to have a long
15439 branch stub. */
15440 from = (rel->r_offset
15441 + input_section->output_offset
15442 + input_section->output_section->vma);
15443
15444 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15445 ? fdh->elf.other
15446 : sym->st_other);
15447
15448 if (stub_entry != NULL
15449 && (stub_entry->stub_type == ppc_stub_long_branch
15450 || stub_entry->stub_type == ppc_stub_plt_branch)
15451 && (r_type == R_PPC64_ADDR14_BRTAKEN
15452 || r_type == R_PPC64_ADDR14_BRNTAKEN
15453 || (relocation + addend - from + max_br_offset
15454 < 2 * max_br_offset)))
15455 /* Don't use the stub if this branch is in range. */
15456 stub_entry = NULL;
15457
15458 if (stub_entry != NULL
15459 && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15460 || stub_entry->stub_type == ppc_stub_long_branch_both
15461 || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15462 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15463 && (r_type != R_PPC64_REL24_NOTOC
15464 || ((fdh ? fdh->elf.other : sym->st_other)
15465 & STO_PPC64_LOCAL_MASK) == 1 << STO_PPC64_LOCAL_BIT)
15466 && (relocation + addend - from + max_br_offset
15467 < 2 * max_br_offset))
15468 stub_entry = NULL;
15469
15470 if (stub_entry != NULL
15471 && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15472 || stub_entry->stub_type == ppc_stub_long_branch_both
15473 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15474 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15475 && r_type == R_PPC64_REL24_NOTOC
15476 && (relocation + addend - from + max_br_offset
15477 < 2 * max_br_offset))
15478 stub_entry = NULL;
15479
15480 if (stub_entry != NULL)
15481 {
15482 /* Munge up the value and addend so that we call the stub
15483 rather than the procedure directly. */
15484 asection *stub_sec = stub_entry->group->stub_sec;
15485
15486 if (stub_entry->stub_type == ppc_stub_save_res)
15487 relocation += (stub_sec->output_offset
15488 + stub_sec->output_section->vma
15489 + stub_sec->size - htab->sfpr->size
15490 - htab->sfpr->output_offset
15491 - htab->sfpr->output_section->vma);
15492 else
15493 relocation = (stub_entry->stub_offset
15494 + stub_sec->output_offset
15495 + stub_sec->output_section->vma);
15496 addend = 0;
15497 reloc_dest = DEST_STUB;
15498
15499 if (((stub_entry->stub_type == ppc_stub_plt_call
15500 && ALWAYS_EMIT_R2SAVE)
15501 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15502 || stub_entry->stub_type == ppc_stub_plt_call_both)
15503 && !(h != NULL
15504 && (h == htab->tls_get_addr_fd
15505 || h == htab->tls_get_addr)
15506 && htab->params->tls_get_addr_opt)
15507 && rel + 1 < relend
15508 && rel[1].r_offset == rel->r_offset + 4
15509 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15510 relocation += 4;
15511 else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15512 || stub_entry->stub_type == ppc_stub_plt_branch_both
15513 || stub_entry->stub_type == ppc_stub_plt_call_both)
15514 && r_type == R_PPC64_REL24_NOTOC)
15515 relocation += 4;
15516 }
15517
15518 if (insn != 0)
15519 {
15520 if (is_isa_v2)
15521 {
15522 /* Set 'a' bit. This is 0b00010 in BO field for branch
15523 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15524 for branch on CTR insns (BO == 1a00t or 1a01t). */
15525 if ((insn & (0x14 << 21)) == (0x04 << 21))
15526 insn |= 0x02 << 21;
15527 else if ((insn & (0x14 << 21)) == (0x10 << 21))
15528 insn |= 0x08 << 21;
15529 else
15530 break;
15531 }
15532 else
15533 {
15534 /* Invert 'y' bit if not the default. */
15535 if ((bfd_signed_vma) (relocation + addend - from) < 0)
15536 insn ^= 0x01 << 21;
15537 }
15538
15539 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15540 }
15541
15542 /* NOP out calls to undefined weak functions.
15543 We can thus call a weak function without first
15544 checking whether the function is defined. */
15545 else if (h != NULL
15546 && h->elf.root.type == bfd_link_hash_undefweak
15547 && h->elf.dynindx == -1
15548 && (r_type == R_PPC64_REL24
15549 || r_type == R_PPC64_REL24_NOTOC)
15550 && relocation == 0
15551 && addend == 0)
15552 {
15553 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15554 goto copy_reloc;
15555 }
15556 break;
15557 }
15558
15559 /* Set `addend'. */
15560 tls_type = 0;
15561 save_unresolved_reloc = unresolved_reloc;
15562 switch (r_type)
15563 {
15564 default:
15565 /* xgettext:c-format */
15566 _bfd_error_handler (_("%pB: %s unsupported"),
15567 input_bfd, ppc64_elf_howto_table[r_type]->name);
15568
15569 bfd_set_error (bfd_error_bad_value);
15570 ret = FALSE;
15571 goto copy_reloc;
15572
15573 case R_PPC64_NONE:
15574 case R_PPC64_TLS:
15575 case R_PPC64_TLSGD:
15576 case R_PPC64_TLSLD:
15577 case R_PPC64_TOCSAVE:
15578 case R_PPC64_GNU_VTINHERIT:
15579 case R_PPC64_GNU_VTENTRY:
15580 case R_PPC64_ENTRY:
15581 goto copy_reloc;
15582
15583 /* GOT16 relocations. Like an ADDR16 using the symbol's
15584 address in the GOT as relocation value instead of the
15585 symbol's value itself. Also, create a GOT entry for the
15586 symbol and put the symbol value there. */
15587 case R_PPC64_GOT_TLSGD16:
15588 case R_PPC64_GOT_TLSGD16_LO:
15589 case R_PPC64_GOT_TLSGD16_HI:
15590 case R_PPC64_GOT_TLSGD16_HA:
15591 tls_type = TLS_TLS | TLS_GD;
15592 goto dogot;
15593
15594 case R_PPC64_GOT_TLSLD16:
15595 case R_PPC64_GOT_TLSLD16_LO:
15596 case R_PPC64_GOT_TLSLD16_HI:
15597 case R_PPC64_GOT_TLSLD16_HA:
15598 tls_type = TLS_TLS | TLS_LD;
15599 goto dogot;
15600
15601 case R_PPC64_GOT_TPREL16_DS:
15602 case R_PPC64_GOT_TPREL16_LO_DS:
15603 case R_PPC64_GOT_TPREL16_HI:
15604 case R_PPC64_GOT_TPREL16_HA:
15605 tls_type = TLS_TLS | TLS_TPREL;
15606 goto dogot;
15607
15608 case R_PPC64_GOT_DTPREL16_DS:
15609 case R_PPC64_GOT_DTPREL16_LO_DS:
15610 case R_PPC64_GOT_DTPREL16_HI:
15611 case R_PPC64_GOT_DTPREL16_HA:
15612 tls_type = TLS_TLS | TLS_DTPREL;
15613 goto dogot;
15614
15615 case R_PPC64_GOT16:
15616 case R_PPC64_GOT16_LO:
15617 case R_PPC64_GOT16_HI:
15618 case R_PPC64_GOT16_HA:
15619 case R_PPC64_GOT16_DS:
15620 case R_PPC64_GOT16_LO_DS:
15621 dogot:
15622 {
15623 /* Relocation is to the entry for this symbol in the global
15624 offset table. */
15625 asection *got;
15626 bfd_vma *offp;
15627 bfd_vma off;
15628 unsigned long indx = 0;
15629 struct got_entry *ent;
15630
15631 if (tls_type == (TLS_TLS | TLS_LD)
15632 && (h == NULL
15633 || !h->elf.def_dynamic))
15634 ent = ppc64_tlsld_got (input_bfd);
15635 else
15636 {
15637 if (h != NULL)
15638 {
15639 if (!htab->elf.dynamic_sections_created
15640 || h->elf.dynindx == -1
15641 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15642 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15643 /* This is actually a static link, or it is a
15644 -Bsymbolic link and the symbol is defined
15645 locally, or the symbol was forced to be local
15646 because of a version file. */
15647 ;
15648 else
15649 {
15650 indx = h->elf.dynindx;
15651 unresolved_reloc = FALSE;
15652 }
15653 ent = h->elf.got.glist;
15654 }
15655 else
15656 {
15657 if (local_got_ents == NULL)
15658 abort ();
15659 ent = local_got_ents[r_symndx];
15660 }
15661
15662 for (; ent != NULL; ent = ent->next)
15663 if (ent->addend == orig_rel.r_addend
15664 && ent->owner == input_bfd
15665 && ent->tls_type == tls_type)
15666 break;
15667 }
15668
15669 if (ent == NULL)
15670 abort ();
15671 if (ent->is_indirect)
15672 ent = ent->got.ent;
15673 offp = &ent->got.offset;
15674 got = ppc64_elf_tdata (ent->owner)->got;
15675 if (got == NULL)
15676 abort ();
15677
15678 /* The offset must always be a multiple of 8. We use the
15679 least significant bit to record whether we have already
15680 processed this entry. */
15681 off = *offp;
15682 if ((off & 1) != 0)
15683 off &= ~1;
15684 else
15685 {
15686 /* Generate relocs for the dynamic linker, except in
15687 the case of TLSLD where we'll use one entry per
15688 module. */
15689 asection *relgot;
15690 bfd_boolean ifunc;
15691
15692 *offp = off | 1;
15693 relgot = NULL;
15694 ifunc = (h != NULL
15695 ? h->elf.type == STT_GNU_IFUNC
15696 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15697 if (ifunc)
15698 {
15699 relgot = htab->elf.irelplt;
15700 if (indx == 0)
15701 htab->local_ifunc_resolver = 1;
15702 else if (is_static_defined (&h->elf))
15703 htab->maybe_local_ifunc_resolver = 1;
15704 }
15705 else if (indx != 0
15706 || (bfd_link_pic (info)
15707 && (h == NULL
15708 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15709 || (tls_type == (TLS_TLS | TLS_LD)
15710 && !h->elf.def_dynamic))
15711 && !(tls_type == (TLS_TLS | TLS_TPREL)
15712 && bfd_link_executable (info)
15713 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15714 relgot = ppc64_elf_tdata (ent->owner)->relgot;
15715 if (relgot != NULL)
15716 {
15717 outrel.r_offset = (got->output_section->vma
15718 + got->output_offset
15719 + off);
15720 outrel.r_addend = addend;
15721 if (tls_type & (TLS_LD | TLS_GD))
15722 {
15723 outrel.r_addend = 0;
15724 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15725 if (tls_type == (TLS_TLS | TLS_GD))
15726 {
15727 loc = relgot->contents;
15728 loc += (relgot->reloc_count++
15729 * sizeof (Elf64_External_Rela));
15730 bfd_elf64_swap_reloca_out (output_bfd,
15731 &outrel, loc);
15732 outrel.r_offset += 8;
15733 outrel.r_addend = addend;
15734 outrel.r_info
15735 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15736 }
15737 }
15738 else if (tls_type == (TLS_TLS | TLS_DTPREL))
15739 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15740 else if (tls_type == (TLS_TLS | TLS_TPREL))
15741 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15742 else if (indx != 0)
15743 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15744 else
15745 {
15746 if (ifunc)
15747 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15748 else
15749 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15750
15751 /* Write the .got section contents for the sake
15752 of prelink. */
15753 loc = got->contents + off;
15754 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15755 loc);
15756 }
15757
15758 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15759 {
15760 outrel.r_addend += relocation;
15761 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15762 {
15763 if (htab->elf.tls_sec == NULL)
15764 outrel.r_addend = 0;
15765 else
15766 outrel.r_addend -= htab->elf.tls_sec->vma;
15767 }
15768 }
15769 loc = relgot->contents;
15770 loc += (relgot->reloc_count++
15771 * sizeof (Elf64_External_Rela));
15772 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15773 }
15774
15775 /* Init the .got section contents here if we're not
15776 emitting a reloc. */
15777 else
15778 {
15779 relocation += addend;
15780 if (tls_type != 0)
15781 {
15782 if (htab->elf.tls_sec == NULL)
15783 relocation = 0;
15784 else
15785 {
15786 if (tls_type & TLS_LD)
15787 relocation = 0;
15788 else
15789 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15790 if (tls_type & TLS_TPREL)
15791 relocation += DTP_OFFSET - TP_OFFSET;
15792 }
15793
15794 if (tls_type & (TLS_GD | TLS_LD))
15795 {
15796 bfd_put_64 (output_bfd, relocation,
15797 got->contents + off + 8);
15798 relocation = 1;
15799 }
15800 }
15801 bfd_put_64 (output_bfd, relocation,
15802 got->contents + off);
15803 }
15804 }
15805
15806 if (off >= (bfd_vma) -2)
15807 abort ();
15808
15809 relocation = got->output_section->vma + got->output_offset + off;
15810 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15811 }
15812 break;
15813
15814 case R_PPC64_PLT16_HA:
15815 case R_PPC64_PLT16_HI:
15816 case R_PPC64_PLT16_LO:
15817 case R_PPC64_PLT16_LO_DS:
15818 case R_PPC64_PLT32:
15819 case R_PPC64_PLT64:
15820 case R_PPC64_PLTSEQ:
15821 case R_PPC64_PLTCALL:
15822 /* Relocation is to the entry for this symbol in the
15823 procedure linkage table. */
15824 unresolved_reloc = TRUE;
15825 {
15826 struct plt_entry **plt_list = NULL;
15827 if (h != NULL)
15828 plt_list = &h->elf.plt.plist;
15829 else if (local_got_ents != NULL)
15830 {
15831 struct plt_entry **local_plt = (struct plt_entry **)
15832 (local_got_ents + symtab_hdr->sh_info);
15833 plt_list = local_plt + r_symndx;
15834 }
15835 if (plt_list)
15836 {
15837 struct plt_entry *ent;
15838
15839 for (ent = *plt_list; ent != NULL; ent = ent->next)
15840 if (ent->plt.offset != (bfd_vma) -1
15841 && ent->addend == orig_rel.r_addend)
15842 {
15843 asection *plt;
15844 bfd_vma got;
15845
15846 plt = htab->elf.splt;
15847 if (!htab->elf.dynamic_sections_created
15848 || h == NULL
15849 || h->elf.dynindx == -1)
15850 {
15851 if (h != NULL
15852 ? h->elf.type == STT_GNU_IFUNC
15853 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15854 plt = htab->elf.iplt;
15855 else
15856 plt = htab->pltlocal;
15857 }
15858 relocation = (plt->output_section->vma
15859 + plt->output_offset
15860 + ent->plt.offset);
15861 if (r_type == R_PPC64_PLT16_HA
15862 || r_type == R_PPC64_PLT16_HI
15863 || r_type == R_PPC64_PLT16_LO
15864 || r_type == R_PPC64_PLT16_LO_DS)
15865 {
15866 got = (elf_gp (output_bfd)
15867 + htab->sec_info[input_section->id].toc_off);
15868 relocation -= got;
15869 }
15870 addend = 0;
15871 unresolved_reloc = FALSE;
15872 break;
15873 }
15874 }
15875 }
15876 break;
15877
15878 case R_PPC64_TOC:
15879 /* Relocation value is TOC base. */
15880 relocation = TOCstart;
15881 if (r_symndx == STN_UNDEF)
15882 relocation += htab->sec_info[input_section->id].toc_off;
15883 else if (unresolved_reloc)
15884 ;
15885 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15886 relocation += htab->sec_info[sec->id].toc_off;
15887 else
15888 unresolved_reloc = TRUE;
15889 goto dodyn;
15890
15891 /* TOC16 relocs. We want the offset relative to the TOC base,
15892 which is the address of the start of the TOC plus 0x8000.
15893 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15894 in this order. */
15895 case R_PPC64_TOC16:
15896 case R_PPC64_TOC16_LO:
15897 case R_PPC64_TOC16_HI:
15898 case R_PPC64_TOC16_DS:
15899 case R_PPC64_TOC16_LO_DS:
15900 case R_PPC64_TOC16_HA:
15901 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15902 break;
15903
15904 /* Relocate against the beginning of the section. */
15905 case R_PPC64_SECTOFF:
15906 case R_PPC64_SECTOFF_LO:
15907 case R_PPC64_SECTOFF_HI:
15908 case R_PPC64_SECTOFF_DS:
15909 case R_PPC64_SECTOFF_LO_DS:
15910 case R_PPC64_SECTOFF_HA:
15911 if (sec != NULL)
15912 addend -= sec->output_section->vma;
15913 break;
15914
15915 case R_PPC64_REL16:
15916 case R_PPC64_REL16_LO:
15917 case R_PPC64_REL16_HI:
15918 case R_PPC64_REL16_HA:
15919 case R_PPC64_REL16DX_HA:
15920 break;
15921
15922 case R_PPC64_REL14:
15923 case R_PPC64_REL14_BRNTAKEN:
15924 case R_PPC64_REL14_BRTAKEN:
15925 case R_PPC64_REL24:
15926 case R_PPC64_REL24_NOTOC:
15927 break;
15928
15929 case R_PPC64_TPREL16:
15930 case R_PPC64_TPREL16_LO:
15931 case R_PPC64_TPREL16_HI:
15932 case R_PPC64_TPREL16_HA:
15933 case R_PPC64_TPREL16_DS:
15934 case R_PPC64_TPREL16_LO_DS:
15935 case R_PPC64_TPREL16_HIGH:
15936 case R_PPC64_TPREL16_HIGHA:
15937 case R_PPC64_TPREL16_HIGHER:
15938 case R_PPC64_TPREL16_HIGHERA:
15939 case R_PPC64_TPREL16_HIGHEST:
15940 case R_PPC64_TPREL16_HIGHESTA:
15941 if (h != NULL
15942 && h->elf.root.type == bfd_link_hash_undefweak
15943 && h->elf.dynindx == -1)
15944 {
15945 /* Make this relocation against an undefined weak symbol
15946 resolve to zero. This is really just a tweak, since
15947 code using weak externs ought to check that they are
15948 defined before using them. */
15949 bfd_byte *p = contents + rel->r_offset - d_offset;
15950
15951 insn = bfd_get_32 (input_bfd, p);
15952 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15953 if (insn != 0)
15954 bfd_put_32 (input_bfd, insn, p);
15955 break;
15956 }
15957 if (htab->elf.tls_sec != NULL)
15958 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15959 /* The TPREL16 relocs shouldn't really be used in shared
15960 libs or with non-local symbols as that will result in
15961 DT_TEXTREL being set, but support them anyway. */
15962 goto dodyn;
15963
15964 case R_PPC64_DTPREL16:
15965 case R_PPC64_DTPREL16_LO:
15966 case R_PPC64_DTPREL16_HI:
15967 case R_PPC64_DTPREL16_HA:
15968 case R_PPC64_DTPREL16_DS:
15969 case R_PPC64_DTPREL16_LO_DS:
15970 case R_PPC64_DTPREL16_HIGH:
15971 case R_PPC64_DTPREL16_HIGHA:
15972 case R_PPC64_DTPREL16_HIGHER:
15973 case R_PPC64_DTPREL16_HIGHERA:
15974 case R_PPC64_DTPREL16_HIGHEST:
15975 case R_PPC64_DTPREL16_HIGHESTA:
15976 if (htab->elf.tls_sec != NULL)
15977 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15978 break;
15979
15980 case R_PPC64_ADDR64_LOCAL:
15981 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15982 ? h->elf.other
15983 : sym->st_other);
15984 break;
15985
15986 case R_PPC64_DTPMOD64:
15987 relocation = 1;
15988 addend = 0;
15989 goto dodyn;
15990
15991 case R_PPC64_TPREL64:
15992 if (htab->elf.tls_sec != NULL)
15993 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15994 goto dodyn;
15995
15996 case R_PPC64_DTPREL64:
15997 if (htab->elf.tls_sec != NULL)
15998 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15999 /* Fall through. */
16000
16001 /* Relocations that may need to be propagated if this is a
16002 dynamic object. */
16003 case R_PPC64_REL30:
16004 case R_PPC64_REL32:
16005 case R_PPC64_REL64:
16006 case R_PPC64_ADDR14:
16007 case R_PPC64_ADDR14_BRNTAKEN:
16008 case R_PPC64_ADDR14_BRTAKEN:
16009 case R_PPC64_ADDR16:
16010 case R_PPC64_ADDR16_DS:
16011 case R_PPC64_ADDR16_HA:
16012 case R_PPC64_ADDR16_HI:
16013 case R_PPC64_ADDR16_HIGH:
16014 case R_PPC64_ADDR16_HIGHA:
16015 case R_PPC64_ADDR16_HIGHER:
16016 case R_PPC64_ADDR16_HIGHERA:
16017 case R_PPC64_ADDR16_HIGHEST:
16018 case R_PPC64_ADDR16_HIGHESTA:
16019 case R_PPC64_ADDR16_LO:
16020 case R_PPC64_ADDR16_LO_DS:
16021 case R_PPC64_ADDR24:
16022 case R_PPC64_ADDR32:
16023 case R_PPC64_ADDR64:
16024 case R_PPC64_UADDR16:
16025 case R_PPC64_UADDR32:
16026 case R_PPC64_UADDR64:
16027 dodyn:
16028 if ((input_section->flags & SEC_ALLOC) == 0)
16029 break;
16030
16031 if (NO_OPD_RELOCS && is_opd)
16032 break;
16033
16034 if (bfd_link_pic (info)
16035 ? ((h == NULL
16036 || h->dyn_relocs != NULL)
16037 && ((h != NULL && pc_dynrelocs (h))
16038 || must_be_dyn_reloc (info, r_type)))
16039 : (h != NULL
16040 ? h->dyn_relocs != NULL
16041 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16042 {
16043 bfd_boolean skip, relocate;
16044 asection *sreloc;
16045 bfd_vma out_off;
16046 long indx = 0;
16047
16048 /* When generating a dynamic object, these relocations
16049 are copied into the output file to be resolved at run
16050 time. */
16051
16052 skip = FALSE;
16053 relocate = FALSE;
16054
16055 out_off = _bfd_elf_section_offset (output_bfd, info,
16056 input_section, rel->r_offset);
16057 if (out_off == (bfd_vma) -1)
16058 skip = TRUE;
16059 else if (out_off == (bfd_vma) -2)
16060 skip = TRUE, relocate = TRUE;
16061 out_off += (input_section->output_section->vma
16062 + input_section->output_offset);
16063 outrel.r_offset = out_off;
16064 outrel.r_addend = rel->r_addend;
16065
16066 /* Optimize unaligned reloc use. */
16067 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
16068 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
16069 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
16070 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
16071 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
16072 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
16073 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
16074 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
16075 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
16076
16077 if (skip)
16078 memset (&outrel, 0, sizeof outrel);
16079 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
16080 && !is_opd
16081 && r_type != R_PPC64_TOC)
16082 {
16083 indx = h->elf.dynindx;
16084 BFD_ASSERT (indx != -1);
16085 outrel.r_info = ELF64_R_INFO (indx, r_type);
16086 }
16087 else
16088 {
16089 /* This symbol is local, or marked to become local,
16090 or this is an opd section reloc which must point
16091 at a local function. */
16092 outrel.r_addend += relocation;
16093 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
16094 {
16095 if (is_opd && h != NULL)
16096 {
16097 /* Lie about opd entries. This case occurs
16098 when building shared libraries and we
16099 reference a function in another shared
16100 lib. The same thing happens for a weak
16101 definition in an application that's
16102 overridden by a strong definition in a
16103 shared lib. (I believe this is a generic
16104 bug in binutils handling of weak syms.)
16105 In these cases we won't use the opd
16106 entry in this lib. */
16107 unresolved_reloc = FALSE;
16108 }
16109 if (!is_opd
16110 && r_type == R_PPC64_ADDR64
16111 && (h != NULL
16112 ? h->elf.type == STT_GNU_IFUNC
16113 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16114 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
16115 else
16116 {
16117 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
16118
16119 /* We need to relocate .opd contents for ld.so.
16120 Prelink also wants simple and consistent rules
16121 for relocs. This make all RELATIVE relocs have
16122 *r_offset equal to r_addend. */
16123 relocate = TRUE;
16124 }
16125 }
16126 else
16127 {
16128 if (h != NULL
16129 ? h->elf.type == STT_GNU_IFUNC
16130 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16131 {
16132 info->callbacks->einfo
16133 /* xgettext:c-format */
16134 (_("%H: %s for indirect "
16135 "function `%pT' unsupported\n"),
16136 input_bfd, input_section, rel->r_offset,
16137 ppc64_elf_howto_table[r_type]->name,
16138 sym_name);
16139 ret = FALSE;
16140 }
16141 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
16142 ;
16143 else if (sec == NULL || sec->owner == NULL)
16144 {
16145 bfd_set_error (bfd_error_bad_value);
16146 return FALSE;
16147 }
16148 else
16149 {
16150 asection *osec;
16151
16152 osec = sec->output_section;
16153 indx = elf_section_data (osec)->dynindx;
16154
16155 if (indx == 0)
16156 {
16157 if ((osec->flags & SEC_READONLY) == 0
16158 && htab->elf.data_index_section != NULL)
16159 osec = htab->elf.data_index_section;
16160 else
16161 osec = htab->elf.text_index_section;
16162 indx = elf_section_data (osec)->dynindx;
16163 }
16164 BFD_ASSERT (indx != 0);
16165
16166 /* We are turning this relocation into one
16167 against a section symbol, so subtract out
16168 the output section's address but not the
16169 offset of the input section in the output
16170 section. */
16171 outrel.r_addend -= osec->vma;
16172 }
16173
16174 outrel.r_info = ELF64_R_INFO (indx, r_type);
16175 }
16176 }
16177
16178 sreloc = elf_section_data (input_section)->sreloc;
16179 if (h != NULL
16180 ? h->elf.type == STT_GNU_IFUNC
16181 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16182 {
16183 sreloc = htab->elf.irelplt;
16184 if (indx == 0)
16185 htab->local_ifunc_resolver = 1;
16186 else if (is_static_defined (&h->elf))
16187 htab->maybe_local_ifunc_resolver = 1;
16188 }
16189 if (sreloc == NULL)
16190 abort ();
16191
16192 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16193 >= sreloc->size)
16194 abort ();
16195 loc = sreloc->contents;
16196 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16197 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16198
16199 /* If this reloc is against an external symbol, it will
16200 be computed at runtime, so there's no need to do
16201 anything now. However, for the sake of prelink ensure
16202 that the section contents are a known value. */
16203 if (!relocate)
16204 {
16205 unresolved_reloc = FALSE;
16206 /* The value chosen here is quite arbitrary as ld.so
16207 ignores section contents except for the special
16208 case of .opd where the contents might be accessed
16209 before relocation. Choose zero, as that won't
16210 cause reloc overflow. */
16211 relocation = 0;
16212 addend = 0;
16213 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16214 to improve backward compatibility with older
16215 versions of ld. */
16216 if (r_type == R_PPC64_ADDR64)
16217 addend = outrel.r_addend;
16218 /* Adjust pc_relative relocs to have zero in *r_offset. */
16219 else if (ppc64_elf_howto_table[r_type]->pc_relative)
16220 addend = outrel.r_offset;
16221 }
16222 }
16223 break;
16224
16225 case R_PPC64_COPY:
16226 case R_PPC64_GLOB_DAT:
16227 case R_PPC64_JMP_SLOT:
16228 case R_PPC64_JMP_IREL:
16229 case R_PPC64_RELATIVE:
16230 /* We shouldn't ever see these dynamic relocs in relocatable
16231 files. */
16232 /* Fall through. */
16233
16234 case R_PPC64_PLTGOT16:
16235 case R_PPC64_PLTGOT16_DS:
16236 case R_PPC64_PLTGOT16_HA:
16237 case R_PPC64_PLTGOT16_HI:
16238 case R_PPC64_PLTGOT16_LO:
16239 case R_PPC64_PLTGOT16_LO_DS:
16240 case R_PPC64_PLTREL32:
16241 case R_PPC64_PLTREL64:
16242 /* These ones haven't been implemented yet. */
16243
16244 info->callbacks->einfo
16245 /* xgettext:c-format */
16246 (_("%P: %pB: %s is not supported for `%pT'\n"),
16247 input_bfd,
16248 ppc64_elf_howto_table[r_type]->name, sym_name);
16249
16250 bfd_set_error (bfd_error_invalid_operation);
16251 ret = FALSE;
16252 goto copy_reloc;
16253 }
16254
16255 /* Multi-instruction sequences that access the TOC can be
16256 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16257 to nop; addi rb,r2,x; */
16258 switch (r_type)
16259 {
16260 default:
16261 break;
16262
16263 case R_PPC64_GOT_TLSLD16_HI:
16264 case R_PPC64_GOT_TLSGD16_HI:
16265 case R_PPC64_GOT_TPREL16_HI:
16266 case R_PPC64_GOT_DTPREL16_HI:
16267 case R_PPC64_GOT16_HI:
16268 case R_PPC64_TOC16_HI:
16269 /* These relocs would only be useful if building up an
16270 offset to later add to r2, perhaps in an indexed
16271 addressing mode instruction. Don't try to optimize.
16272 Unfortunately, the possibility of someone building up an
16273 offset like this or even with the HA relocs, means that
16274 we need to check the high insn when optimizing the low
16275 insn. */
16276 break;
16277
16278 case R_PPC64_PLTCALL:
16279 if (unresolved_reloc)
16280 {
16281 /* No plt entry. Make this into a direct call. */
16282 bfd_byte *p = contents + rel->r_offset;
16283 insn = bfd_get_32 (input_bfd, p);
16284 insn &= 1;
16285 bfd_put_32 (input_bfd, B_DOT | insn, p);
16286 bfd_put_32 (input_bfd, NOP, p + 4);
16287 unresolved_reloc = save_unresolved_reloc;
16288 r_type = R_PPC64_REL24;
16289 }
16290 break;
16291
16292 case R_PPC64_PLTSEQ:
16293 if (unresolved_reloc)
16294 {
16295 unresolved_reloc = FALSE;
16296 goto nop_it;
16297 }
16298 break;
16299
16300 case R_PPC64_PLT16_HA:
16301 if (unresolved_reloc)
16302 {
16303 unresolved_reloc = FALSE;
16304 goto nop_it;
16305 }
16306 /* Fall through. */
16307 case R_PPC64_GOT_TLSLD16_HA:
16308 case R_PPC64_GOT_TLSGD16_HA:
16309 case R_PPC64_GOT_TPREL16_HA:
16310 case R_PPC64_GOT_DTPREL16_HA:
16311 case R_PPC64_GOT16_HA:
16312 case R_PPC64_TOC16_HA:
16313 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16314 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16315 {
16316 bfd_byte *p;
16317 nop_it:
16318 p = contents + (rel->r_offset & ~3);
16319 bfd_put_32 (input_bfd, NOP, p);
16320 goto copy_reloc;
16321 }
16322 break;
16323
16324 case R_PPC64_PLT16_LO:
16325 case R_PPC64_PLT16_LO_DS:
16326 if (unresolved_reloc)
16327 {
16328 unresolved_reloc = FALSE;
16329 goto nop_it;
16330 }
16331 /* Fall through. */
16332 case R_PPC64_GOT_TLSLD16_LO:
16333 case R_PPC64_GOT_TLSGD16_LO:
16334 case R_PPC64_GOT_TPREL16_LO_DS:
16335 case R_PPC64_GOT_DTPREL16_LO_DS:
16336 case R_PPC64_GOT16_LO:
16337 case R_PPC64_GOT16_LO_DS:
16338 case R_PPC64_TOC16_LO:
16339 case R_PPC64_TOC16_LO_DS:
16340 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16341 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16342 {
16343 bfd_byte *p = contents + (rel->r_offset & ~3);
16344 insn = bfd_get_32 (input_bfd, p);
16345 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16346 {
16347 /* Transform addic to addi when we change reg. */
16348 insn &= ~((0x3f << 26) | (0x1f << 16));
16349 insn |= (14u << 26) | (2 << 16);
16350 }
16351 else
16352 {
16353 insn &= ~(0x1f << 16);
16354 insn |= 2 << 16;
16355 }
16356 bfd_put_32 (input_bfd, insn, p);
16357 }
16358 break;
16359
16360 case R_PPC64_TPREL16_HA:
16361 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16362 {
16363 bfd_byte *p = contents + (rel->r_offset & ~3);
16364 insn = bfd_get_32 (input_bfd, p);
16365 if ((insn & ((0x3f << 26) | 0x1f << 16))
16366 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16367 /* xgettext:c-format */
16368 info->callbacks->minfo
16369 (_("%H: warning: %s unexpected insn %#x.\n"),
16370 input_bfd, input_section, rel->r_offset,
16371 ppc64_elf_howto_table[r_type]->name, insn);
16372 else
16373 {
16374 bfd_put_32 (input_bfd, NOP, p);
16375 goto copy_reloc;
16376 }
16377 }
16378 break;
16379
16380 case R_PPC64_TPREL16_LO:
16381 case R_PPC64_TPREL16_LO_DS:
16382 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16383 {
16384 bfd_byte *p = contents + (rel->r_offset & ~3);
16385 insn = bfd_get_32 (input_bfd, p);
16386 insn &= ~(0x1f << 16);
16387 insn |= 13 << 16;
16388 bfd_put_32 (input_bfd, insn, p);
16389 }
16390 break;
16391 }
16392
16393 /* Do any further special processing. */
16394 switch (r_type)
16395 {
16396 default:
16397 break;
16398
16399 case R_PPC64_REL16_HA:
16400 case R_PPC64_REL16DX_HA:
16401 case R_PPC64_ADDR16_HA:
16402 case R_PPC64_ADDR16_HIGHA:
16403 case R_PPC64_ADDR16_HIGHERA:
16404 case R_PPC64_ADDR16_HIGHESTA:
16405 case R_PPC64_TOC16_HA:
16406 case R_PPC64_SECTOFF_HA:
16407 case R_PPC64_TPREL16_HA:
16408 case R_PPC64_TPREL16_HIGHA:
16409 case R_PPC64_TPREL16_HIGHERA:
16410 case R_PPC64_TPREL16_HIGHESTA:
16411 case R_PPC64_DTPREL16_HA:
16412 case R_PPC64_DTPREL16_HIGHA:
16413 case R_PPC64_DTPREL16_HIGHERA:
16414 case R_PPC64_DTPREL16_HIGHESTA:
16415 /* It's just possible that this symbol is a weak symbol
16416 that's not actually defined anywhere. In that case,
16417 'sec' would be NULL, and we should leave the symbol
16418 alone (it will be set to zero elsewhere in the link). */
16419 if (sec == NULL)
16420 break;
16421 /* Fall through. */
16422
16423 case R_PPC64_GOT16_HA:
16424 case R_PPC64_PLTGOT16_HA:
16425 case R_PPC64_PLT16_HA:
16426 case R_PPC64_GOT_TLSGD16_HA:
16427 case R_PPC64_GOT_TLSLD16_HA:
16428 case R_PPC64_GOT_TPREL16_HA:
16429 case R_PPC64_GOT_DTPREL16_HA:
16430 /* Add 0x10000 if sign bit in 0:15 is set.
16431 Bits 0:15 are not used. */
16432 addend += 0x8000;
16433 break;
16434
16435 case R_PPC64_ADDR16_DS:
16436 case R_PPC64_ADDR16_LO_DS:
16437 case R_PPC64_GOT16_DS:
16438 case R_PPC64_GOT16_LO_DS:
16439 case R_PPC64_PLT16_LO_DS:
16440 case R_PPC64_SECTOFF_DS:
16441 case R_PPC64_SECTOFF_LO_DS:
16442 case R_PPC64_TOC16_DS:
16443 case R_PPC64_TOC16_LO_DS:
16444 case R_PPC64_PLTGOT16_DS:
16445 case R_PPC64_PLTGOT16_LO_DS:
16446 case R_PPC64_GOT_TPREL16_DS:
16447 case R_PPC64_GOT_TPREL16_LO_DS:
16448 case R_PPC64_GOT_DTPREL16_DS:
16449 case R_PPC64_GOT_DTPREL16_LO_DS:
16450 case R_PPC64_TPREL16_DS:
16451 case R_PPC64_TPREL16_LO_DS:
16452 case R_PPC64_DTPREL16_DS:
16453 case R_PPC64_DTPREL16_LO_DS:
16454 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16455 mask = 3;
16456 /* If this reloc is against an lq, lxv, or stxv insn, then
16457 the value must be a multiple of 16. This is somewhat of
16458 a hack, but the "correct" way to do this by defining _DQ
16459 forms of all the _DS relocs bloats all reloc switches in
16460 this file. It doesn't make much sense to use these
16461 relocs in data, so testing the insn should be safe. */
16462 if ((insn & (0x3f << 26)) == (56u << 26)
16463 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16464 mask = 15;
16465 relocation += addend;
16466 addend = insn & (mask ^ 3);
16467 if ((relocation & mask) != 0)
16468 {
16469 relocation ^= relocation & mask;
16470 info->callbacks->einfo
16471 /* xgettext:c-format */
16472 (_("%H: error: %s not a multiple of %u\n"),
16473 input_bfd, input_section, rel->r_offset,
16474 ppc64_elf_howto_table[r_type]->name,
16475 mask + 1);
16476 bfd_set_error (bfd_error_bad_value);
16477 ret = FALSE;
16478 goto copy_reloc;
16479 }
16480 break;
16481 }
16482
16483 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16484 because such sections are not SEC_ALLOC and thus ld.so will
16485 not process them. */
16486 howto = ppc64_elf_howto_table[(int) r_type];
16487 if (unresolved_reloc
16488 && !((input_section->flags & SEC_DEBUGGING) != 0
16489 && h->elf.def_dynamic)
16490 && _bfd_elf_section_offset (output_bfd, info, input_section,
16491 rel->r_offset) != (bfd_vma) -1)
16492 {
16493 info->callbacks->einfo
16494 /* xgettext:c-format */
16495 (_("%H: unresolvable %s against `%pT'\n"),
16496 input_bfd, input_section, rel->r_offset,
16497 howto->name,
16498 h->elf.root.root.string);
16499 ret = FALSE;
16500 }
16501
16502 /* 16-bit fields in insns mostly have signed values, but a
16503 few insns have 16-bit unsigned values. Really, we should
16504 have different reloc types. */
16505 if (howto->complain_on_overflow != complain_overflow_dont
16506 && howto->dst_mask == 0xffff
16507 && (input_section->flags & SEC_CODE) != 0)
16508 {
16509 enum complain_overflow complain = complain_overflow_signed;
16510
16511 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16512 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16513 complain = complain_overflow_bitfield;
16514 else if (howto->rightshift == 0
16515 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16516 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16517 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16518 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16519 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16520 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16521 complain = complain_overflow_unsigned;
16522 if (howto->complain_on_overflow != complain)
16523 {
16524 alt_howto = *howto;
16525 alt_howto.complain_on_overflow = complain;
16526 howto = &alt_howto;
16527 }
16528 }
16529
16530 if (r_type == R_PPC64_REL16DX_HA)
16531 {
16532 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
16533 if (rel->r_offset + 4 > input_section->size)
16534 r = bfd_reloc_outofrange;
16535 else
16536 {
16537 relocation += addend;
16538 relocation -= (rel->r_offset
16539 + input_section->output_offset
16540 + input_section->output_section->vma);
16541 relocation = (bfd_signed_vma) relocation >> 16;
16542 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16543 insn &= ~0x1fffc1;
16544 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16545 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16546 r = bfd_reloc_ok;
16547 if (relocation + 0x8000 > 0xffff)
16548 r = bfd_reloc_overflow;
16549 }
16550 }
16551 else
16552 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
16553 rel->r_offset, relocation, addend);
16554
16555 if (r != bfd_reloc_ok)
16556 {
16557 char *more_info = NULL;
16558 const char *reloc_name = howto->name;
16559
16560 if (reloc_dest != DEST_NORMAL)
16561 {
16562 more_info = bfd_malloc (strlen (reloc_name) + 8);
16563 if (more_info != NULL)
16564 {
16565 strcpy (more_info, reloc_name);
16566 strcat (more_info, (reloc_dest == DEST_OPD
16567 ? " (OPD)" : " (stub)"));
16568 reloc_name = more_info;
16569 }
16570 }
16571
16572 if (r == bfd_reloc_overflow)
16573 {
16574 /* On code like "if (foo) foo();" don't report overflow
16575 on a branch to zero when foo is undefined. */
16576 if (!warned
16577 && (reloc_dest == DEST_STUB
16578 || !(h != NULL
16579 && (h->elf.root.type == bfd_link_hash_undefweak
16580 || h->elf.root.type == bfd_link_hash_undefined)
16581 && is_branch_reloc (r_type))))
16582 info->callbacks->reloc_overflow (info, &h->elf.root,
16583 sym_name, reloc_name,
16584 orig_rel.r_addend,
16585 input_bfd, input_section,
16586 rel->r_offset);
16587 }
16588 else
16589 {
16590 info->callbacks->einfo
16591 /* xgettext:c-format */
16592 (_("%H: %s against `%pT': error %d\n"),
16593 input_bfd, input_section, rel->r_offset,
16594 reloc_name, sym_name, (int) r);
16595 ret = FALSE;
16596 }
16597 if (more_info != NULL)
16598 free (more_info);
16599 }
16600 copy_reloc:
16601 if (wrel != rel)
16602 *wrel = *rel;
16603 }
16604
16605 if (wrel != rel)
16606 {
16607 Elf_Internal_Shdr *rel_hdr;
16608 size_t deleted = rel - wrel;
16609
16610 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16611 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16612 if (rel_hdr->sh_size == 0)
16613 {
16614 /* It is too late to remove an empty reloc section. Leave
16615 one NONE reloc.
16616 ??? What is wrong with an empty section??? */
16617 rel_hdr->sh_size = rel_hdr->sh_entsize;
16618 deleted -= 1;
16619 }
16620 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16621 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16622 input_section->reloc_count -= deleted;
16623 }
16624
16625 /* If we're emitting relocations, then shortly after this function
16626 returns, reloc offsets and addends for this section will be
16627 adjusted. Worse, reloc symbol indices will be for the output
16628 file rather than the input. Save a copy of the relocs for
16629 opd_entry_value. */
16630 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16631 {
16632 bfd_size_type amt;
16633 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16634 rel = bfd_alloc (input_bfd, amt);
16635 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16636 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16637 if (rel == NULL)
16638 return FALSE;
16639 memcpy (rel, relocs, amt);
16640 }
16641 return ret;
16642 }
16643
16644 /* Adjust the value of any local symbols in opd sections. */
16645
16646 static int
16647 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16648 const char *name ATTRIBUTE_UNUSED,
16649 Elf_Internal_Sym *elfsym,
16650 asection *input_sec,
16651 struct elf_link_hash_entry *h)
16652 {
16653 struct _opd_sec_data *opd;
16654 long adjust;
16655 bfd_vma value;
16656
16657 if (h != NULL)
16658 return 1;
16659
16660 opd = get_opd_info (input_sec);
16661 if (opd == NULL || opd->adjust == NULL)
16662 return 1;
16663
16664 value = elfsym->st_value - input_sec->output_offset;
16665 if (!bfd_link_relocatable (info))
16666 value -= input_sec->output_section->vma;
16667
16668 adjust = opd->adjust[OPD_NDX (value)];
16669 if (adjust == -1)
16670 return 2;
16671
16672 elfsym->st_value += adjust;
16673 return 1;
16674 }
16675
16676 /* Finish up dynamic symbol handling. We set the contents of various
16677 dynamic sections here. */
16678
16679 static bfd_boolean
16680 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16681 struct bfd_link_info *info,
16682 struct elf_link_hash_entry *h,
16683 Elf_Internal_Sym *sym)
16684 {
16685 struct ppc_link_hash_table *htab;
16686 struct plt_entry *ent;
16687
16688 htab = ppc_hash_table (info);
16689 if (htab == NULL)
16690 return FALSE;
16691
16692 if (!htab->opd_abi && !h->def_regular)
16693 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16694 if (ent->plt.offset != (bfd_vma) -1)
16695 {
16696 /* Mark the symbol as undefined, rather than as
16697 defined in glink. Leave the value if there were
16698 any relocations where pointer equality matters
16699 (this is a clue for the dynamic linker, to make
16700 function pointer comparisons work between an
16701 application and shared library), otherwise set it
16702 to zero. */
16703 sym->st_shndx = SHN_UNDEF;
16704 if (!h->pointer_equality_needed)
16705 sym->st_value = 0;
16706 else if (!h->ref_regular_nonweak)
16707 {
16708 /* This breaks function pointer comparisons, but
16709 that is better than breaking tests for a NULL
16710 function pointer. */
16711 sym->st_value = 0;
16712 }
16713 break;
16714 }
16715
16716 if (h->needs_copy)
16717 {
16718 /* This symbol needs a copy reloc. Set it up. */
16719 Elf_Internal_Rela rela;
16720 asection *srel;
16721 bfd_byte *loc;
16722
16723 if (h->dynindx == -1
16724 || (h->root.type != bfd_link_hash_defined
16725 && h->root.type != bfd_link_hash_defweak)
16726 || htab->elf.srelbss == NULL
16727 || htab->elf.sreldynrelro == NULL)
16728 abort ();
16729
16730 rela.r_offset = (h->root.u.def.value
16731 + h->root.u.def.section->output_section->vma
16732 + h->root.u.def.section->output_offset);
16733 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16734 rela.r_addend = 0;
16735 if (h->root.u.def.section == htab->elf.sdynrelro)
16736 srel = htab->elf.sreldynrelro;
16737 else
16738 srel = htab->elf.srelbss;
16739 loc = srel->contents;
16740 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16741 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16742 }
16743
16744 return TRUE;
16745 }
16746
16747 /* Used to decide how to sort relocs in an optimal manner for the
16748 dynamic linker, before writing them out. */
16749
16750 static enum elf_reloc_type_class
16751 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16752 const asection *rel_sec,
16753 const Elf_Internal_Rela *rela)
16754 {
16755 enum elf_ppc64_reloc_type r_type;
16756 struct ppc_link_hash_table *htab = ppc_hash_table (info);
16757
16758 if (rel_sec == htab->elf.irelplt)
16759 return reloc_class_ifunc;
16760
16761 r_type = ELF64_R_TYPE (rela->r_info);
16762 switch (r_type)
16763 {
16764 case R_PPC64_RELATIVE:
16765 return reloc_class_relative;
16766 case R_PPC64_JMP_SLOT:
16767 return reloc_class_plt;
16768 case R_PPC64_COPY:
16769 return reloc_class_copy;
16770 default:
16771 return reloc_class_normal;
16772 }
16773 }
16774
16775 /* Finish up the dynamic sections. */
16776
16777 static bfd_boolean
16778 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16779 struct bfd_link_info *info)
16780 {
16781 struct ppc_link_hash_table *htab;
16782 bfd *dynobj;
16783 asection *sdyn;
16784
16785 htab = ppc_hash_table (info);
16786 if (htab == NULL)
16787 return FALSE;
16788
16789 dynobj = htab->elf.dynobj;
16790 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16791
16792 if (htab->elf.dynamic_sections_created)
16793 {
16794 Elf64_External_Dyn *dyncon, *dynconend;
16795
16796 if (sdyn == NULL || htab->elf.sgot == NULL)
16797 abort ();
16798
16799 dyncon = (Elf64_External_Dyn *) sdyn->contents;
16800 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16801 for (; dyncon < dynconend; dyncon++)
16802 {
16803 Elf_Internal_Dyn dyn;
16804 asection *s;
16805
16806 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16807
16808 switch (dyn.d_tag)
16809 {
16810 default:
16811 continue;
16812
16813 case DT_PPC64_GLINK:
16814 s = htab->glink;
16815 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16816 /* We stupidly defined DT_PPC64_GLINK to be the start
16817 of glink rather than the first entry point, which is
16818 what ld.so needs, and now have a bigger stub to
16819 support automatic multiple TOCs. */
16820 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16821 break;
16822
16823 case DT_PPC64_OPD:
16824 s = bfd_get_section_by_name (output_bfd, ".opd");
16825 if (s == NULL)
16826 continue;
16827 dyn.d_un.d_ptr = s->vma;
16828 break;
16829
16830 case DT_PPC64_OPT:
16831 if (htab->do_multi_toc && htab->multi_toc_needed)
16832 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16833 if (htab->has_plt_localentry0)
16834 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16835 break;
16836
16837 case DT_PPC64_OPDSZ:
16838 s = bfd_get_section_by_name (output_bfd, ".opd");
16839 if (s == NULL)
16840 continue;
16841 dyn.d_un.d_val = s->size;
16842 break;
16843
16844 case DT_PLTGOT:
16845 s = htab->elf.splt;
16846 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16847 break;
16848
16849 case DT_JMPREL:
16850 s = htab->elf.srelplt;
16851 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16852 break;
16853
16854 case DT_PLTRELSZ:
16855 dyn.d_un.d_val = htab->elf.srelplt->size;
16856 break;
16857
16858 case DT_TEXTREL:
16859 if (htab->local_ifunc_resolver)
16860 info->callbacks->einfo
16861 (_("%X%P: text relocations and GNU indirect "
16862 "functions will result in a segfault at runtime\n"));
16863 else if (htab->maybe_local_ifunc_resolver)
16864 info->callbacks->einfo
16865 (_("%P: warning: text relocations and GNU indirect "
16866 "functions may result in a segfault at runtime\n"));
16867 continue;
16868 }
16869
16870 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16871 }
16872 }
16873
16874 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16875 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16876 {
16877 /* Fill in the first entry in the global offset table.
16878 We use it to hold the link-time TOCbase. */
16879 bfd_put_64 (output_bfd,
16880 elf_gp (output_bfd) + TOC_BASE_OFF,
16881 htab->elf.sgot->contents);
16882
16883 /* Set .got entry size. */
16884 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
16885 = 8;
16886 }
16887
16888 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16889 && htab->elf.splt->output_section != bfd_abs_section_ptr)
16890 {
16891 /* Set .plt entry size. */
16892 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16893 = PLT_ENTRY_SIZE (htab);
16894 }
16895
16896 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16897 brlt ourselves if emitrelocations. */
16898 if (htab->brlt != NULL
16899 && htab->brlt->reloc_count != 0
16900 && !_bfd_elf_link_output_relocs (output_bfd,
16901 htab->brlt,
16902 elf_section_data (htab->brlt)->rela.hdr,
16903 elf_section_data (htab->brlt)->relocs,
16904 NULL))
16905 return FALSE;
16906
16907 if (htab->glink != NULL
16908 && htab->glink->reloc_count != 0
16909 && !_bfd_elf_link_output_relocs (output_bfd,
16910 htab->glink,
16911 elf_section_data (htab->glink)->rela.hdr,
16912 elf_section_data (htab->glink)->relocs,
16913 NULL))
16914 return FALSE;
16915
16916
16917 if (htab->glink_eh_frame != NULL
16918 && htab->glink_eh_frame->size != 0
16919 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16920 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16921 htab->glink_eh_frame,
16922 htab->glink_eh_frame->contents))
16923 return FALSE;
16924
16925 /* We need to handle writing out multiple GOT sections ourselves,
16926 since we didn't add them to DYNOBJ. We know dynobj is the first
16927 bfd. */
16928 while ((dynobj = dynobj->link.next) != NULL)
16929 {
16930 asection *s;
16931
16932 if (!is_ppc64_elf (dynobj))
16933 continue;
16934
16935 s = ppc64_elf_tdata (dynobj)->got;
16936 if (s != NULL
16937 && s->size != 0
16938 && s->output_section != bfd_abs_section_ptr
16939 && !bfd_set_section_contents (output_bfd, s->output_section,
16940 s->contents, s->output_offset,
16941 s->size))
16942 return FALSE;
16943 s = ppc64_elf_tdata (dynobj)->relgot;
16944 if (s != NULL
16945 && s->size != 0
16946 && s->output_section != bfd_abs_section_ptr
16947 && !bfd_set_section_contents (output_bfd, s->output_section,
16948 s->contents, s->output_offset,
16949 s->size))
16950 return FALSE;
16951 }
16952
16953 return TRUE;
16954 }
16955
16956 #include "elf64-target.h"
16957
16958 /* FreeBSD support */
16959
16960 #undef TARGET_LITTLE_SYM
16961 #undef TARGET_LITTLE_NAME
16962
16963 #undef TARGET_BIG_SYM
16964 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
16965 #undef TARGET_BIG_NAME
16966 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16967
16968 #undef ELF_OSABI
16969 #define ELF_OSABI ELFOSABI_FREEBSD
16970
16971 #undef elf64_bed
16972 #define elf64_bed elf64_powerpc_fbsd_bed
16973
16974 #include "elf64-target.h"
A mirror of the official binutils-gdb repository