]> 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
Fix ppc64le S-record test fail
[thirdparty/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2016 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 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
89
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_before_check_relocs
98 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
108 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
110 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
120
121 /* The name of the dynamic interpreter. This is put in the .interp
122 section. */
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
124
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
127
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
130
131 /* Offsets to some stack save slots. */
132 #define STK_LR 16
133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
134 /* This one is dodgy. ELFv2 does not have a linker word, so use the
135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
138
139 /* TOC base pointers offset from start of TOC. */
140 #define TOC_BASE_OFF 0x8000
141 /* TOC base alignment. */
142 #define TOC_BASE_ALIGN 256
143
144 /* Offset of tp and dtp pointers from start of TLS block. */
145 #define TP_OFFSET 0x7000
146 #define DTP_OFFSET 0x8000
147
148 /* .plt call stub instructions. The normal stub is like this, but
149 sometimes the .plt entry crosses a 64k boundary and we need to
150 insert an addi to adjust r11. */
151 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
152 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
153 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
154 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
155 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
156 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
157 #define BCTR 0x4e800420 /* bctr */
158
159 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
160 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
161 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
162
163 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
164 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
165 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
166 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
167 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
168 #define BNECTR 0x4ca20420 /* bnectr+ */
169 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
170
171 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
172 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
173 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
174
175 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
176 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
177 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
178
179 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
180 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
181 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
182 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
183 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
184
185 /* glink call stub instructions. We enter with the index in R0. */
186 #define GLINK_CALL_STUB_SIZE (16*4)
187 /* 0: */
188 /* .quad plt0-1f */
189 /* __glink: */
190 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
191 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
192 /* 1: */
193 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
194 /* ld %2,(0b-1b)(%11) */
195 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
196 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
197 /* ld %12,0(%11) */
198 /* ld %2,8(%11) */
199 /* mtctr %12 */
200 /* ld %11,16(%11) */
201 /* bctr */
202 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
203 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
204 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
205 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
206 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
207
208 /* Pad with this. */
209 #define NOP 0x60000000
210
211 /* Some other nops. */
212 #define CROR_151515 0x4def7b82
213 #define CROR_313131 0x4ffffb82
214
215 /* .glink entries for the first 32k functions are two instructions. */
216 #define LI_R0_0 0x38000000 /* li %r0,0 */
217 #define B_DOT 0x48000000 /* b . */
218
219 /* After that, we need two instructions to load the index, followed by
220 a branch. */
221 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
222 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
223
224 /* Instructions used by the save and restore reg functions. */
225 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
226 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
227 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
228 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
229 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
230 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
231 #define LI_R12_0 0x39800000 /* li %r12,0 */
232 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
233 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
234 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
235 #define BLR 0x4e800020 /* blr */
236
237 /* Since .opd is an array of descriptors and each entry will end up
238 with identical R_PPC64_RELATIVE relocs, there is really no need to
239 propagate .opd relocs; The dynamic linker should be taught to
240 relocate .opd without reloc entries. */
241 #ifndef NO_OPD_RELOCS
242 #define NO_OPD_RELOCS 0
243 #endif
244
245 #ifndef ARRAY_SIZE
246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
247 #endif
248
249 static inline int
250 abiversion (bfd *abfd)
251 {
252 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
253 }
254
255 static inline void
256 set_abiversion (bfd *abfd, int ver)
257 {
258 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
259 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
260 }
261 \f
262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
263
264 /* Relocation HOWTO's. */
265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
266
267 static reloc_howto_type ppc64_elf_howto_raw[] = {
268 /* This reloc does nothing. */
269 HOWTO (R_PPC64_NONE, /* type */
270 0, /* rightshift */
271 3, /* size (0 = byte, 1 = short, 2 = long) */
272 0, /* bitsize */
273 FALSE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_dont, /* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_PPC64_NONE", /* name */
278 FALSE, /* partial_inplace */
279 0, /* src_mask */
280 0, /* dst_mask */
281 FALSE), /* pcrel_offset */
282
283 /* A standard 32 bit relocation. */
284 HOWTO (R_PPC64_ADDR32, /* type */
285 0, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 32, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_bitfield, /* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_PPC64_ADDR32", /* name */
293 FALSE, /* partial_inplace */
294 0, /* src_mask */
295 0xffffffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* An absolute 26 bit branch; the lower two bits must be zero.
299 FIXME: we don't check that, we just clear them. */
300 HOWTO (R_PPC64_ADDR24, /* type */
301 0, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 26, /* bitsize */
304 FALSE, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_PPC64_ADDR24", /* name */
309 FALSE, /* partial_inplace */
310 0, /* src_mask */
311 0x03fffffc, /* dst_mask */
312 FALSE), /* pcrel_offset */
313
314 /* A standard 16 bit relocation. */
315 HOWTO (R_PPC64_ADDR16, /* type */
316 0, /* rightshift */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
318 16, /* bitsize */
319 FALSE, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_bitfield, /* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_PPC64_ADDR16", /* name */
324 FALSE, /* partial_inplace */
325 0, /* src_mask */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328
329 /* A 16 bit relocation without overflow. */
330 HOWTO (R_PPC64_ADDR16_LO, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_dont,/* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_PPC64_ADDR16_LO", /* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343
344 /* Bits 16-31 of an address. */
345 HOWTO (R_PPC64_ADDR16_HI, /* type */
346 16, /* rightshift */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
348 16, /* bitsize */
349 FALSE, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_signed, /* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_PPC64_ADDR16_HI", /* name */
354 FALSE, /* partial_inplace */
355 0, /* src_mask */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358
359 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
360 bits, treated as a signed number, is negative. */
361 HOWTO (R_PPC64_ADDR16_HA, /* type */
362 16, /* rightshift */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_signed, /* complain_on_overflow */
368 ppc64_elf_ha_reloc, /* special_function */
369 "R_PPC64_ADDR16_HA", /* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0xffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* An absolute 16 bit branch; the lower two bits must be zero.
376 FIXME: we don't check that, we just clear them. */
377 HOWTO (R_PPC64_ADDR14, /* type */
378 0, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 16, /* bitsize */
381 FALSE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_signed, /* complain_on_overflow */
384 ppc64_elf_branch_reloc, /* special_function */
385 "R_PPC64_ADDR14", /* name */
386 FALSE, /* partial_inplace */
387 0, /* src_mask */
388 0x0000fffc, /* dst_mask */
389 FALSE), /* pcrel_offset */
390
391 /* An absolute 16 bit branch, for which bit 10 should be set to
392 indicate that the branch is expected to be taken. The lower two
393 bits must be zero. */
394 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 16, /* bitsize */
398 FALSE, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_signed, /* complain_on_overflow */
401 ppc64_elf_brtaken_reloc, /* special_function */
402 "R_PPC64_ADDR14_BRTAKEN",/* name */
403 FALSE, /* partial_inplace */
404 0, /* src_mask */
405 0x0000fffc, /* dst_mask */
406 FALSE), /* pcrel_offset */
407
408 /* An absolute 16 bit branch, for which bit 10 should be set to
409 indicate that the branch is not expected to be taken. The lower
410 two bits must be zero. */
411 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
412 0, /* rightshift */
413 2, /* size (0 = byte, 1 = short, 2 = long) */
414 16, /* bitsize */
415 FALSE, /* pc_relative */
416 0, /* bitpos */
417 complain_overflow_signed, /* complain_on_overflow */
418 ppc64_elf_brtaken_reloc, /* special_function */
419 "R_PPC64_ADDR14_BRNTAKEN",/* name */
420 FALSE, /* partial_inplace */
421 0, /* src_mask */
422 0x0000fffc, /* dst_mask */
423 FALSE), /* pcrel_offset */
424
425 /* A relative 26 bit branch; the lower two bits must be zero. */
426 HOWTO (R_PPC64_REL24, /* type */
427 0, /* rightshift */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
429 26, /* bitsize */
430 TRUE, /* pc_relative */
431 0, /* bitpos */
432 complain_overflow_signed, /* complain_on_overflow */
433 ppc64_elf_branch_reloc, /* special_function */
434 "R_PPC64_REL24", /* name */
435 FALSE, /* partial_inplace */
436 0, /* src_mask */
437 0x03fffffc, /* dst_mask */
438 TRUE), /* pcrel_offset */
439
440 /* A relative 16 bit branch; the lower two bits must be zero. */
441 HOWTO (R_PPC64_REL14, /* type */
442 0, /* rightshift */
443 2, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
445 TRUE, /* pc_relative */
446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_branch_reloc, /* special_function */
449 "R_PPC64_REL14", /* name */
450 FALSE, /* partial_inplace */
451 0, /* src_mask */
452 0x0000fffc, /* dst_mask */
453 TRUE), /* pcrel_offset */
454
455 /* A relative 16 bit branch. Bit 10 should be set to indicate that
456 the branch is expected to be taken. The lower two bits must be
457 zero. */
458 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
459 0, /* rightshift */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
461 16, /* bitsize */
462 TRUE, /* pc_relative */
463 0, /* bitpos */
464 complain_overflow_signed, /* complain_on_overflow */
465 ppc64_elf_brtaken_reloc, /* special_function */
466 "R_PPC64_REL14_BRTAKEN", /* name */
467 FALSE, /* partial_inplace */
468 0, /* src_mask */
469 0x0000fffc, /* dst_mask */
470 TRUE), /* pcrel_offset */
471
472 /* A relative 16 bit branch. Bit 10 should be set to indicate that
473 the branch is not expected to be taken. The lower two bits must
474 be zero. */
475 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
476 0, /* rightshift */
477 2, /* size (0 = byte, 1 = short, 2 = long) */
478 16, /* bitsize */
479 TRUE, /* pc_relative */
480 0, /* bitpos */
481 complain_overflow_signed, /* complain_on_overflow */
482 ppc64_elf_brtaken_reloc, /* special_function */
483 "R_PPC64_REL14_BRNTAKEN",/* name */
484 FALSE, /* partial_inplace */
485 0, /* src_mask */
486 0x0000fffc, /* dst_mask */
487 TRUE), /* pcrel_offset */
488
489 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
490 symbol. */
491 HOWTO (R_PPC64_GOT16, /* type */
492 0, /* rightshift */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 FALSE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_unhandled_reloc, /* special_function */
499 "R_PPC64_GOT16", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
504
505 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
506 the symbol. */
507 HOWTO (R_PPC64_GOT16_LO, /* type */
508 0, /* rightshift */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
510 16, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_dont, /* complain_on_overflow */
514 ppc64_elf_unhandled_reloc, /* special_function */
515 "R_PPC64_GOT16_LO", /* name */
516 FALSE, /* partial_inplace */
517 0, /* src_mask */
518 0xffff, /* dst_mask */
519 FALSE), /* pcrel_offset */
520
521 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
522 the symbol. */
523 HOWTO (R_PPC64_GOT16_HI, /* type */
524 16, /* rightshift */
525 1, /* size (0 = byte, 1 = short, 2 = long) */
526 16, /* bitsize */
527 FALSE, /* pc_relative */
528 0, /* bitpos */
529 complain_overflow_signed,/* complain_on_overflow */
530 ppc64_elf_unhandled_reloc, /* special_function */
531 "R_PPC64_GOT16_HI", /* name */
532 FALSE, /* partial_inplace */
533 0, /* src_mask */
534 0xffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
536
537 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
538 the symbol. */
539 HOWTO (R_PPC64_GOT16_HA, /* type */
540 16, /* rightshift */
541 1, /* size (0 = byte, 1 = short, 2 = long) */
542 16, /* bitsize */
543 FALSE, /* pc_relative */
544 0, /* bitpos */
545 complain_overflow_signed,/* complain_on_overflow */
546 ppc64_elf_unhandled_reloc, /* special_function */
547 "R_PPC64_GOT16_HA", /* name */
548 FALSE, /* partial_inplace */
549 0, /* src_mask */
550 0xffff, /* dst_mask */
551 FALSE), /* pcrel_offset */
552
553 /* This is used only by the dynamic linker. The symbol should exist
554 both in the object being run and in some shared library. The
555 dynamic linker copies the data addressed by the symbol from the
556 shared library into the object, because the object being
557 run has to have the data at some particular address. */
558 HOWTO (R_PPC64_COPY, /* type */
559 0, /* rightshift */
560 0, /* this one is variable size */
561 0, /* bitsize */
562 FALSE, /* pc_relative */
563 0, /* bitpos */
564 complain_overflow_dont, /* complain_on_overflow */
565 ppc64_elf_unhandled_reloc, /* special_function */
566 "R_PPC64_COPY", /* name */
567 FALSE, /* partial_inplace */
568 0, /* src_mask */
569 0, /* dst_mask */
570 FALSE), /* pcrel_offset */
571
572 /* Like R_PPC64_ADDR64, but used when setting global offset table
573 entries. */
574 HOWTO (R_PPC64_GLOB_DAT, /* type */
575 0, /* rightshift */
576 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
577 64, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_dont, /* complain_on_overflow */
581 ppc64_elf_unhandled_reloc, /* special_function */
582 "R_PPC64_GLOB_DAT", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 ONES (64), /* dst_mask */
586 FALSE), /* pcrel_offset */
587
588 /* Created by the link editor. Marks a procedure linkage table
589 entry for a symbol. */
590 HOWTO (R_PPC64_JMP_SLOT, /* type */
591 0, /* rightshift */
592 0, /* size (0 = byte, 1 = short, 2 = long) */
593 0, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont, /* complain_on_overflow */
597 ppc64_elf_unhandled_reloc, /* special_function */
598 "R_PPC64_JMP_SLOT", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* Used only by the dynamic linker. When the object is run, this
605 doubleword64 is set to the load address of the object, plus the
606 addend. */
607 HOWTO (R_PPC64_RELATIVE, /* 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 bfd_elf_generic_reloc, /* special_function */
615 "R_PPC64_RELATIVE", /* name */
616 FALSE, /* partial_inplace */
617 0, /* src_mask */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Like R_PPC64_ADDR32, but may be unaligned. */
622 HOWTO (R_PPC64_UADDR32, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 32, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_bitfield, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_PPC64_UADDR32", /* name */
631 FALSE, /* partial_inplace */
632 0, /* src_mask */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 /* Like R_PPC64_ADDR16, but may be unaligned. */
637 HOWTO (R_PPC64_UADDR16, /* type */
638 0, /* rightshift */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_PPC64_UADDR16", /* name */
646 FALSE, /* partial_inplace */
647 0, /* src_mask */
648 0xffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
650
651 /* 32-bit PC relative. */
652 HOWTO (R_PPC64_REL32, /* type */
653 0, /* rightshift */
654 2, /* size (0 = byte, 1 = short, 2 = long) */
655 32, /* bitsize */
656 TRUE, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_signed, /* complain_on_overflow */
659 bfd_elf_generic_reloc, /* special_function */
660 "R_PPC64_REL32", /* name */
661 FALSE, /* partial_inplace */
662 0, /* src_mask */
663 0xffffffff, /* dst_mask */
664 TRUE), /* pcrel_offset */
665
666 /* 32-bit relocation to the symbol's procedure linkage table. */
667 HOWTO (R_PPC64_PLT32, /* type */
668 0, /* rightshift */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
670 32, /* bitsize */
671 FALSE, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_bitfield, /* complain_on_overflow */
674 ppc64_elf_unhandled_reloc, /* special_function */
675 "R_PPC64_PLT32", /* name */
676 FALSE, /* partial_inplace */
677 0, /* src_mask */
678 0xffffffff, /* dst_mask */
679 FALSE), /* pcrel_offset */
680
681 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
682 FIXME: R_PPC64_PLTREL32 not supported. */
683 HOWTO (R_PPC64_PLTREL32, /* type */
684 0, /* rightshift */
685 2, /* size (0 = byte, 1 = short, 2 = long) */
686 32, /* bitsize */
687 TRUE, /* pc_relative */
688 0, /* bitpos */
689 complain_overflow_signed, /* complain_on_overflow */
690 bfd_elf_generic_reloc, /* special_function */
691 "R_PPC64_PLTREL32", /* name */
692 FALSE, /* partial_inplace */
693 0, /* src_mask */
694 0xffffffff, /* dst_mask */
695 TRUE), /* pcrel_offset */
696
697 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
698 the symbol. */
699 HOWTO (R_PPC64_PLT16_LO, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_dont, /* complain_on_overflow */
706 ppc64_elf_unhandled_reloc, /* special_function */
707 "R_PPC64_PLT16_LO", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
714 the symbol. */
715 HOWTO (R_PPC64_PLT16_HI, /* type */
716 16, /* rightshift */
717 1, /* size (0 = byte, 1 = short, 2 = long) */
718 16, /* bitsize */
719 FALSE, /* pc_relative */
720 0, /* bitpos */
721 complain_overflow_signed, /* complain_on_overflow */
722 ppc64_elf_unhandled_reloc, /* special_function */
723 "R_PPC64_PLT16_HI", /* name */
724 FALSE, /* partial_inplace */
725 0, /* src_mask */
726 0xffff, /* dst_mask */
727 FALSE), /* pcrel_offset */
728
729 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
730 the symbol. */
731 HOWTO (R_PPC64_PLT16_HA, /* type */
732 16, /* rightshift */
733 1, /* size (0 = byte, 1 = short, 2 = long) */
734 16, /* bitsize */
735 FALSE, /* pc_relative */
736 0, /* bitpos */
737 complain_overflow_signed, /* complain_on_overflow */
738 ppc64_elf_unhandled_reloc, /* special_function */
739 "R_PPC64_PLT16_HA", /* name */
740 FALSE, /* partial_inplace */
741 0, /* src_mask */
742 0xffff, /* dst_mask */
743 FALSE), /* pcrel_offset */
744
745 /* 16-bit section relative relocation. */
746 HOWTO (R_PPC64_SECTOFF, /* type */
747 0, /* rightshift */
748 1, /* size (0 = byte, 1 = short, 2 = long) */
749 16, /* bitsize */
750 FALSE, /* pc_relative */
751 0, /* bitpos */
752 complain_overflow_signed, /* complain_on_overflow */
753 ppc64_elf_sectoff_reloc, /* special_function */
754 "R_PPC64_SECTOFF", /* name */
755 FALSE, /* partial_inplace */
756 0, /* src_mask */
757 0xffff, /* dst_mask */
758 FALSE), /* pcrel_offset */
759
760 /* Like R_PPC64_SECTOFF, but no overflow warning. */
761 HOWTO (R_PPC64_SECTOFF_LO, /* type */
762 0, /* rightshift */
763 1, /* size (0 = byte, 1 = short, 2 = long) */
764 16, /* bitsize */
765 FALSE, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 ppc64_elf_sectoff_reloc, /* special_function */
769 "R_PPC64_SECTOFF_LO", /* name */
770 FALSE, /* partial_inplace */
771 0, /* src_mask */
772 0xffff, /* dst_mask */
773 FALSE), /* pcrel_offset */
774
775 /* 16-bit upper half section relative relocation. */
776 HOWTO (R_PPC64_SECTOFF_HI, /* type */
777 16, /* rightshift */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
780 FALSE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_signed, /* complain_on_overflow */
783 ppc64_elf_sectoff_reloc, /* special_function */
784 "R_PPC64_SECTOFF_HI", /* name */
785 FALSE, /* partial_inplace */
786 0, /* src_mask */
787 0xffff, /* dst_mask */
788 FALSE), /* pcrel_offset */
789
790 /* 16-bit upper half adjusted section relative relocation. */
791 HOWTO (R_PPC64_SECTOFF_HA, /* type */
792 16, /* rightshift */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
794 16, /* bitsize */
795 FALSE, /* pc_relative */
796 0, /* bitpos */
797 complain_overflow_signed, /* complain_on_overflow */
798 ppc64_elf_sectoff_ha_reloc, /* special_function */
799 "R_PPC64_SECTOFF_HA", /* name */
800 FALSE, /* partial_inplace */
801 0, /* src_mask */
802 0xffff, /* dst_mask */
803 FALSE), /* pcrel_offset */
804
805 /* Like R_PPC64_REL24 without touching the two least significant bits. */
806 HOWTO (R_PPC64_REL30, /* type */
807 2, /* rightshift */
808 2, /* size (0 = byte, 1 = short, 2 = long) */
809 30, /* bitsize */
810 TRUE, /* pc_relative */
811 0, /* bitpos */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_PPC64_REL30", /* name */
815 FALSE, /* partial_inplace */
816 0, /* src_mask */
817 0xfffffffc, /* dst_mask */
818 TRUE), /* pcrel_offset */
819
820 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
821
822 /* A standard 64-bit relocation. */
823 HOWTO (R_PPC64_ADDR64, /* type */
824 0, /* rightshift */
825 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
826 64, /* bitsize */
827 FALSE, /* pc_relative */
828 0, /* bitpos */
829 complain_overflow_dont, /* complain_on_overflow */
830 bfd_elf_generic_reloc, /* special_function */
831 "R_PPC64_ADDR64", /* name */
832 FALSE, /* partial_inplace */
833 0, /* src_mask */
834 ONES (64), /* dst_mask */
835 FALSE), /* pcrel_offset */
836
837 /* The bits 32-47 of an address. */
838 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
839 32, /* rightshift */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
841 16, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_ADDR16_HIGHER", /* name */
847 FALSE, /* partial_inplace */
848 0, /* src_mask */
849 0xffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* The bits 32-47 of an address, plus 1 if the contents of the low
853 16 bits, treated as a signed number, is negative. */
854 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
855 32, /* rightshift */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
857 16, /* bitsize */
858 FALSE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_dont, /* complain_on_overflow */
861 ppc64_elf_ha_reloc, /* special_function */
862 "R_PPC64_ADDR16_HIGHERA", /* name */
863 FALSE, /* partial_inplace */
864 0, /* src_mask */
865 0xffff, /* dst_mask */
866 FALSE), /* pcrel_offset */
867
868 /* The bits 48-63 of an address. */
869 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
870 48, /* rightshift */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
872 16, /* bitsize */
873 FALSE, /* pc_relative */
874 0, /* bitpos */
875 complain_overflow_dont, /* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_PPC64_ADDR16_HIGHEST", /* name */
878 FALSE, /* partial_inplace */
879 0, /* src_mask */
880 0xffff, /* dst_mask */
881 FALSE), /* pcrel_offset */
882
883 /* The bits 48-63 of an address, plus 1 if the contents of the low
884 16 bits, treated as a signed number, is negative. */
885 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
886 48, /* rightshift */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
888 16, /* bitsize */
889 FALSE, /* pc_relative */
890 0, /* bitpos */
891 complain_overflow_dont, /* complain_on_overflow */
892 ppc64_elf_ha_reloc, /* special_function */
893 "R_PPC64_ADDR16_HIGHESTA", /* name */
894 FALSE, /* partial_inplace */
895 0, /* src_mask */
896 0xffff, /* dst_mask */
897 FALSE), /* pcrel_offset */
898
899 /* Like ADDR64, but may be unaligned. */
900 HOWTO (R_PPC64_UADDR64, /* type */
901 0, /* rightshift */
902 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
903 64, /* bitsize */
904 FALSE, /* pc_relative */
905 0, /* bitpos */
906 complain_overflow_dont, /* complain_on_overflow */
907 bfd_elf_generic_reloc, /* special_function */
908 "R_PPC64_UADDR64", /* name */
909 FALSE, /* partial_inplace */
910 0, /* src_mask */
911 ONES (64), /* dst_mask */
912 FALSE), /* pcrel_offset */
913
914 /* 64-bit relative relocation. */
915 HOWTO (R_PPC64_REL64, /* type */
916 0, /* rightshift */
917 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
918 64, /* bitsize */
919 TRUE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_dont, /* complain_on_overflow */
922 bfd_elf_generic_reloc, /* special_function */
923 "R_PPC64_REL64", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 ONES (64), /* dst_mask */
927 TRUE), /* pcrel_offset */
928
929 /* 64-bit relocation to the symbol's procedure linkage table. */
930 HOWTO (R_PPC64_PLT64, /* type */
931 0, /* rightshift */
932 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
933 64, /* bitsize */
934 FALSE, /* pc_relative */
935 0, /* bitpos */
936 complain_overflow_dont, /* complain_on_overflow */
937 ppc64_elf_unhandled_reloc, /* special_function */
938 "R_PPC64_PLT64", /* name */
939 FALSE, /* partial_inplace */
940 0, /* src_mask */
941 ONES (64), /* dst_mask */
942 FALSE), /* pcrel_offset */
943
944 /* 64-bit PC relative relocation to the symbol's procedure linkage
945 table. */
946 /* FIXME: R_PPC64_PLTREL64 not supported. */
947 HOWTO (R_PPC64_PLTREL64, /* type */
948 0, /* rightshift */
949 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
950 64, /* bitsize */
951 TRUE, /* pc_relative */
952 0, /* bitpos */
953 complain_overflow_dont, /* complain_on_overflow */
954 ppc64_elf_unhandled_reloc, /* special_function */
955 "R_PPC64_PLTREL64", /* name */
956 FALSE, /* partial_inplace */
957 0, /* src_mask */
958 ONES (64), /* dst_mask */
959 TRUE), /* pcrel_offset */
960
961 /* 16 bit TOC-relative relocation. */
962
963 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
964 HOWTO (R_PPC64_TOC16, /* type */
965 0, /* rightshift */
966 1, /* size (0 = byte, 1 = short, 2 = long) */
967 16, /* bitsize */
968 FALSE, /* pc_relative */
969 0, /* bitpos */
970 complain_overflow_signed, /* complain_on_overflow */
971 ppc64_elf_toc_reloc, /* special_function */
972 "R_PPC64_TOC16", /* name */
973 FALSE, /* partial_inplace */
974 0, /* src_mask */
975 0xffff, /* dst_mask */
976 FALSE), /* pcrel_offset */
977
978 /* 16 bit TOC-relative relocation without overflow. */
979
980 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
981 HOWTO (R_PPC64_TOC16_LO, /* type */
982 0, /* rightshift */
983 1, /* size (0 = byte, 1 = short, 2 = long) */
984 16, /* bitsize */
985 FALSE, /* pc_relative */
986 0, /* bitpos */
987 complain_overflow_dont, /* complain_on_overflow */
988 ppc64_elf_toc_reloc, /* special_function */
989 "R_PPC64_TOC16_LO", /* name */
990 FALSE, /* partial_inplace */
991 0, /* src_mask */
992 0xffff, /* dst_mask */
993 FALSE), /* pcrel_offset */
994
995 /* 16 bit TOC-relative relocation, high 16 bits. */
996
997 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
998 HOWTO (R_PPC64_TOC16_HI, /* type */
999 16, /* rightshift */
1000 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 16, /* bitsize */
1002 FALSE, /* pc_relative */
1003 0, /* bitpos */
1004 complain_overflow_signed, /* complain_on_overflow */
1005 ppc64_elf_toc_reloc, /* special_function */
1006 "R_PPC64_TOC16_HI", /* name */
1007 FALSE, /* partial_inplace */
1008 0, /* src_mask */
1009 0xffff, /* dst_mask */
1010 FALSE), /* pcrel_offset */
1011
1012 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013 contents of the low 16 bits, treated as a signed number, is
1014 negative. */
1015
1016 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1017 HOWTO (R_PPC64_TOC16_HA, /* type */
1018 16, /* rightshift */
1019 1, /* size (0 = byte, 1 = short, 2 = long) */
1020 16, /* bitsize */
1021 FALSE, /* pc_relative */
1022 0, /* bitpos */
1023 complain_overflow_signed, /* complain_on_overflow */
1024 ppc64_elf_toc_ha_reloc, /* special_function */
1025 "R_PPC64_TOC16_HA", /* name */
1026 FALSE, /* partial_inplace */
1027 0, /* src_mask */
1028 0xffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1030
1031 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1032
1033 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1034 HOWTO (R_PPC64_TOC, /* type */
1035 0, /* rightshift */
1036 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037 64, /* bitsize */
1038 FALSE, /* pc_relative */
1039 0, /* bitpos */
1040 complain_overflow_dont, /* complain_on_overflow */
1041 ppc64_elf_toc64_reloc, /* special_function */
1042 "R_PPC64_TOC", /* name */
1043 FALSE, /* partial_inplace */
1044 0, /* src_mask */
1045 ONES (64), /* dst_mask */
1046 FALSE), /* pcrel_offset */
1047
1048 /* Like R_PPC64_GOT16, but also informs the link editor that the
1049 value to relocate may (!) refer to a PLT entry which the link
1050 editor (a) may replace with the symbol value. If the link editor
1051 is unable to fully resolve the symbol, it may (b) create a PLT
1052 entry and store the address to the new PLT entry in the GOT.
1053 This permits lazy resolution of function symbols at run time.
1054 The link editor may also skip all of this and just (c) emit a
1055 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1056 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16, /* type */
1058 0, /* rightshift */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1060 16, /* bitsize */
1061 FALSE, /* pc_relative */
1062 0, /* bitpos */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Like R_PPC64_PLTGOT16, but without overflow. */
1072 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1073 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_dont, /* complain_on_overflow */
1080 ppc64_elf_unhandled_reloc, /* special_function */
1081 "R_PPC64_PLTGOT16_LO", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xffff, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1088 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1089 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1090 16, /* rightshift */
1091 1, /* size (0 = byte, 1 = short, 2 = long) */
1092 16, /* bitsize */
1093 FALSE, /* pc_relative */
1094 0, /* bitpos */
1095 complain_overflow_signed, /* complain_on_overflow */
1096 ppc64_elf_unhandled_reloc, /* special_function */
1097 "R_PPC64_PLTGOT16_HI", /* name */
1098 FALSE, /* partial_inplace */
1099 0, /* src_mask */
1100 0xffff, /* dst_mask */
1101 FALSE), /* pcrel_offset */
1102
1103 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104 1 if the contents of the low 16 bits, treated as a signed number,
1105 is negative. */
1106 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1107 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1108 16, /* rightshift */
1109 1, /* size (0 = byte, 1 = short, 2 = long) */
1110 16, /* bitsize */
1111 FALSE, /* pc_relative */
1112 0, /* bitpos */
1113 complain_overflow_signed, /* complain_on_overflow */
1114 ppc64_elf_unhandled_reloc, /* special_function */
1115 "R_PPC64_PLTGOT16_HA", /* name */
1116 FALSE, /* partial_inplace */
1117 0, /* src_mask */
1118 0xffff, /* dst_mask */
1119 FALSE), /* pcrel_offset */
1120
1121 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1122 HOWTO (R_PPC64_ADDR16_DS, /* type */
1123 0, /* 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 bfd_elf_generic_reloc, /* special_function */
1130 "R_PPC64_ADDR16_DS", /* name */
1131 FALSE, /* partial_inplace */
1132 0, /* src_mask */
1133 0xfffc, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1135
1136 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1137 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1138 0, /* rightshift */
1139 1, /* size (0 = byte, 1 = short, 2 = long) */
1140 16, /* bitsize */
1141 FALSE, /* pc_relative */
1142 0, /* bitpos */
1143 complain_overflow_dont,/* complain_on_overflow */
1144 bfd_elf_generic_reloc, /* special_function */
1145 "R_PPC64_ADDR16_LO_DS",/* name */
1146 FALSE, /* partial_inplace */
1147 0, /* src_mask */
1148 0xfffc, /* dst_mask */
1149 FALSE), /* pcrel_offset */
1150
1151 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1152 HOWTO (R_PPC64_GOT16_DS, /* type */
1153 0, /* rightshift */
1154 1, /* size (0 = byte, 1 = short, 2 = long) */
1155 16, /* bitsize */
1156 FALSE, /* pc_relative */
1157 0, /* bitpos */
1158 complain_overflow_signed, /* complain_on_overflow */
1159 ppc64_elf_unhandled_reloc, /* special_function */
1160 "R_PPC64_GOT16_DS", /* name */
1161 FALSE, /* partial_inplace */
1162 0, /* src_mask */
1163 0xfffc, /* dst_mask */
1164 FALSE), /* pcrel_offset */
1165
1166 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1167 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1168 0, /* rightshift */
1169 1, /* size (0 = byte, 1 = short, 2 = long) */
1170 16, /* bitsize */
1171 FALSE, /* pc_relative */
1172 0, /* bitpos */
1173 complain_overflow_dont, /* complain_on_overflow */
1174 ppc64_elf_unhandled_reloc, /* special_function */
1175 "R_PPC64_GOT16_LO_DS", /* name */
1176 FALSE, /* partial_inplace */
1177 0, /* src_mask */
1178 0xfffc, /* dst_mask */
1179 FALSE), /* pcrel_offset */
1180
1181 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1182 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1183 0, /* rightshift */
1184 1, /* size (0 = byte, 1 = short, 2 = long) */
1185 16, /* bitsize */
1186 FALSE, /* pc_relative */
1187 0, /* bitpos */
1188 complain_overflow_dont, /* complain_on_overflow */
1189 ppc64_elf_unhandled_reloc, /* special_function */
1190 "R_PPC64_PLT16_LO_DS", /* name */
1191 FALSE, /* partial_inplace */
1192 0, /* src_mask */
1193 0xfffc, /* dst_mask */
1194 FALSE), /* pcrel_offset */
1195
1196 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1197 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1198 0, /* rightshift */
1199 1, /* size (0 = byte, 1 = short, 2 = long) */
1200 16, /* bitsize */
1201 FALSE, /* pc_relative */
1202 0, /* bitpos */
1203 complain_overflow_signed, /* complain_on_overflow */
1204 ppc64_elf_sectoff_reloc, /* special_function */
1205 "R_PPC64_SECTOFF_DS", /* name */
1206 FALSE, /* partial_inplace */
1207 0, /* src_mask */
1208 0xfffc, /* dst_mask */
1209 FALSE), /* pcrel_offset */
1210
1211 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1212 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213 0, /* rightshift */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1215 16, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_sectoff_reloc, /* special_function */
1220 "R_PPC64_SECTOFF_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1222 0, /* src_mask */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1225
1226 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1227 HOWTO (R_PPC64_TOC16_DS, /* type */
1228 0, /* rightshift */
1229 1, /* size (0 = byte, 1 = short, 2 = long) */
1230 16, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_signed, /* complain_on_overflow */
1234 ppc64_elf_toc_reloc, /* special_function */
1235 "R_PPC64_TOC16_DS", /* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0xfffc, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1240
1241 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1242 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1243 0, /* rightshift */
1244 1, /* size (0 = byte, 1 = short, 2 = long) */
1245 16, /* bitsize */
1246 FALSE, /* pc_relative */
1247 0, /* bitpos */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 ppc64_elf_toc_reloc, /* special_function */
1250 "R_PPC64_TOC16_LO_DS", /* name */
1251 FALSE, /* partial_inplace */
1252 0, /* src_mask */
1253 0xfffc, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1255
1256 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1257 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1258 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1259 0, /* rightshift */
1260 1, /* size (0 = byte, 1 = short, 2 = long) */
1261 16, /* bitsize */
1262 FALSE, /* pc_relative */
1263 0, /* bitpos */
1264 complain_overflow_signed, /* complain_on_overflow */
1265 ppc64_elf_unhandled_reloc, /* special_function */
1266 "R_PPC64_PLTGOT16_DS", /* name */
1267 FALSE, /* partial_inplace */
1268 0, /* src_mask */
1269 0xfffc, /* dst_mask */
1270 FALSE), /* pcrel_offset */
1271
1272 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1273 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1274 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275 0, /* rightshift */
1276 1, /* size (0 = byte, 1 = short, 2 = long) */
1277 16, /* bitsize */
1278 FALSE, /* pc_relative */
1279 0, /* bitpos */
1280 complain_overflow_dont, /* complain_on_overflow */
1281 ppc64_elf_unhandled_reloc, /* special_function */
1282 "R_PPC64_PLTGOT16_LO_DS",/* name */
1283 FALSE, /* partial_inplace */
1284 0, /* src_mask */
1285 0xfffc, /* dst_mask */
1286 FALSE), /* pcrel_offset */
1287
1288 /* Marker relocs for TLS. */
1289 HOWTO (R_PPC64_TLS,
1290 0, /* rightshift */
1291 2, /* size (0 = byte, 1 = short, 2 = long) */
1292 32, /* bitsize */
1293 FALSE, /* pc_relative */
1294 0, /* bitpos */
1295 complain_overflow_dont, /* complain_on_overflow */
1296 bfd_elf_generic_reloc, /* special_function */
1297 "R_PPC64_TLS", /* name */
1298 FALSE, /* partial_inplace */
1299 0, /* src_mask */
1300 0, /* dst_mask */
1301 FALSE), /* pcrel_offset */
1302
1303 HOWTO (R_PPC64_TLSGD,
1304 0, /* rightshift */
1305 2, /* size (0 = byte, 1 = short, 2 = long) */
1306 32, /* bitsize */
1307 FALSE, /* pc_relative */
1308 0, /* bitpos */
1309 complain_overflow_dont, /* complain_on_overflow */
1310 bfd_elf_generic_reloc, /* special_function */
1311 "R_PPC64_TLSGD", /* name */
1312 FALSE, /* partial_inplace */
1313 0, /* src_mask */
1314 0, /* dst_mask */
1315 FALSE), /* pcrel_offset */
1316
1317 HOWTO (R_PPC64_TLSLD,
1318 0, /* rightshift */
1319 2, /* size (0 = byte, 1 = short, 2 = long) */
1320 32, /* bitsize */
1321 FALSE, /* pc_relative */
1322 0, /* bitpos */
1323 complain_overflow_dont, /* complain_on_overflow */
1324 bfd_elf_generic_reloc, /* special_function */
1325 "R_PPC64_TLSLD", /* name */
1326 FALSE, /* partial_inplace */
1327 0, /* src_mask */
1328 0, /* dst_mask */
1329 FALSE), /* pcrel_offset */
1330
1331 HOWTO (R_PPC64_TOCSAVE,
1332 0, /* rightshift */
1333 2, /* size (0 = byte, 1 = short, 2 = long) */
1334 32, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 bfd_elf_generic_reloc, /* special_function */
1339 "R_PPC64_TOCSAVE", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Computes the load module index of the load module that contains the
1346 definition of its TLS sym. */
1347 HOWTO (R_PPC64_DTPMOD64,
1348 0, /* rightshift */
1349 4, /* size (0 = byte, 1 = short, 2 = long) */
1350 64, /* bitsize */
1351 FALSE, /* pc_relative */
1352 0, /* bitpos */
1353 complain_overflow_dont, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPMOD64", /* name */
1356 FALSE, /* partial_inplace */
1357 0, /* src_mask */
1358 ONES (64), /* dst_mask */
1359 FALSE), /* pcrel_offset */
1360
1361 /* Computes a dtv-relative displacement, the difference between the value
1362 of sym+add and the base address of the thread-local storage block that
1363 contains the definition of sym, minus 0x8000. */
1364 HOWTO (R_PPC64_DTPREL64,
1365 0, /* rightshift */
1366 4, /* size (0 = byte, 1 = short, 2 = long) */
1367 64, /* bitsize */
1368 FALSE, /* pc_relative */
1369 0, /* bitpos */
1370 complain_overflow_dont, /* complain_on_overflow */
1371 ppc64_elf_unhandled_reloc, /* special_function */
1372 "R_PPC64_DTPREL64", /* name */
1373 FALSE, /* partial_inplace */
1374 0, /* src_mask */
1375 ONES (64), /* dst_mask */
1376 FALSE), /* pcrel_offset */
1377
1378 /* A 16 bit dtprel reloc. */
1379 HOWTO (R_PPC64_DTPREL16,
1380 0, /* rightshift */
1381 1, /* size (0 = byte, 1 = short, 2 = long) */
1382 16, /* bitsize */
1383 FALSE, /* pc_relative */
1384 0, /* bitpos */
1385 complain_overflow_signed, /* complain_on_overflow */
1386 ppc64_elf_unhandled_reloc, /* special_function */
1387 "R_PPC64_DTPREL16", /* name */
1388 FALSE, /* partial_inplace */
1389 0, /* src_mask */
1390 0xffff, /* dst_mask */
1391 FALSE), /* pcrel_offset */
1392
1393 /* Like DTPREL16, but no overflow. */
1394 HOWTO (R_PPC64_DTPREL16_LO,
1395 0, /* rightshift */
1396 1, /* size (0 = byte, 1 = short, 2 = long) */
1397 16, /* bitsize */
1398 FALSE, /* pc_relative */
1399 0, /* bitpos */
1400 complain_overflow_dont, /* complain_on_overflow */
1401 ppc64_elf_unhandled_reloc, /* special_function */
1402 "R_PPC64_DTPREL16_LO", /* name */
1403 FALSE, /* partial_inplace */
1404 0, /* src_mask */
1405 0xffff, /* dst_mask */
1406 FALSE), /* pcrel_offset */
1407
1408 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1409 HOWTO (R_PPC64_DTPREL16_HI,
1410 16, /* rightshift */
1411 1, /* size (0 = byte, 1 = short, 2 = long) */
1412 16, /* bitsize */
1413 FALSE, /* pc_relative */
1414 0, /* bitpos */
1415 complain_overflow_signed, /* complain_on_overflow */
1416 ppc64_elf_unhandled_reloc, /* special_function */
1417 "R_PPC64_DTPREL16_HI", /* name */
1418 FALSE, /* partial_inplace */
1419 0, /* src_mask */
1420 0xffff, /* dst_mask */
1421 FALSE), /* pcrel_offset */
1422
1423 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1424 HOWTO (R_PPC64_DTPREL16_HA,
1425 16, /* rightshift */
1426 1, /* size (0 = byte, 1 = short, 2 = long) */
1427 16, /* bitsize */
1428 FALSE, /* pc_relative */
1429 0, /* bitpos */
1430 complain_overflow_signed, /* complain_on_overflow */
1431 ppc64_elf_unhandled_reloc, /* special_function */
1432 "R_PPC64_DTPREL16_HA", /* name */
1433 FALSE, /* partial_inplace */
1434 0, /* src_mask */
1435 0xffff, /* dst_mask */
1436 FALSE), /* pcrel_offset */
1437
1438 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1439 HOWTO (R_PPC64_DTPREL16_HIGHER,
1440 32, /* rightshift */
1441 1, /* size (0 = byte, 1 = short, 2 = long) */
1442 16, /* bitsize */
1443 FALSE, /* pc_relative */
1444 0, /* bitpos */
1445 complain_overflow_dont, /* complain_on_overflow */
1446 ppc64_elf_unhandled_reloc, /* special_function */
1447 "R_PPC64_DTPREL16_HIGHER", /* name */
1448 FALSE, /* partial_inplace */
1449 0, /* src_mask */
1450 0xffff, /* dst_mask */
1451 FALSE), /* pcrel_offset */
1452
1453 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1454 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455 32, /* rightshift */
1456 1, /* size (0 = byte, 1 = short, 2 = long) */
1457 16, /* bitsize */
1458 FALSE, /* pc_relative */
1459 0, /* bitpos */
1460 complain_overflow_dont, /* complain_on_overflow */
1461 ppc64_elf_unhandled_reloc, /* special_function */
1462 "R_PPC64_DTPREL16_HIGHERA", /* name */
1463 FALSE, /* partial_inplace */
1464 0, /* src_mask */
1465 0xffff, /* dst_mask */
1466 FALSE), /* pcrel_offset */
1467
1468 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1469 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470 48, /* rightshift */
1471 1, /* size (0 = byte, 1 = short, 2 = long) */
1472 16, /* bitsize */
1473 FALSE, /* pc_relative */
1474 0, /* bitpos */
1475 complain_overflow_dont, /* complain_on_overflow */
1476 ppc64_elf_unhandled_reloc, /* special_function */
1477 "R_PPC64_DTPREL16_HIGHEST", /* name */
1478 FALSE, /* partial_inplace */
1479 0, /* src_mask */
1480 0xffff, /* dst_mask */
1481 FALSE), /* pcrel_offset */
1482
1483 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1484 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485 48, /* rightshift */
1486 1, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
1488 FALSE, /* pc_relative */
1489 0, /* bitpos */
1490 complain_overflow_dont, /* complain_on_overflow */
1491 ppc64_elf_unhandled_reloc, /* special_function */
1492 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493 FALSE, /* partial_inplace */
1494 0, /* src_mask */
1495 0xffff, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1497
1498 /* Like DTPREL16, but for insns with a DS field. */
1499 HOWTO (R_PPC64_DTPREL16_DS,
1500 0, /* rightshift */
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 0, /* bitpos */
1505 complain_overflow_signed, /* complain_on_overflow */
1506 ppc64_elf_unhandled_reloc, /* special_function */
1507 "R_PPC64_DTPREL16_DS", /* name */
1508 FALSE, /* partial_inplace */
1509 0, /* src_mask */
1510 0xfffc, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512
1513 /* Like DTPREL16_DS, but no overflow. */
1514 HOWTO (R_PPC64_DTPREL16_LO_DS,
1515 0, /* rightshift */
1516 1, /* size (0 = byte, 1 = short, 2 = long) */
1517 16, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 ppc64_elf_unhandled_reloc, /* special_function */
1522 "R_PPC64_DTPREL16_LO_DS", /* name */
1523 FALSE, /* partial_inplace */
1524 0, /* src_mask */
1525 0xfffc, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 /* Computes a tp-relative displacement, the difference between the value of
1529 sym+add and the value of the thread pointer (r13). */
1530 HOWTO (R_PPC64_TPREL64,
1531 0, /* rightshift */
1532 4, /* size (0 = byte, 1 = short, 2 = long) */
1533 64, /* bitsize */
1534 FALSE, /* pc_relative */
1535 0, /* bitpos */
1536 complain_overflow_dont, /* complain_on_overflow */
1537 ppc64_elf_unhandled_reloc, /* special_function */
1538 "R_PPC64_TPREL64", /* name */
1539 FALSE, /* partial_inplace */
1540 0, /* src_mask */
1541 ONES (64), /* dst_mask */
1542 FALSE), /* pcrel_offset */
1543
1544 /* A 16 bit tprel reloc. */
1545 HOWTO (R_PPC64_TPREL16,
1546 0, /* rightshift */
1547 1, /* size (0 = byte, 1 = short, 2 = long) */
1548 16, /* bitsize */
1549 FALSE, /* pc_relative */
1550 0, /* bitpos */
1551 complain_overflow_signed, /* complain_on_overflow */
1552 ppc64_elf_unhandled_reloc, /* special_function */
1553 "R_PPC64_TPREL16", /* name */
1554 FALSE, /* partial_inplace */
1555 0, /* src_mask */
1556 0xffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1558
1559 /* Like TPREL16, but no overflow. */
1560 HOWTO (R_PPC64_TPREL16_LO,
1561 0, /* rightshift */
1562 1, /* size (0 = byte, 1 = short, 2 = long) */
1563 16, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont, /* complain_on_overflow */
1567 ppc64_elf_unhandled_reloc, /* special_function */
1568 "R_PPC64_TPREL16_LO", /* name */
1569 FALSE, /* partial_inplace */
1570 0, /* src_mask */
1571 0xffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573
1574 /* Like TPREL16_LO, but next higher group of 16 bits. */
1575 HOWTO (R_PPC64_TPREL16_HI,
1576 16, /* rightshift */
1577 1, /* size (0 = byte, 1 = short, 2 = long) */
1578 16, /* bitsize */
1579 FALSE, /* pc_relative */
1580 0, /* bitpos */
1581 complain_overflow_signed, /* complain_on_overflow */
1582 ppc64_elf_unhandled_reloc, /* special_function */
1583 "R_PPC64_TPREL16_HI", /* name */
1584 FALSE, /* partial_inplace */
1585 0, /* src_mask */
1586 0xffff, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1588
1589 /* Like TPREL16_HI, but adjust for low 16 bits. */
1590 HOWTO (R_PPC64_TPREL16_HA,
1591 16, /* rightshift */
1592 1, /* size (0 = byte, 1 = short, 2 = long) */
1593 16, /* bitsize */
1594 FALSE, /* pc_relative */
1595 0, /* bitpos */
1596 complain_overflow_signed, /* complain_on_overflow */
1597 ppc64_elf_unhandled_reloc, /* special_function */
1598 "R_PPC64_TPREL16_HA", /* name */
1599 FALSE, /* partial_inplace */
1600 0, /* src_mask */
1601 0xffff, /* dst_mask */
1602 FALSE), /* pcrel_offset */
1603
1604 /* Like TPREL16_HI, but next higher group of 16 bits. */
1605 HOWTO (R_PPC64_TPREL16_HIGHER,
1606 32, /* rightshift */
1607 1, /* size (0 = byte, 1 = short, 2 = long) */
1608 16, /* bitsize */
1609 FALSE, /* pc_relative */
1610 0, /* bitpos */
1611 complain_overflow_dont, /* complain_on_overflow */
1612 ppc64_elf_unhandled_reloc, /* special_function */
1613 "R_PPC64_TPREL16_HIGHER", /* name */
1614 FALSE, /* partial_inplace */
1615 0, /* src_mask */
1616 0xffff, /* dst_mask */
1617 FALSE), /* pcrel_offset */
1618
1619 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1620 HOWTO (R_PPC64_TPREL16_HIGHERA,
1621 32, /* rightshift */
1622 1, /* size (0 = byte, 1 = short, 2 = long) */
1623 16, /* bitsize */
1624 FALSE, /* pc_relative */
1625 0, /* bitpos */
1626 complain_overflow_dont, /* complain_on_overflow */
1627 ppc64_elf_unhandled_reloc, /* special_function */
1628 "R_PPC64_TPREL16_HIGHERA", /* name */
1629 FALSE, /* partial_inplace */
1630 0, /* src_mask */
1631 0xffff, /* dst_mask */
1632 FALSE), /* pcrel_offset */
1633
1634 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1635 HOWTO (R_PPC64_TPREL16_HIGHEST,
1636 48, /* rightshift */
1637 1, /* size (0 = byte, 1 = short, 2 = long) */
1638 16, /* bitsize */
1639 FALSE, /* pc_relative */
1640 0, /* bitpos */
1641 complain_overflow_dont, /* complain_on_overflow */
1642 ppc64_elf_unhandled_reloc, /* special_function */
1643 "R_PPC64_TPREL16_HIGHEST", /* name */
1644 FALSE, /* partial_inplace */
1645 0, /* src_mask */
1646 0xffff, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1648
1649 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1650 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651 48, /* rightshift */
1652 1, /* size (0 = byte, 1 = short, 2 = long) */
1653 16, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_dont, /* complain_on_overflow */
1657 ppc64_elf_unhandled_reloc, /* special_function */
1658 "R_PPC64_TPREL16_HIGHESTA", /* name */
1659 FALSE, /* partial_inplace */
1660 0, /* src_mask */
1661 0xffff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663
1664 /* Like TPREL16, but for insns with a DS field. */
1665 HOWTO (R_PPC64_TPREL16_DS,
1666 0, /* rightshift */
1667 1, /* size (0 = byte, 1 = short, 2 = long) */
1668 16, /* bitsize */
1669 FALSE, /* pc_relative */
1670 0, /* bitpos */
1671 complain_overflow_signed, /* complain_on_overflow */
1672 ppc64_elf_unhandled_reloc, /* special_function */
1673 "R_PPC64_TPREL16_DS", /* name */
1674 FALSE, /* partial_inplace */
1675 0, /* src_mask */
1676 0xfffc, /* dst_mask */
1677 FALSE), /* pcrel_offset */
1678
1679 /* Like TPREL16_DS, but no overflow. */
1680 HOWTO (R_PPC64_TPREL16_LO_DS,
1681 0, /* rightshift */
1682 1, /* size (0 = byte, 1 = short, 2 = long) */
1683 16, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont, /* complain_on_overflow */
1687 ppc64_elf_unhandled_reloc, /* special_function */
1688 "R_PPC64_TPREL16_LO_DS", /* name */
1689 FALSE, /* partial_inplace */
1690 0, /* src_mask */
1691 0xfffc, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696 to the first entry relative to the TOC base (r2). */
1697 HOWTO (R_PPC64_GOT_TLSGD16,
1698 0, /* rightshift */
1699 1, /* size (0 = byte, 1 = short, 2 = long) */
1700 16, /* bitsize */
1701 FALSE, /* pc_relative */
1702 0, /* bitpos */
1703 complain_overflow_signed, /* complain_on_overflow */
1704 ppc64_elf_unhandled_reloc, /* special_function */
1705 "R_PPC64_GOT_TLSGD16", /* name */
1706 FALSE, /* partial_inplace */
1707 0, /* src_mask */
1708 0xffff, /* dst_mask */
1709 FALSE), /* pcrel_offset */
1710
1711 /* Like GOT_TLSGD16, but no overflow. */
1712 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713 0, /* rightshift */
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1715 16, /* bitsize */
1716 FALSE, /* pc_relative */
1717 0, /* bitpos */
1718 complain_overflow_dont, /* complain_on_overflow */
1719 ppc64_elf_unhandled_reloc, /* special_function */
1720 "R_PPC64_GOT_TLSGD16_LO", /* name */
1721 FALSE, /* partial_inplace */
1722 0, /* src_mask */
1723 0xffff, /* dst_mask */
1724 FALSE), /* pcrel_offset */
1725
1726 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1727 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728 16, /* rightshift */
1729 1, /* size (0 = byte, 1 = short, 2 = long) */
1730 16, /* bitsize */
1731 FALSE, /* pc_relative */
1732 0, /* bitpos */
1733 complain_overflow_signed, /* complain_on_overflow */
1734 ppc64_elf_unhandled_reloc, /* special_function */
1735 "R_PPC64_GOT_TLSGD16_HI", /* name */
1736 FALSE, /* partial_inplace */
1737 0, /* src_mask */
1738 0xffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1740
1741 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1742 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743 16, /* rightshift */
1744 1, /* size (0 = byte, 1 = short, 2 = long) */
1745 16, /* bitsize */
1746 FALSE, /* pc_relative */
1747 0, /* bitpos */
1748 complain_overflow_signed, /* complain_on_overflow */
1749 ppc64_elf_unhandled_reloc, /* special_function */
1750 "R_PPC64_GOT_TLSGD16_HA", /* name */
1751 FALSE, /* partial_inplace */
1752 0, /* src_mask */
1753 0xffff, /* dst_mask */
1754 FALSE), /* pcrel_offset */
1755
1756 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757 with values (sym+add)@dtpmod and zero, and computes the offset to the
1758 first entry relative to the TOC base (r2). */
1759 HOWTO (R_PPC64_GOT_TLSLD16,
1760 0, /* rightshift */
1761 1, /* size (0 = byte, 1 = short, 2 = long) */
1762 16, /* bitsize */
1763 FALSE, /* pc_relative */
1764 0, /* bitpos */
1765 complain_overflow_signed, /* complain_on_overflow */
1766 ppc64_elf_unhandled_reloc, /* special_function */
1767 "R_PPC64_GOT_TLSLD16", /* name */
1768 FALSE, /* partial_inplace */
1769 0, /* src_mask */
1770 0xffff, /* dst_mask */
1771 FALSE), /* pcrel_offset */
1772
1773 /* Like GOT_TLSLD16, but no overflow. */
1774 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775 0, /* rightshift */
1776 1, /* size (0 = byte, 1 = short, 2 = long) */
1777 16, /* bitsize */
1778 FALSE, /* pc_relative */
1779 0, /* bitpos */
1780 complain_overflow_dont, /* complain_on_overflow */
1781 ppc64_elf_unhandled_reloc, /* special_function */
1782 "R_PPC64_GOT_TLSLD16_LO", /* name */
1783 FALSE, /* partial_inplace */
1784 0, /* src_mask */
1785 0xffff, /* dst_mask */
1786 FALSE), /* pcrel_offset */
1787
1788 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1789 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790 16, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1792 16, /* bitsize */
1793 FALSE, /* pc_relative */
1794 0, /* bitpos */
1795 complain_overflow_signed, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_TLSLD16_HI", /* name */
1798 FALSE, /* partial_inplace */
1799 0, /* src_mask */
1800 0xffff, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1802
1803 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1804 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805 16, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1807 16, /* bitsize */
1808 FALSE, /* pc_relative */
1809 0, /* bitpos */
1810 complain_overflow_signed, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_TLSLD16_HA", /* name */
1813 FALSE, /* partial_inplace */
1814 0, /* src_mask */
1815 0xffff, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1817
1818 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819 the offset to the entry relative to the TOC base (r2). */
1820 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821 0, /* rightshift */
1822 1, /* size (0 = byte, 1 = short, 2 = long) */
1823 16, /* bitsize */
1824 FALSE, /* pc_relative */
1825 0, /* bitpos */
1826 complain_overflow_signed, /* complain_on_overflow */
1827 ppc64_elf_unhandled_reloc, /* special_function */
1828 "R_PPC64_GOT_DTPREL16_DS", /* name */
1829 FALSE, /* partial_inplace */
1830 0, /* src_mask */
1831 0xfffc, /* dst_mask */
1832 FALSE), /* pcrel_offset */
1833
1834 /* Like GOT_DTPREL16_DS, but no overflow. */
1835 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836 0, /* rightshift */
1837 1, /* size (0 = byte, 1 = short, 2 = long) */
1838 16, /* bitsize */
1839 FALSE, /* pc_relative */
1840 0, /* bitpos */
1841 complain_overflow_dont, /* complain_on_overflow */
1842 ppc64_elf_unhandled_reloc, /* special_function */
1843 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844 FALSE, /* partial_inplace */
1845 0, /* src_mask */
1846 0xfffc, /* dst_mask */
1847 FALSE), /* pcrel_offset */
1848
1849 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1850 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851 16, /* rightshift */
1852 1, /* size (0 = byte, 1 = short, 2 = long) */
1853 16, /* bitsize */
1854 FALSE, /* pc_relative */
1855 0, /* bitpos */
1856 complain_overflow_signed, /* complain_on_overflow */
1857 ppc64_elf_unhandled_reloc, /* special_function */
1858 "R_PPC64_GOT_DTPREL16_HI", /* name */
1859 FALSE, /* partial_inplace */
1860 0, /* src_mask */
1861 0xffff, /* dst_mask */
1862 FALSE), /* pcrel_offset */
1863
1864 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1865 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866 16, /* rightshift */
1867 1, /* size (0 = byte, 1 = short, 2 = long) */
1868 16, /* bitsize */
1869 FALSE, /* pc_relative */
1870 0, /* bitpos */
1871 complain_overflow_signed, /* complain_on_overflow */
1872 ppc64_elf_unhandled_reloc, /* special_function */
1873 "R_PPC64_GOT_DTPREL16_HA", /* name */
1874 FALSE, /* partial_inplace */
1875 0, /* src_mask */
1876 0xffff, /* dst_mask */
1877 FALSE), /* pcrel_offset */
1878
1879 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880 offset to the entry relative to the TOC base (r2). */
1881 HOWTO (R_PPC64_GOT_TPREL16_DS,
1882 0, /* rightshift */
1883 1, /* size (0 = byte, 1 = short, 2 = long) */
1884 16, /* bitsize */
1885 FALSE, /* pc_relative */
1886 0, /* bitpos */
1887 complain_overflow_signed, /* complain_on_overflow */
1888 ppc64_elf_unhandled_reloc, /* special_function */
1889 "R_PPC64_GOT_TPREL16_DS", /* name */
1890 FALSE, /* partial_inplace */
1891 0, /* src_mask */
1892 0xfffc, /* dst_mask */
1893 FALSE), /* pcrel_offset */
1894
1895 /* Like GOT_TPREL16_DS, but no overflow. */
1896 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897 0, /* rightshift */
1898 1, /* size (0 = byte, 1 = short, 2 = long) */
1899 16, /* bitsize */
1900 FALSE, /* pc_relative */
1901 0, /* bitpos */
1902 complain_overflow_dont, /* complain_on_overflow */
1903 ppc64_elf_unhandled_reloc, /* special_function */
1904 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905 FALSE, /* partial_inplace */
1906 0, /* src_mask */
1907 0xfffc, /* dst_mask */
1908 FALSE), /* pcrel_offset */
1909
1910 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1911 HOWTO (R_PPC64_GOT_TPREL16_HI,
1912 16, /* rightshift */
1913 1, /* size (0 = byte, 1 = short, 2 = long) */
1914 16, /* bitsize */
1915 FALSE, /* pc_relative */
1916 0, /* bitpos */
1917 complain_overflow_signed, /* complain_on_overflow */
1918 ppc64_elf_unhandled_reloc, /* special_function */
1919 "R_PPC64_GOT_TPREL16_HI", /* name */
1920 FALSE, /* partial_inplace */
1921 0, /* src_mask */
1922 0xffff, /* dst_mask */
1923 FALSE), /* pcrel_offset */
1924
1925 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1926 HOWTO (R_PPC64_GOT_TPREL16_HA,
1927 16, /* rightshift */
1928 1, /* size (0 = byte, 1 = short, 2 = long) */
1929 16, /* bitsize */
1930 FALSE, /* pc_relative */
1931 0, /* bitpos */
1932 complain_overflow_signed, /* complain_on_overflow */
1933 ppc64_elf_unhandled_reloc, /* special_function */
1934 "R_PPC64_GOT_TPREL16_HA", /* name */
1935 FALSE, /* partial_inplace */
1936 0, /* src_mask */
1937 0xffff, /* dst_mask */
1938 FALSE), /* pcrel_offset */
1939
1940 HOWTO (R_PPC64_JMP_IREL, /* type */
1941 0, /* rightshift */
1942 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943 0, /* bitsize */
1944 FALSE, /* pc_relative */
1945 0, /* bitpos */
1946 complain_overflow_dont, /* complain_on_overflow */
1947 ppc64_elf_unhandled_reloc, /* special_function */
1948 "R_PPC64_JMP_IREL", /* name */
1949 FALSE, /* partial_inplace */
1950 0, /* src_mask */
1951 0, /* dst_mask */
1952 FALSE), /* pcrel_offset */
1953
1954 HOWTO (R_PPC64_IRELATIVE, /* type */
1955 0, /* rightshift */
1956 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957 64, /* bitsize */
1958 FALSE, /* pc_relative */
1959 0, /* bitpos */
1960 complain_overflow_dont, /* complain_on_overflow */
1961 bfd_elf_generic_reloc, /* special_function */
1962 "R_PPC64_IRELATIVE", /* name */
1963 FALSE, /* partial_inplace */
1964 0, /* src_mask */
1965 ONES (64), /* dst_mask */
1966 FALSE), /* pcrel_offset */
1967
1968 /* A 16 bit relative relocation. */
1969 HOWTO (R_PPC64_REL16, /* type */
1970 0, /* rightshift */
1971 1, /* size (0 = byte, 1 = short, 2 = long) */
1972 16, /* bitsize */
1973 TRUE, /* pc_relative */
1974 0, /* bitpos */
1975 complain_overflow_signed, /* complain_on_overflow */
1976 bfd_elf_generic_reloc, /* special_function */
1977 "R_PPC64_REL16", /* name */
1978 FALSE, /* partial_inplace */
1979 0, /* src_mask */
1980 0xffff, /* dst_mask */
1981 TRUE), /* pcrel_offset */
1982
1983 /* A 16 bit relative relocation without overflow. */
1984 HOWTO (R_PPC64_REL16_LO, /* type */
1985 0, /* rightshift */
1986 1, /* size (0 = byte, 1 = short, 2 = long) */
1987 16, /* bitsize */
1988 TRUE, /* pc_relative */
1989 0, /* bitpos */
1990 complain_overflow_dont,/* complain_on_overflow */
1991 bfd_elf_generic_reloc, /* special_function */
1992 "R_PPC64_REL16_LO", /* name */
1993 FALSE, /* partial_inplace */
1994 0, /* src_mask */
1995 0xffff, /* dst_mask */
1996 TRUE), /* pcrel_offset */
1997
1998 /* The high order 16 bits of a relative address. */
1999 HOWTO (R_PPC64_REL16_HI, /* type */
2000 16, /* rightshift */
2001 1, /* size (0 = byte, 1 = short, 2 = long) */
2002 16, /* bitsize */
2003 TRUE, /* pc_relative */
2004 0, /* bitpos */
2005 complain_overflow_signed, /* complain_on_overflow */
2006 bfd_elf_generic_reloc, /* special_function */
2007 "R_PPC64_REL16_HI", /* name */
2008 FALSE, /* partial_inplace */
2009 0, /* src_mask */
2010 0xffff, /* dst_mask */
2011 TRUE), /* pcrel_offset */
2012
2013 /* The high order 16 bits of a relative address, plus 1 if the contents of
2014 the low 16 bits, treated as a signed number, is negative. */
2015 HOWTO (R_PPC64_REL16_HA, /* type */
2016 16, /* rightshift */
2017 1, /* size (0 = byte, 1 = short, 2 = long) */
2018 16, /* bitsize */
2019 TRUE, /* pc_relative */
2020 0, /* bitpos */
2021 complain_overflow_signed, /* complain_on_overflow */
2022 ppc64_elf_ha_reloc, /* special_function */
2023 "R_PPC64_REL16_HA", /* name */
2024 FALSE, /* partial_inplace */
2025 0, /* src_mask */
2026 0xffff, /* dst_mask */
2027 TRUE), /* pcrel_offset */
2028
2029 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2030 HOWTO (R_PPC64_REL16DX_HA, /* type */
2031 16, /* rightshift */
2032 2, /* size (0 = byte, 1 = short, 2 = long) */
2033 16, /* bitsize */
2034 TRUE, /* pc_relative */
2035 0, /* bitpos */
2036 complain_overflow_signed, /* complain_on_overflow */
2037 ppc64_elf_ha_reloc, /* special_function */
2038 "R_PPC64_REL16DX_HA", /* name */
2039 FALSE, /* partial_inplace */
2040 0, /* src_mask */
2041 0x1fffc1, /* dst_mask */
2042 TRUE), /* pcrel_offset */
2043
2044 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2045 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2046 16, /* rightshift */
2047 1, /* size (0 = byte, 1 = short, 2 = long) */
2048 16, /* bitsize */
2049 FALSE, /* pc_relative */
2050 0, /* bitpos */
2051 complain_overflow_dont, /* complain_on_overflow */
2052 bfd_elf_generic_reloc, /* special_function */
2053 "R_PPC64_ADDR16_HIGH", /* name */
2054 FALSE, /* partial_inplace */
2055 0, /* src_mask */
2056 0xffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2058
2059 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2060 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2061 16, /* rightshift */
2062 1, /* size (0 = byte, 1 = short, 2 = long) */
2063 16, /* bitsize */
2064 FALSE, /* pc_relative */
2065 0, /* bitpos */
2066 complain_overflow_dont, /* complain_on_overflow */
2067 ppc64_elf_ha_reloc, /* special_function */
2068 "R_PPC64_ADDR16_HIGHA", /* name */
2069 FALSE, /* partial_inplace */
2070 0, /* src_mask */
2071 0xffff, /* dst_mask */
2072 FALSE), /* pcrel_offset */
2073
2074 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2075 HOWTO (R_PPC64_DTPREL16_HIGH,
2076 16, /* rightshift */
2077 1, /* size (0 = byte, 1 = short, 2 = long) */
2078 16, /* bitsize */
2079 FALSE, /* pc_relative */
2080 0, /* bitpos */
2081 complain_overflow_dont, /* complain_on_overflow */
2082 ppc64_elf_unhandled_reloc, /* special_function */
2083 "R_PPC64_DTPREL16_HIGH", /* name */
2084 FALSE, /* partial_inplace */
2085 0, /* src_mask */
2086 0xffff, /* dst_mask */
2087 FALSE), /* pcrel_offset */
2088
2089 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2090 HOWTO (R_PPC64_DTPREL16_HIGHA,
2091 16, /* rightshift */
2092 1, /* size (0 = byte, 1 = short, 2 = long) */
2093 16, /* bitsize */
2094 FALSE, /* pc_relative */
2095 0, /* bitpos */
2096 complain_overflow_dont, /* complain_on_overflow */
2097 ppc64_elf_unhandled_reloc, /* special_function */
2098 "R_PPC64_DTPREL16_HIGHA", /* name */
2099 FALSE, /* partial_inplace */
2100 0, /* src_mask */
2101 0xffff, /* dst_mask */
2102 FALSE), /* pcrel_offset */
2103
2104 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2105 HOWTO (R_PPC64_TPREL16_HIGH,
2106 16, /* rightshift */
2107 1, /* size (0 = byte, 1 = short, 2 = long) */
2108 16, /* bitsize */
2109 FALSE, /* pc_relative */
2110 0, /* bitpos */
2111 complain_overflow_dont, /* complain_on_overflow */
2112 ppc64_elf_unhandled_reloc, /* special_function */
2113 "R_PPC64_TPREL16_HIGH", /* name */
2114 FALSE, /* partial_inplace */
2115 0, /* src_mask */
2116 0xffff, /* dst_mask */
2117 FALSE), /* pcrel_offset */
2118
2119 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2120 HOWTO (R_PPC64_TPREL16_HIGHA,
2121 16, /* rightshift */
2122 1, /* size (0 = byte, 1 = short, 2 = long) */
2123 16, /* bitsize */
2124 FALSE, /* pc_relative */
2125 0, /* bitpos */
2126 complain_overflow_dont, /* complain_on_overflow */
2127 ppc64_elf_unhandled_reloc, /* special_function */
2128 "R_PPC64_TPREL16_HIGHA", /* name */
2129 FALSE, /* partial_inplace */
2130 0, /* src_mask */
2131 0xffff, /* dst_mask */
2132 FALSE), /* pcrel_offset */
2133
2134 /* Marker reloc on ELFv2 large-model function entry. */
2135 HOWTO (R_PPC64_ENTRY,
2136 0, /* rightshift */
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2138 32, /* bitsize */
2139 FALSE, /* pc_relative */
2140 0, /* bitpos */
2141 complain_overflow_dont, /* complain_on_overflow */
2142 bfd_elf_generic_reloc, /* special_function */
2143 "R_PPC64_ENTRY", /* name */
2144 FALSE, /* partial_inplace */
2145 0, /* src_mask */
2146 0, /* dst_mask */
2147 FALSE), /* pcrel_offset */
2148
2149 /* Like ADDR64, but use local entry point of function. */
2150 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2151 0, /* rightshift */
2152 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153 64, /* bitsize */
2154 FALSE, /* pc_relative */
2155 0, /* bitpos */
2156 complain_overflow_dont, /* complain_on_overflow */
2157 bfd_elf_generic_reloc, /* special_function */
2158 "R_PPC64_ADDR64_LOCAL", /* name */
2159 FALSE, /* partial_inplace */
2160 0, /* src_mask */
2161 ONES (64), /* dst_mask */
2162 FALSE), /* pcrel_offset */
2163
2164 /* GNU extension to record C++ vtable hierarchy. */
2165 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166 0, /* rightshift */
2167 0, /* size (0 = byte, 1 = short, 2 = long) */
2168 0, /* bitsize */
2169 FALSE, /* pc_relative */
2170 0, /* bitpos */
2171 complain_overflow_dont, /* complain_on_overflow */
2172 NULL, /* special_function */
2173 "R_PPC64_GNU_VTINHERIT", /* name */
2174 FALSE, /* partial_inplace */
2175 0, /* src_mask */
2176 0, /* dst_mask */
2177 FALSE), /* pcrel_offset */
2178
2179 /* GNU extension to record C++ vtable member usage. */
2180 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2181 0, /* rightshift */
2182 0, /* size (0 = byte, 1 = short, 2 = long) */
2183 0, /* bitsize */
2184 FALSE, /* pc_relative */
2185 0, /* bitpos */
2186 complain_overflow_dont, /* complain_on_overflow */
2187 NULL, /* special_function */
2188 "R_PPC64_GNU_VTENTRY", /* name */
2189 FALSE, /* partial_inplace */
2190 0, /* src_mask */
2191 0, /* dst_mask */
2192 FALSE), /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197 be done. */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202 unsigned int i, type;
2203
2204 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205 {
2206 type = ppc64_elf_howto_raw[i].type;
2207 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209 }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214 bfd_reloc_code_real_type code)
2215 {
2216 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219 /* Initialize howto table if needed. */
2220 ppc_howto_init ();
2221
2222 switch (code)
2223 {
2224 default:
2225 return NULL;
2226
2227 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2228 break;
2229 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2230 break;
2231 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2232 break;
2233 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2234 break;
2235 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2236 break;
2237 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2238 break;
2239 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2240 break;
2241 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2242 break;
2243 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2244 break;
2245 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2246 break;
2247 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2248 break;
2249 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2250 break;
2251 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2252 break;
2253 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2254 break;
2255 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2256 break;
2257 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2258 break;
2259 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2260 break;
2261 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2262 break;
2263 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2264 break;
2265 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2266 break;
2267 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2268 break;
2269 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2270 break;
2271 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2272 break;
2273 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2274 break;
2275 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2276 break;
2277 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2278 break;
2279 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2280 break;
2281 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2282 break;
2283 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2284 break;
2285 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2286 break;
2287 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2288 break;
2289 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2290 break;
2291 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2292 break;
2293 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2294 break;
2295 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2296 break;
2297 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2298 break;
2299 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2300 break;
2301 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2302 break;
2303 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2304 break;
2305 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2306 break;
2307 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2308 break;
2309 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2310 break;
2311 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2312 break;
2313 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2314 break;
2315 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2316 break;
2317 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2318 break;
2319 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2320 break;
2321 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2322 break;
2323 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2324 break;
2325 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2326 break;
2327 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2328 break;
2329 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2330 break;
2331 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2332 break;
2333 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2334 break;
2335 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2336 break;
2337 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2338 break;
2339 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2340 break;
2341 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2342 break;
2343 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2344 break;
2345 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2346 break;
2347 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2348 break;
2349 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2350 break;
2351 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2352 break;
2353 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2354 break;
2355 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2356 break;
2357 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2358 break;
2359 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2360 break;
2361 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2362 break;
2363 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2364 break;
2365 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2366 break;
2367 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2368 break;
2369 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2370 break;
2371 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2372 break;
2373 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2374 break;
2375 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2376 break;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2378 break;
2379 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2380 break;
2381 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2382 break;
2383 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2384 break;
2385 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2386 break;
2387 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2388 break;
2389 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2390 break;
2391 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2392 break;
2393 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2394 break;
2395 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2396 break;
2397 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2398 break;
2399 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2400 break;
2401 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2402 break;
2403 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2404 break;
2405 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2406 break;
2407 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2408 break;
2409 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2410 break;
2411 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2412 break;
2413 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2414 break;
2415 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2416 break;
2417 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2418 break;
2419 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2420 break;
2421 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2422 break;
2423 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2424 break;
2425 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2426 break;
2427 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2428 break;
2429 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2430 break;
2431 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2432 break;
2433 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2434 break;
2435 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2436 break;
2437 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2438 break;
2439 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2440 break;
2441 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2442 break;
2443 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2444 break;
2445 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2446 break;
2447 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2448 break;
2449 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2450 break;
2451 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2452 break;
2453 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2454 break;
2455 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2456 break;
2457 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2458 break;
2459 }
2460
2461 return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466 const char *r_name)
2467 {
2468 unsigned int i;
2469
2470 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471 if (ppc64_elf_howto_raw[i].name != NULL
2472 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473 return &ppc64_elf_howto_raw[i];
2474
2475 return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc. */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482 Elf_Internal_Rela *dst)
2483 {
2484 unsigned int type;
2485
2486 /* Initialize howto table if needed. */
2487 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488 ppc_howto_init ();
2489
2490 type = ELF64_R_TYPE (dst->r_info);
2491 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492 {
2493 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494 abfd, (int) type);
2495 type = R_PPC64_NONE;
2496 }
2497 cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504 void *data, asection *input_section,
2505 bfd *output_bfd, char **error_message)
2506 {
2507 enum elf_ppc64_reloc_type r_type;
2508 long insn;
2509 bfd_size_type octets;
2510 bfd_vma value;
2511
2512 /* If this is a relocatable link (output_bfd test tells us), just
2513 call the generic function. Any adjustment will be done at final
2514 link time. */
2515 if (output_bfd != NULL)
2516 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517 input_section, output_bfd, error_message);
2518
2519 /* Adjust the addend for sign extension of the low 16 bits.
2520 We won't actually be using the low 16 bits, so trashing them
2521 doesn't matter. */
2522 reloc_entry->addend += 0x8000;
2523 r_type = reloc_entry->howto->type;
2524 if (r_type != R_PPC64_REL16DX_HA)
2525 return bfd_reloc_continue;
2526
2527 value = 0;
2528 if (!bfd_is_com_section (symbol->section))
2529 value = symbol->value;
2530 value += (reloc_entry->addend
2531 + symbol->section->output_offset
2532 + symbol->section->output_section->vma);
2533 value -= (reloc_entry->address
2534 + input_section->output_offset
2535 + input_section->output_section->vma);
2536 value = (bfd_signed_vma) value >> 16;
2537
2538 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540 insn &= ~0x1fffc1;
2541 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543 if (value + 0x8000 > 0xffff)
2544 return bfd_reloc_overflow;
2545 return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550 void *data, asection *input_section,
2551 bfd *output_bfd, char **error_message)
2552 {
2553 if (output_bfd != NULL)
2554 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555 input_section, output_bfd, error_message);
2556
2557 if (strcmp (symbol->section->name, ".opd") == 0
2558 && (symbol->section->owner->flags & DYNAMIC) == 0)
2559 {
2560 bfd_vma dest = opd_entry_value (symbol->section,
2561 symbol->value + reloc_entry->addend,
2562 NULL, NULL, FALSE);
2563 if (dest != (bfd_vma) -1)
2564 reloc_entry->addend = dest - (symbol->value
2565 + symbol->section->output_section->vma
2566 + symbol->section->output_offset);
2567 }
2568 else
2569 {
2570 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572 if (symbol->section->owner != abfd
2573 && symbol->section->owner != NULL
2574 && abiversion (symbol->section->owner) >= 2)
2575 {
2576 unsigned int i;
2577
2578 for (i = 0; i < symbol->section->owner->symcount; ++i)
2579 {
2580 asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582 if (strcmp (symdef->name, symbol->name) == 0)
2583 {
2584 elfsym = (elf_symbol_type *) symdef;
2585 break;
2586 }
2587 }
2588 }
2589 reloc_entry->addend
2590 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591 }
2592 return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597 void *data, asection *input_section,
2598 bfd *output_bfd, char **error_message)
2599 {
2600 long insn;
2601 enum elf_ppc64_reloc_type r_type;
2602 bfd_size_type octets;
2603 /* Assume 'at' branch hints. */
2604 bfd_boolean is_isa_v2 = TRUE;
2605
2606 /* If this is a relocatable link (output_bfd test tells us), just
2607 call the generic function. Any adjustment will be done at final
2608 link time. */
2609 if (output_bfd != NULL)
2610 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611 input_section, output_bfd, error_message);
2612
2613 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615 insn &= ~(0x01 << 21);
2616 r_type = reloc_entry->howto->type;
2617 if (r_type == R_PPC64_ADDR14_BRTAKEN
2618 || r_type == R_PPC64_REL14_BRTAKEN)
2619 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2620
2621 if (is_isa_v2)
2622 {
2623 /* Set 'a' bit. This is 0b00010 in BO field for branch
2624 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625 for branch on CTR insns (BO == 1a00t or 1a01t). */
2626 if ((insn & (0x14 << 21)) == (0x04 << 21))
2627 insn |= 0x02 << 21;
2628 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629 insn |= 0x08 << 21;
2630 else
2631 goto out;
2632 }
2633 else
2634 {
2635 bfd_vma target = 0;
2636 bfd_vma from;
2637
2638 if (!bfd_is_com_section (symbol->section))
2639 target = symbol->value;
2640 target += symbol->section->output_section->vma;
2641 target += symbol->section->output_offset;
2642 target += reloc_entry->addend;
2643
2644 from = (reloc_entry->address
2645 + input_section->output_offset
2646 + input_section->output_section->vma);
2647
2648 /* Invert 'y' bit if not the default. */
2649 if ((bfd_signed_vma) (target - from) < 0)
2650 insn ^= 0x01 << 21;
2651 }
2652 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653 out:
2654 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655 input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660 void *data, asection *input_section,
2661 bfd *output_bfd, char **error_message)
2662 {
2663 /* If this is a relocatable link (output_bfd test tells us), just
2664 call the generic function. Any adjustment will be done at final
2665 link time. */
2666 if (output_bfd != NULL)
2667 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668 input_section, output_bfd, error_message);
2669
2670 /* Subtract the symbol section base address. */
2671 reloc_entry->addend -= symbol->section->output_section->vma;
2672 return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677 void *data, asection *input_section,
2678 bfd *output_bfd, char **error_message)
2679 {
2680 /* If this is a relocatable link (output_bfd test tells us), just
2681 call the generic function. Any adjustment will be done at final
2682 link time. */
2683 if (output_bfd != NULL)
2684 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685 input_section, output_bfd, error_message);
2686
2687 /* Subtract the symbol section base address. */
2688 reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690 /* Adjust the addend for sign extension of the low 16 bits. */
2691 reloc_entry->addend += 0x8000;
2692 return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697 void *data, asection *input_section,
2698 bfd *output_bfd, char **error_message)
2699 {
2700 bfd_vma TOCstart;
2701
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2704 link time. */
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2708
2709 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710 if (TOCstart == 0)
2711 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713 /* Subtract the TOC base address. */
2714 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715 return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720 void *data, asection *input_section,
2721 bfd *output_bfd, char **error_message)
2722 {
2723 bfd_vma TOCstart;
2724
2725 /* If this is a relocatable link (output_bfd test tells us), just
2726 call the generic function. Any adjustment will be done at final
2727 link time. */
2728 if (output_bfd != NULL)
2729 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730 input_section, output_bfd, error_message);
2731
2732 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 if (TOCstart == 0)
2734 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736 /* Subtract the TOC base address. */
2737 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739 /* Adjust the addend for sign extension of the low 16 bits. */
2740 reloc_entry->addend += 0x8000;
2741 return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746 void *data, asection *input_section,
2747 bfd *output_bfd, char **error_message)
2748 {
2749 bfd_vma TOCstart;
2750 bfd_size_type octets;
2751
2752 /* If this is a relocatable link (output_bfd test tells us), just
2753 call the generic function. Any adjustment will be done at final
2754 link time. */
2755 if (output_bfd != NULL)
2756 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757 input_section, output_bfd, error_message);
2758
2759 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760 if (TOCstart == 0)
2761 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765 return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770 void *data, asection *input_section,
2771 bfd *output_bfd, char **error_message)
2772 {
2773 /* If this is a relocatable link (output_bfd test tells us), just
2774 call the generic function. Any adjustment will be done at final
2775 link time. */
2776 if (output_bfd != NULL)
2777 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778 input_section, output_bfd, error_message);
2779
2780 if (error_message != NULL)
2781 {
2782 static char buf[60];
2783 sprintf (buf, "generic linker can't handle %s",
2784 reloc_entry->howto->name);
2785 *error_message = buf;
2786 }
2787 return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol. We might need more
2791 than one got entry per symbol. */
2792 struct got_entry
2793 {
2794 struct got_entry *next;
2795
2796 /* The symbol addend that we'll be placing in the GOT. */
2797 bfd_vma addend;
2798
2799 /* Unlike other ELF targets, we use separate GOT entries for the same
2800 symbol referenced from different input files. This is to support
2801 automatic multiple TOC/GOT sections, where the TOC base can vary
2802 from one input file to another. After partitioning into TOC groups
2803 we merge entries within the group.
2804
2805 Point to the BFD owning this GOT entry. */
2806 bfd *owner;
2807
2808 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809 TLS_TPREL or TLS_DTPREL for tls entries. */
2810 unsigned char tls_type;
2811
2812 /* Non-zero if got.ent points to real entry. */
2813 unsigned char is_indirect;
2814
2815 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2816 union
2817 {
2818 bfd_signed_vma refcount;
2819 bfd_vma offset;
2820 struct got_entry *ent;
2821 } got;
2822 };
2823
2824 /* The same for PLT. */
2825 struct plt_entry
2826 {
2827 struct plt_entry *next;
2828
2829 bfd_vma addend;
2830
2831 union
2832 {
2833 bfd_signed_vma refcount;
2834 bfd_vma offset;
2835 } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840 struct elf_obj_tdata elf;
2841
2842 /* Shortcuts to dynamic linker sections. */
2843 asection *got;
2844 asection *relgot;
2845
2846 /* Used during garbage collection. We attach global symbols defined
2847 on removed .opd entries to this section so that the sym is removed. */
2848 asection *deleted_section;
2849
2850 /* TLS local dynamic got entry handling. Support for multiple GOT
2851 sections means we potentially need one of these for each input bfd. */
2852 struct got_entry tlsld_got;
2853
2854 union {
2855 /* A copy of relocs before they are modified for --emit-relocs. */
2856 Elf_Internal_Rela *relocs;
2857
2858 /* Section contents. */
2859 bfd_byte *contents;
2860 } opd;
2861
2862 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863 the reloc to be in the range -32768 to 32767. */
2864 unsigned int has_small_toc_reloc : 1;
2865
2866 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867 instruction not one we handle. */
2868 unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875 (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879 && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras. */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887 PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891 default is 32 bit. */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2897 {
2898 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2899
2900 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2901 {
2902 /* Relies on arch after 32 bit default being 64 bit default. */
2903 abfd->arch_info = abfd->arch_info->next;
2904 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2905 }
2906 }
2907 return TRUE;
2908 }
2909
2910 /* Support for core dump NOTE sections. */
2911
2912 static bfd_boolean
2913 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2914 {
2915 size_t offset, size;
2916
2917 if (note->descsz != 504)
2918 return FALSE;
2919
2920 /* pr_cursig */
2921 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2922
2923 /* pr_pid */
2924 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2925
2926 /* pr_reg */
2927 offset = 112;
2928 size = 384;
2929
2930 /* Make a ".reg/999" section. */
2931 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2932 size, note->descpos + offset);
2933 }
2934
2935 static bfd_boolean
2936 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2937 {
2938 if (note->descsz != 136)
2939 return FALSE;
2940
2941 elf_tdata (abfd)->core->pid
2942 = bfd_get_32 (abfd, note->descdata + 24);
2943 elf_tdata (abfd)->core->program
2944 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2945 elf_tdata (abfd)->core->command
2946 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2947
2948 return TRUE;
2949 }
2950
2951 static char *
2952 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2953 ...)
2954 {
2955 switch (note_type)
2956 {
2957 default:
2958 return NULL;
2959
2960 case NT_PRPSINFO:
2961 {
2962 char data[136];
2963 va_list ap;
2964
2965 va_start (ap, note_type);
2966 memset (data, 0, sizeof (data));
2967 strncpy (data + 40, va_arg (ap, const char *), 16);
2968 strncpy (data + 56, va_arg (ap, const char *), 80);
2969 va_end (ap);
2970 return elfcore_write_note (abfd, buf, bufsiz,
2971 "CORE", note_type, data, sizeof (data));
2972 }
2973
2974 case NT_PRSTATUS:
2975 {
2976 char data[504];
2977 va_list ap;
2978 long pid;
2979 int cursig;
2980 const void *greg;
2981
2982 va_start (ap, note_type);
2983 memset (data, 0, 112);
2984 pid = va_arg (ap, long);
2985 bfd_put_32 (abfd, pid, data + 32);
2986 cursig = va_arg (ap, int);
2987 bfd_put_16 (abfd, cursig, data + 12);
2988 greg = va_arg (ap, const void *);
2989 memcpy (data + 112, greg, 384);
2990 memset (data + 496, 0, 8);
2991 va_end (ap);
2992 return elfcore_write_note (abfd, buf, bufsiz,
2993 "CORE", note_type, data, sizeof (data));
2994 }
2995 }
2996 }
2997
2998 /* Add extra PPC sections. */
2999
3000 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3001 {
3002 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3003 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3004 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3007 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3008 { NULL, 0, 0, 0, 0 }
3009 };
3010
3011 enum _ppc64_sec_type {
3012 sec_normal = 0,
3013 sec_opd = 1,
3014 sec_toc = 2
3015 };
3016
3017 struct _ppc64_elf_section_data
3018 {
3019 struct bfd_elf_section_data elf;
3020
3021 union
3022 {
3023 /* An array with one entry for each opd function descriptor,
3024 and some spares since opd entries may be either 16 or 24 bytes. */
3025 #define OPD_NDX(OFF) ((OFF) >> 4)
3026 struct _opd_sec_data
3027 {
3028 /* Points to the function code section for local opd entries. */
3029 asection **func_sec;
3030
3031 /* After editing .opd, adjust references to opd local syms. */
3032 long *adjust;
3033 } opd;
3034
3035 /* An array for toc sections, indexed by offset/8. */
3036 struct _toc_sec_data
3037 {
3038 /* Specifies the relocation symbol index used at a given toc offset. */
3039 unsigned *symndx;
3040
3041 /* And the relocation addend. */
3042 bfd_vma *add;
3043 } toc;
3044 } u;
3045
3046 enum _ppc64_sec_type sec_type:2;
3047
3048 /* Flag set when small branches are detected. Used to
3049 select suitable defaults for the stub group size. */
3050 unsigned int has_14bit_branch:1;
3051 };
3052
3053 #define ppc64_elf_section_data(sec) \
3054 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3055
3056 static bfd_boolean
3057 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3058 {
3059 if (!sec->used_by_bfd)
3060 {
3061 struct _ppc64_elf_section_data *sdata;
3062 bfd_size_type amt = sizeof (*sdata);
3063
3064 sdata = bfd_zalloc (abfd, amt);
3065 if (sdata == NULL)
3066 return FALSE;
3067 sec->used_by_bfd = sdata;
3068 }
3069
3070 return _bfd_elf_new_section_hook (abfd, sec);
3071 }
3072
3073 static struct _opd_sec_data *
3074 get_opd_info (asection * sec)
3075 {
3076 if (sec != NULL
3077 && ppc64_elf_section_data (sec) != NULL
3078 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3079 return &ppc64_elf_section_data (sec)->u.opd;
3080 return NULL;
3081 }
3082 \f
3083 /* Parameters for the qsort hook. */
3084 static bfd_boolean synthetic_relocatable;
3085
3086 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3087
3088 static int
3089 compare_symbols (const void *ap, const void *bp)
3090 {
3091 const asymbol *a = * (const asymbol **) ap;
3092 const asymbol *b = * (const asymbol **) bp;
3093
3094 /* Section symbols first. */
3095 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3096 return -1;
3097 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3098 return 1;
3099
3100 /* then .opd symbols. */
3101 if (strcmp (a->section->name, ".opd") == 0
3102 && strcmp (b->section->name, ".opd") != 0)
3103 return -1;
3104 if (strcmp (a->section->name, ".opd") != 0
3105 && strcmp (b->section->name, ".opd") == 0)
3106 return 1;
3107
3108 /* then other code symbols. */
3109 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3110 == (SEC_CODE | SEC_ALLOC)
3111 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3112 != (SEC_CODE | SEC_ALLOC))
3113 return -1;
3114
3115 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3116 != (SEC_CODE | SEC_ALLOC)
3117 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3118 == (SEC_CODE | SEC_ALLOC))
3119 return 1;
3120
3121 if (synthetic_relocatable)
3122 {
3123 if (a->section->id < b->section->id)
3124 return -1;
3125
3126 if (a->section->id > b->section->id)
3127 return 1;
3128 }
3129
3130 if (a->value + a->section->vma < b->value + b->section->vma)
3131 return -1;
3132
3133 if (a->value + a->section->vma > b->value + b->section->vma)
3134 return 1;
3135
3136 /* For syms with the same value, prefer strong dynamic global function
3137 syms over other syms. */
3138 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3139 return -1;
3140
3141 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3142 return 1;
3143
3144 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3145 return -1;
3146
3147 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3148 return 1;
3149
3150 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3151 return -1;
3152
3153 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3154 return 1;
3155
3156 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3157 return -1;
3158
3159 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3160 return 1;
3161
3162 return 0;
3163 }
3164
3165 /* Search SYMS for a symbol of the given VALUE. */
3166
3167 static asymbol *
3168 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3169 {
3170 long mid;
3171
3172 if (id == (unsigned) -1)
3173 {
3174 while (lo < hi)
3175 {
3176 mid = (lo + hi) >> 1;
3177 if (syms[mid]->value + syms[mid]->section->vma < value)
3178 lo = mid + 1;
3179 else if (syms[mid]->value + syms[mid]->section->vma > value)
3180 hi = mid;
3181 else
3182 return syms[mid];
3183 }
3184 }
3185 else
3186 {
3187 while (lo < hi)
3188 {
3189 mid = (lo + hi) >> 1;
3190 if (syms[mid]->section->id < id)
3191 lo = mid + 1;
3192 else if (syms[mid]->section->id > id)
3193 hi = mid;
3194 else if (syms[mid]->value < value)
3195 lo = mid + 1;
3196 else if (syms[mid]->value > value)
3197 hi = mid;
3198 else
3199 return syms[mid];
3200 }
3201 }
3202 return NULL;
3203 }
3204
3205 static bfd_boolean
3206 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3207 {
3208 bfd_vma vma = *(bfd_vma *) ptr;
3209 return ((section->flags & SEC_ALLOC) != 0
3210 && section->vma <= vma
3211 && vma < section->vma + section->size);
3212 }
3213
3214 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3215 entry syms. Also generate @plt symbols for the glink branch table.
3216 Returns count of synthetic symbols in RET or -1 on error. */
3217
3218 static long
3219 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3220 long static_count, asymbol **static_syms,
3221 long dyn_count, asymbol **dyn_syms,
3222 asymbol **ret)
3223 {
3224 asymbol *s;
3225 long i;
3226 long count;
3227 char *names;
3228 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3229 asection *opd = NULL;
3230 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3231 asymbol **syms;
3232 int abi = abiversion (abfd);
3233
3234 *ret = NULL;
3235
3236 if (abi < 2)
3237 {
3238 opd = bfd_get_section_by_name (abfd, ".opd");
3239 if (opd == NULL && abi == 1)
3240 return 0;
3241 }
3242
3243 symcount = static_count;
3244 if (!relocatable)
3245 symcount += dyn_count;
3246 if (symcount == 0)
3247 return 0;
3248
3249 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3250 if (syms == NULL)
3251 return -1;
3252
3253 if (!relocatable && static_count != 0 && dyn_count != 0)
3254 {
3255 /* Use both symbol tables. */
3256 memcpy (syms, static_syms, static_count * sizeof (*syms));
3257 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3258 }
3259 else if (!relocatable && static_count == 0)
3260 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3261 else
3262 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3263
3264 synthetic_relocatable = relocatable;
3265 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3266
3267 if (!relocatable && symcount > 1)
3268 {
3269 long j;
3270 /* Trim duplicate syms, since we may have merged the normal and
3271 dynamic symbols. Actually, we only care about syms that have
3272 different values, so trim any with the same value. */
3273 for (i = 1, j = 1; i < symcount; ++i)
3274 if (syms[i - 1]->value + syms[i - 1]->section->vma
3275 != syms[i]->value + syms[i]->section->vma)
3276 syms[j++] = syms[i];
3277 symcount = j;
3278 }
3279
3280 i = 0;
3281 if (strcmp (syms[i]->section->name, ".opd") == 0)
3282 ++i;
3283 codesecsym = i;
3284
3285 for (; i < symcount; ++i)
3286 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3287 != (SEC_CODE | SEC_ALLOC))
3288 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3289 break;
3290 codesecsymend = i;
3291
3292 for (; i < symcount; ++i)
3293 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3294 break;
3295 secsymend = i;
3296
3297 for (; i < symcount; ++i)
3298 if (strcmp (syms[i]->section->name, ".opd") != 0)
3299 break;
3300 opdsymend = i;
3301
3302 for (; i < symcount; ++i)
3303 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3304 != (SEC_CODE | SEC_ALLOC))
3305 break;
3306 symcount = i;
3307
3308 count = 0;
3309
3310 if (relocatable)
3311 {
3312 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3313 arelent *r;
3314 size_t size;
3315 long relcount;
3316
3317 if (opdsymend == secsymend)
3318 goto done;
3319
3320 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3321 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3322 if (relcount == 0)
3323 goto done;
3324
3325 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3326 {
3327 count = -1;
3328 goto done;
3329 }
3330
3331 size = 0;
3332 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3333 {
3334 asymbol *sym;
3335
3336 while (r < opd->relocation + relcount
3337 && r->address < syms[i]->value + opd->vma)
3338 ++r;
3339
3340 if (r == opd->relocation + relcount)
3341 break;
3342
3343 if (r->address != syms[i]->value + opd->vma)
3344 continue;
3345
3346 if (r->howto->type != R_PPC64_ADDR64)
3347 continue;
3348
3349 sym = *r->sym_ptr_ptr;
3350 if (!sym_exists_at (syms, opdsymend, symcount,
3351 sym->section->id, sym->value + r->addend))
3352 {
3353 ++count;
3354 size += sizeof (asymbol);
3355 size += strlen (syms[i]->name) + 2;
3356 }
3357 }
3358
3359 if (size == 0)
3360 goto done;
3361 s = *ret = bfd_malloc (size);
3362 if (s == NULL)
3363 {
3364 count = -1;
3365 goto done;
3366 }
3367
3368 names = (char *) (s + count);
3369
3370 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3371 {
3372 asymbol *sym;
3373
3374 while (r < opd->relocation + relcount
3375 && r->address < syms[i]->value + opd->vma)
3376 ++r;
3377
3378 if (r == opd->relocation + relcount)
3379 break;
3380
3381 if (r->address != syms[i]->value + opd->vma)
3382 continue;
3383
3384 if (r->howto->type != R_PPC64_ADDR64)
3385 continue;
3386
3387 sym = *r->sym_ptr_ptr;
3388 if (!sym_exists_at (syms, opdsymend, symcount,
3389 sym->section->id, sym->value + r->addend))
3390 {
3391 size_t len;
3392
3393 *s = *syms[i];
3394 s->flags |= BSF_SYNTHETIC;
3395 s->section = sym->section;
3396 s->value = sym->value + r->addend;
3397 s->name = names;
3398 *names++ = '.';
3399 len = strlen (syms[i]->name);
3400 memcpy (names, syms[i]->name, len + 1);
3401 names += len + 1;
3402 /* Have udata.p point back to the original symbol this
3403 synthetic symbol was derived from. */
3404 s->udata.p = syms[i];
3405 s++;
3406 }
3407 }
3408 }
3409 else
3410 {
3411 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3412 bfd_byte *contents = NULL;
3413 size_t size;
3414 long plt_count = 0;
3415 bfd_vma glink_vma = 0, resolv_vma = 0;
3416 asection *dynamic, *glink = NULL, *relplt = NULL;
3417 arelent *p;
3418
3419 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3420 {
3421 free_contents_and_exit_err:
3422 count = -1;
3423 free_contents_and_exit:
3424 if (contents)
3425 free (contents);
3426 goto done;
3427 }
3428
3429 size = 0;
3430 for (i = secsymend; i < opdsymend; ++i)
3431 {
3432 bfd_vma ent;
3433
3434 /* Ignore bogus symbols. */
3435 if (syms[i]->value > opd->size - 8)
3436 continue;
3437
3438 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3439 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3440 {
3441 ++count;
3442 size += sizeof (asymbol);
3443 size += strlen (syms[i]->name) + 2;
3444 }
3445 }
3446
3447 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3448 if (dyn_count != 0
3449 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3450 {
3451 bfd_byte *dynbuf, *extdyn, *extdynend;
3452 size_t extdynsize;
3453 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3454
3455 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3456 goto free_contents_and_exit_err;
3457
3458 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3459 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3460
3461 extdyn = dynbuf;
3462 extdynend = extdyn + dynamic->size;
3463 for (; extdyn < extdynend; extdyn += extdynsize)
3464 {
3465 Elf_Internal_Dyn dyn;
3466 (*swap_dyn_in) (abfd, extdyn, &dyn);
3467
3468 if (dyn.d_tag == DT_NULL)
3469 break;
3470
3471 if (dyn.d_tag == DT_PPC64_GLINK)
3472 {
3473 /* The first glink stub starts at offset 32; see
3474 comment in ppc64_elf_finish_dynamic_sections. */
3475 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3476 /* The .glink section usually does not survive the final
3477 link; search for the section (usually .text) where the
3478 glink stubs now reside. */
3479 glink = bfd_sections_find_if (abfd, section_covers_vma,
3480 &glink_vma);
3481 break;
3482 }
3483 }
3484
3485 free (dynbuf);
3486 }
3487
3488 if (glink != NULL)
3489 {
3490 /* Determine __glink trampoline by reading the relative branch
3491 from the first glink stub. */
3492 bfd_byte buf[4];
3493 unsigned int off = 0;
3494
3495 while (bfd_get_section_contents (abfd, glink, buf,
3496 glink_vma + off - glink->vma, 4))
3497 {
3498 unsigned int insn = bfd_get_32 (abfd, buf);
3499 insn ^= B_DOT;
3500 if ((insn & ~0x3fffffc) == 0)
3501 {
3502 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3503 break;
3504 }
3505 off += 4;
3506 if (off > 4)
3507 break;
3508 }
3509
3510 if (resolv_vma)
3511 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3512
3513 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3514 if (relplt != NULL)
3515 {
3516 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3517 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3518 goto free_contents_and_exit_err;
3519
3520 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3521 size += plt_count * sizeof (asymbol);
3522
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3525 {
3526 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3527 if (p->addend != 0)
3528 size += sizeof ("+0x") - 1 + 16;
3529 }
3530 }
3531 }
3532
3533 if (size == 0)
3534 goto free_contents_and_exit;
3535 s = *ret = bfd_malloc (size);
3536 if (s == NULL)
3537 goto free_contents_and_exit_err;
3538
3539 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3540
3541 for (i = secsymend; i < opdsymend; ++i)
3542 {
3543 bfd_vma ent;
3544
3545 if (syms[i]->value > opd->size - 8)
3546 continue;
3547
3548 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3549 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3550 {
3551 long lo, hi;
3552 size_t len;
3553 asection *sec = abfd->sections;
3554
3555 *s = *syms[i];
3556 lo = codesecsym;
3557 hi = codesecsymend;
3558 while (lo < hi)
3559 {
3560 long mid = (lo + hi) >> 1;
3561 if (syms[mid]->section->vma < ent)
3562 lo = mid + 1;
3563 else if (syms[mid]->section->vma > ent)
3564 hi = mid;
3565 else
3566 {
3567 sec = syms[mid]->section;
3568 break;
3569 }
3570 }
3571
3572 if (lo >= hi && lo > codesecsym)
3573 sec = syms[lo - 1]->section;
3574
3575 for (; sec != NULL; sec = sec->next)
3576 {
3577 if (sec->vma > ent)
3578 break;
3579 /* SEC_LOAD may not be set if SEC is from a separate debug
3580 info file. */
3581 if ((sec->flags & SEC_ALLOC) == 0)
3582 break;
3583 if ((sec->flags & SEC_CODE) != 0)
3584 s->section = sec;
3585 }
3586 s->flags |= BSF_SYNTHETIC;
3587 s->value = ent - s->section->vma;
3588 s->name = names;
3589 *names++ = '.';
3590 len = strlen (syms[i]->name);
3591 memcpy (names, syms[i]->name, len + 1);
3592 names += len + 1;
3593 /* Have udata.p point back to the original symbol this
3594 synthetic symbol was derived from. */
3595 s->udata.p = syms[i];
3596 s++;
3597 }
3598 }
3599 free (contents);
3600
3601 if (glink != NULL && relplt != NULL)
3602 {
3603 if (resolv_vma)
3604 {
3605 /* Add a symbol for the main glink trampoline. */
3606 memset (s, 0, sizeof *s);
3607 s->the_bfd = abfd;
3608 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3609 s->section = glink;
3610 s->value = resolv_vma - glink->vma;
3611 s->name = names;
3612 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3613 names += sizeof ("__glink_PLTresolve");
3614 s++;
3615 count++;
3616 }
3617
3618 /* FIXME: It would be very much nicer to put sym@plt on the
3619 stub rather than on the glink branch table entry. The
3620 objdump disassembler would then use a sensible symbol
3621 name on plt calls. The difficulty in doing so is
3622 a) finding the stubs, and,
3623 b) matching stubs against plt entries, and,
3624 c) there can be multiple stubs for a given plt entry.
3625
3626 Solving (a) could be done by code scanning, but older
3627 ppc64 binaries used different stubs to current code.
3628 (b) is the tricky one since you need to known the toc
3629 pointer for at least one function that uses a pic stub to
3630 be able to calculate the plt address referenced.
3631 (c) means gdb would need to set multiple breakpoints (or
3632 find the glink branch itself) when setting breakpoints
3633 for pending shared library loads. */
3634 p = relplt->relocation;
3635 for (i = 0; i < plt_count; i++, p++)
3636 {
3637 size_t len;
3638
3639 *s = **p->sym_ptr_ptr;
3640 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3641 we are defining a symbol, ensure one of them is set. */
3642 if ((s->flags & BSF_LOCAL) == 0)
3643 s->flags |= BSF_GLOBAL;
3644 s->flags |= BSF_SYNTHETIC;
3645 s->section = glink;
3646 s->value = glink_vma - glink->vma;
3647 s->name = names;
3648 s->udata.p = NULL;
3649 len = strlen ((*p->sym_ptr_ptr)->name);
3650 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3651 names += len;
3652 if (p->addend != 0)
3653 {
3654 memcpy (names, "+0x", sizeof ("+0x") - 1);
3655 names += sizeof ("+0x") - 1;
3656 bfd_sprintf_vma (abfd, names, p->addend);
3657 names += strlen (names);
3658 }
3659 memcpy (names, "@plt", sizeof ("@plt"));
3660 names += sizeof ("@plt");
3661 s++;
3662 if (abi < 2)
3663 {
3664 glink_vma += 8;
3665 if (i >= 0x8000)
3666 glink_vma += 4;
3667 }
3668 else
3669 glink_vma += 4;
3670 }
3671 count += plt_count;
3672 }
3673 }
3674
3675 done:
3676 free (syms);
3677 return count;
3678 }
3679 \f
3680 /* The following functions are specific to the ELF linker, while
3681 functions above are used generally. Those named ppc64_elf_* are
3682 called by the main ELF linker code. They appear in this file more
3683 or less in the order in which they are called. eg.
3684 ppc64_elf_check_relocs is called early in the link process,
3685 ppc64_elf_finish_dynamic_sections is one of the last functions
3686 called.
3687
3688 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3689 functions have both a function code symbol and a function descriptor
3690 symbol. A call to foo in a relocatable object file looks like:
3691
3692 . .text
3693 . x:
3694 . bl .foo
3695 . nop
3696
3697 The function definition in another object file might be:
3698
3699 . .section .opd
3700 . foo: .quad .foo
3701 . .quad .TOC.@tocbase
3702 . .quad 0
3703 .
3704 . .text
3705 . .foo: blr
3706
3707 When the linker resolves the call during a static link, the branch
3708 unsurprisingly just goes to .foo and the .opd information is unused.
3709 If the function definition is in a shared library, things are a little
3710 different: The call goes via a plt call stub, the opd information gets
3711 copied to the plt, and the linker patches the nop.
3712
3713 . x:
3714 . bl .foo_stub
3715 . ld 2,40(1)
3716 .
3717 .
3718 . .foo_stub:
3719 . std 2,40(1) # in practice, the call stub
3720 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3721 . addi 11,11,Lfoo@toc@l # this is the general idea
3722 . ld 12,0(11)
3723 . ld 2,8(11)
3724 . mtctr 12
3725 . ld 11,16(11)
3726 . bctr
3727 .
3728 . .section .plt
3729 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3730
3731 The "reloc ()" notation is supposed to indicate that the linker emits
3732 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3733 copying.
3734
3735 What are the difficulties here? Well, firstly, the relocations
3736 examined by the linker in check_relocs are against the function code
3737 sym .foo, while the dynamic relocation in the plt is emitted against
3738 the function descriptor symbol, foo. Somewhere along the line, we need
3739 to carefully copy dynamic link information from one symbol to the other.
3740 Secondly, the generic part of the elf linker will make .foo a dynamic
3741 symbol as is normal for most other backends. We need foo dynamic
3742 instead, at least for an application final link. However, when
3743 creating a shared library containing foo, we need to have both symbols
3744 dynamic so that references to .foo are satisfied during the early
3745 stages of linking. Otherwise the linker might decide to pull in a
3746 definition from some other object, eg. a static library.
3747
3748 Update: As of August 2004, we support a new convention. Function
3749 calls may use the function descriptor symbol, ie. "bl foo". This
3750 behaves exactly as "bl .foo". */
3751
3752 /* Of those relocs that might be copied as dynamic relocs, this function
3753 selects those that must be copied when linking a shared library,
3754 even when the symbol is local. */
3755
3756 static int
3757 must_be_dyn_reloc (struct bfd_link_info *info,
3758 enum elf_ppc64_reloc_type r_type)
3759 {
3760 switch (r_type)
3761 {
3762 default:
3763 return 1;
3764
3765 case R_PPC64_REL32:
3766 case R_PPC64_REL64:
3767 case R_PPC64_REL30:
3768 return 0;
3769
3770 case R_PPC64_TPREL16:
3771 case R_PPC64_TPREL16_LO:
3772 case R_PPC64_TPREL16_HI:
3773 case R_PPC64_TPREL16_HA:
3774 case R_PPC64_TPREL16_DS:
3775 case R_PPC64_TPREL16_LO_DS:
3776 case R_PPC64_TPREL16_HIGH:
3777 case R_PPC64_TPREL16_HIGHA:
3778 case R_PPC64_TPREL16_HIGHER:
3779 case R_PPC64_TPREL16_HIGHERA:
3780 case R_PPC64_TPREL16_HIGHEST:
3781 case R_PPC64_TPREL16_HIGHESTA:
3782 case R_PPC64_TPREL64:
3783 return !bfd_link_executable (info);
3784 }
3785 }
3786
3787 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3788 copying dynamic variables from a shared lib into an app's dynbss
3789 section, and instead use a dynamic relocation to point into the
3790 shared lib. With code that gcc generates, it's vital that this be
3791 enabled; In the PowerPC64 ABI, the address of a function is actually
3792 the address of a function descriptor, which resides in the .opd
3793 section. gcc uses the descriptor directly rather than going via the
3794 GOT as some other ABI's do, which means that initialized function
3795 pointers must reference the descriptor. Thus, a function pointer
3796 initialized to the address of a function in a shared library will
3797 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3798 redefines the function descriptor symbol to point to the copy. This
3799 presents a problem as a plt entry for that function is also
3800 initialized from the function descriptor symbol and the copy reloc
3801 may not be initialized first. */
3802 #define ELIMINATE_COPY_RELOCS 1
3803
3804 /* Section name for stubs is the associated section name plus this
3805 string. */
3806 #define STUB_SUFFIX ".stub"
3807
3808 /* Linker stubs.
3809 ppc_stub_long_branch:
3810 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3811 destination, but a 24 bit branch in a stub section will reach.
3812 . b dest
3813
3814 ppc_stub_plt_branch:
3815 Similar to the above, but a 24 bit branch in the stub section won't
3816 reach its destination.
3817 . addis %r11,%r2,xxx@toc@ha
3818 . ld %r12,xxx@toc@l(%r11)
3819 . mtctr %r12
3820 . bctr
3821
3822 ppc_stub_plt_call:
3823 Used to call a function in a shared library. If it so happens that
3824 the plt entry referenced crosses a 64k boundary, then an extra
3825 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3826 . std %r2,40(%r1)
3827 . addis %r11,%r2,xxx@toc@ha
3828 . ld %r12,xxx+0@toc@l(%r11)
3829 . mtctr %r12
3830 . ld %r2,xxx+8@toc@l(%r11)
3831 . ld %r11,xxx+16@toc@l(%r11)
3832 . bctr
3833
3834 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3835 code to adjust the value and save r2 to support multiple toc sections.
3836 A ppc_stub_long_branch with an r2 offset looks like:
3837 . std %r2,40(%r1)
3838 . addis %r2,%r2,off@ha
3839 . addi %r2,%r2,off@l
3840 . b dest
3841
3842 A ppc_stub_plt_branch with an r2 offset looks like:
3843 . std %r2,40(%r1)
3844 . addis %r11,%r2,xxx@toc@ha
3845 . ld %r12,xxx@toc@l(%r11)
3846 . addis %r2,%r2,off@ha
3847 . addi %r2,%r2,off@l
3848 . mtctr %r12
3849 . bctr
3850
3851 In cases where the "addis" instruction would add zero, the "addis" is
3852 omitted and following instructions modified slightly in some cases.
3853 */
3854
3855 enum ppc_stub_type {
3856 ppc_stub_none,
3857 ppc_stub_long_branch,
3858 ppc_stub_long_branch_r2off,
3859 ppc_stub_plt_branch,
3860 ppc_stub_plt_branch_r2off,
3861 ppc_stub_plt_call,
3862 ppc_stub_plt_call_r2save,
3863 ppc_stub_global_entry,
3864 ppc_stub_save_res
3865 };
3866
3867 /* Information on stub grouping. */
3868 struct map_stub
3869 {
3870 /* The stub section. */
3871 asection *stub_sec;
3872 /* This is the section to which stubs in the group will be attached. */
3873 asection *link_sec;
3874 /* Next group. */
3875 struct map_stub *next;
3876 /* Whether to emit a copy of register save/restore functions in this
3877 group. */
3878 int needs_save_res;
3879 };
3880
3881 struct ppc_stub_hash_entry {
3882
3883 /* Base hash table entry structure. */
3884 struct bfd_hash_entry root;
3885
3886 enum ppc_stub_type stub_type;
3887
3888 /* Group information. */
3889 struct map_stub *group;
3890
3891 /* Offset within stub_sec of the beginning of this stub. */
3892 bfd_vma stub_offset;
3893
3894 /* Given the symbol's value and its section we can determine its final
3895 value when building the stubs (so the stub knows where to jump. */
3896 bfd_vma target_value;
3897 asection *target_section;
3898
3899 /* The symbol table entry, if any, that this was derived from. */
3900 struct ppc_link_hash_entry *h;
3901 struct plt_entry *plt_ent;
3902
3903 /* Symbol st_other. */
3904 unsigned char other;
3905 };
3906
3907 struct ppc_branch_hash_entry {
3908
3909 /* Base hash table entry structure. */
3910 struct bfd_hash_entry root;
3911
3912 /* Offset within branch lookup table. */
3913 unsigned int offset;
3914
3915 /* Generation marker. */
3916 unsigned int iter;
3917 };
3918
3919 /* Used to track dynamic relocations for local symbols. */
3920 struct ppc_dyn_relocs
3921 {
3922 struct ppc_dyn_relocs *next;
3923
3924 /* The input section of the reloc. */
3925 asection *sec;
3926
3927 /* Total number of relocs copied for the input section. */
3928 unsigned int count : 31;
3929
3930 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3931 unsigned int ifunc : 1;
3932 };
3933
3934 struct ppc_link_hash_entry
3935 {
3936 struct elf_link_hash_entry elf;
3937
3938 union {
3939 /* A pointer to the most recently used stub hash entry against this
3940 symbol. */
3941 struct ppc_stub_hash_entry *stub_cache;
3942
3943 /* A pointer to the next symbol starting with a '.' */
3944 struct ppc_link_hash_entry *next_dot_sym;
3945 } u;
3946
3947 /* Track dynamic relocs copied for this symbol. */
3948 struct elf_dyn_relocs *dyn_relocs;
3949
3950 /* Link between function code and descriptor symbols. */
3951 struct ppc_link_hash_entry *oh;
3952
3953 /* Flag function code and descriptor symbols. */
3954 unsigned int is_func:1;
3955 unsigned int is_func_descriptor:1;
3956 unsigned int fake:1;
3957
3958 /* Whether global opd/toc sym has been adjusted or not.
3959 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3960 should be set for all globals defined in any opd/toc section. */
3961 unsigned int adjust_done:1;
3962
3963 /* Set if we twiddled this symbol to weak at some stage. */
3964 unsigned int was_undefined:1;
3965
3966 /* Set if this is an out-of-line register save/restore function,
3967 with non-standard calling convention. */
3968 unsigned int save_res:1;
3969
3970 /* Contexts in which symbol is used in the GOT (or TOC).
3971 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3972 corresponding relocs are encountered during check_relocs.
3973 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3974 indicate the corresponding GOT entry type is not needed.
3975 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3976 a TPREL one. We use a separate flag rather than setting TPREL
3977 just for convenience in distinguishing the two cases. */
3978 #define TLS_GD 1 /* GD reloc. */
3979 #define TLS_LD 2 /* LD reloc. */
3980 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3981 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3982 #define TLS_TLS 16 /* Any TLS reloc. */
3983 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3984 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3985 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3986 unsigned char tls_mask;
3987 };
3988
3989 /* ppc64 ELF linker hash table. */
3990
3991 struct ppc_link_hash_table
3992 {
3993 struct elf_link_hash_table elf;
3994
3995 /* The stub hash table. */
3996 struct bfd_hash_table stub_hash_table;
3997
3998 /* Another hash table for plt_branch stubs. */
3999 struct bfd_hash_table branch_hash_table;
4000
4001 /* Hash table for function prologue tocsave. */
4002 htab_t tocsave_htab;
4003
4004 /* Various options and other info passed from the linker. */
4005 struct ppc64_elf_params *params;
4006
4007 /* The size of sec_info below. */
4008 unsigned int sec_info_arr_size;
4009
4010 /* Per-section array of extra section info. Done this way rather
4011 than as part of ppc64_elf_section_data so we have the info for
4012 non-ppc64 sections. */
4013 struct
4014 {
4015 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4016 bfd_vma toc_off;
4017
4018 union
4019 {
4020 /* The section group that this section belongs to. */
4021 struct map_stub *group;
4022 /* A temp section list pointer. */
4023 asection *list;
4024 } u;
4025 } *sec_info;
4026
4027 /* Linked list of groups. */
4028 struct map_stub *group;
4029
4030 /* Temp used when calculating TOC pointers. */
4031 bfd_vma toc_curr;
4032 bfd *toc_bfd;
4033 asection *toc_first_sec;
4034
4035 /* Used when adding symbols. */
4036 struct ppc_link_hash_entry *dot_syms;
4037
4038 /* Shortcuts to get to dynamic linker sections. */
4039 asection *dynbss;
4040 asection *relbss;
4041 asection *glink;
4042 asection *sfpr;
4043 asection *brlt;
4044 asection *relbrlt;
4045 asection *glink_eh_frame;
4046
4047 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4048 struct ppc_link_hash_entry *tls_get_addr;
4049 struct ppc_link_hash_entry *tls_get_addr_fd;
4050
4051 /* The size of reliplt used by got entry relocs. */
4052 bfd_size_type got_reli_size;
4053
4054 /* Statistics. */
4055 unsigned long stub_count[ppc_stub_global_entry];
4056
4057 /* Number of stubs against global syms. */
4058 unsigned long stub_globals;
4059
4060 /* Set if we're linking code with function descriptors. */
4061 unsigned int opd_abi:1;
4062
4063 /* Support for multiple toc sections. */
4064 unsigned int do_multi_toc:1;
4065 unsigned int multi_toc_needed:1;
4066 unsigned int second_toc_pass:1;
4067 unsigned int do_toc_opt:1;
4068
4069 /* Set on error. */
4070 unsigned int stub_error:1;
4071
4072 /* Temp used by ppc64_elf_before_check_relocs. */
4073 unsigned int twiddled_syms:1;
4074
4075 /* Incremented every time we size stubs. */
4076 unsigned int stub_iteration;
4077
4078 /* Small local sym cache. */
4079 struct sym_cache sym_cache;
4080 };
4081
4082 /* Rename some of the generic section flags to better document how they
4083 are used here. */
4084
4085 /* Nonzero if this section has TLS related relocations. */
4086 #define has_tls_reloc sec_flg0
4087
4088 /* Nonzero if this section has a call to __tls_get_addr. */
4089 #define has_tls_get_addr_call sec_flg1
4090
4091 /* Nonzero if this section has any toc or got relocs. */
4092 #define has_toc_reloc sec_flg2
4093
4094 /* Nonzero if this section has a call to another section that uses
4095 the toc or got. */
4096 #define makes_toc_func_call sec_flg3
4097
4098 /* Recursion protection when determining above flag. */
4099 #define call_check_in_progress sec_flg4
4100 #define call_check_done sec_flg5
4101
4102 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4103
4104 #define ppc_hash_table(p) \
4105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4106 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4107
4108 #define ppc_stub_hash_lookup(table, string, create, copy) \
4109 ((struct ppc_stub_hash_entry *) \
4110 bfd_hash_lookup ((table), (string), (create), (copy)))
4111
4112 #define ppc_branch_hash_lookup(table, string, create, copy) \
4113 ((struct ppc_branch_hash_entry *) \
4114 bfd_hash_lookup ((table), (string), (create), (copy)))
4115
4116 /* Create an entry in the stub hash table. */
4117
4118 static struct bfd_hash_entry *
4119 stub_hash_newfunc (struct bfd_hash_entry *entry,
4120 struct bfd_hash_table *table,
4121 const char *string)
4122 {
4123 /* Allocate the structure if it has not already been allocated by a
4124 subclass. */
4125 if (entry == NULL)
4126 {
4127 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4128 if (entry == NULL)
4129 return entry;
4130 }
4131
4132 /* Call the allocation method of the superclass. */
4133 entry = bfd_hash_newfunc (entry, table, string);
4134 if (entry != NULL)
4135 {
4136 struct ppc_stub_hash_entry *eh;
4137
4138 /* Initialize the local fields. */
4139 eh = (struct ppc_stub_hash_entry *) entry;
4140 eh->stub_type = ppc_stub_none;
4141 eh->group = NULL;
4142 eh->stub_offset = 0;
4143 eh->target_value = 0;
4144 eh->target_section = NULL;
4145 eh->h = NULL;
4146 eh->plt_ent = NULL;
4147 eh->other = 0;
4148 }
4149
4150 return entry;
4151 }
4152
4153 /* Create an entry in the branch hash table. */
4154
4155 static struct bfd_hash_entry *
4156 branch_hash_newfunc (struct bfd_hash_entry *entry,
4157 struct bfd_hash_table *table,
4158 const char *string)
4159 {
4160 /* Allocate the structure if it has not already been allocated by a
4161 subclass. */
4162 if (entry == NULL)
4163 {
4164 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4165 if (entry == NULL)
4166 return entry;
4167 }
4168
4169 /* Call the allocation method of the superclass. */
4170 entry = bfd_hash_newfunc (entry, table, string);
4171 if (entry != NULL)
4172 {
4173 struct ppc_branch_hash_entry *eh;
4174
4175 /* Initialize the local fields. */
4176 eh = (struct ppc_branch_hash_entry *) entry;
4177 eh->offset = 0;
4178 eh->iter = 0;
4179 }
4180
4181 return entry;
4182 }
4183
4184 /* Create an entry in a ppc64 ELF linker hash table. */
4185
4186 static struct bfd_hash_entry *
4187 link_hash_newfunc (struct bfd_hash_entry *entry,
4188 struct bfd_hash_table *table,
4189 const char *string)
4190 {
4191 /* Allocate the structure if it has not already been allocated by a
4192 subclass. */
4193 if (entry == NULL)
4194 {
4195 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4196 if (entry == NULL)
4197 return entry;
4198 }
4199
4200 /* Call the allocation method of the superclass. */
4201 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4202 if (entry != NULL)
4203 {
4204 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4205
4206 memset (&eh->u.stub_cache, 0,
4207 (sizeof (struct ppc_link_hash_entry)
4208 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4209
4210 /* When making function calls, old ABI code references function entry
4211 points (dot symbols), while new ABI code references the function
4212 descriptor symbol. We need to make any combination of reference and
4213 definition work together, without breaking archive linking.
4214
4215 For a defined function "foo" and an undefined call to "bar":
4216 An old object defines "foo" and ".foo", references ".bar" (possibly
4217 "bar" too).
4218 A new object defines "foo" and references "bar".
4219
4220 A new object thus has no problem with its undefined symbols being
4221 satisfied by definitions in an old object. On the other hand, the
4222 old object won't have ".bar" satisfied by a new object.
4223
4224 Keep a list of newly added dot-symbols. */
4225
4226 if (string[0] == '.')
4227 {
4228 struct ppc_link_hash_table *htab;
4229
4230 htab = (struct ppc_link_hash_table *) table;
4231 eh->u.next_dot_sym = htab->dot_syms;
4232 htab->dot_syms = eh;
4233 }
4234 }
4235
4236 return entry;
4237 }
4238
4239 struct tocsave_entry {
4240 asection *sec;
4241 bfd_vma offset;
4242 };
4243
4244 static hashval_t
4245 tocsave_htab_hash (const void *p)
4246 {
4247 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4248 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4249 }
4250
4251 static int
4252 tocsave_htab_eq (const void *p1, const void *p2)
4253 {
4254 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4255 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4256 return e1->sec == e2->sec && e1->offset == e2->offset;
4257 }
4258
4259 /* Destroy a ppc64 ELF linker hash table. */
4260
4261 static void
4262 ppc64_elf_link_hash_table_free (bfd *obfd)
4263 {
4264 struct ppc_link_hash_table *htab;
4265
4266 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4267 if (htab->tocsave_htab)
4268 htab_delete (htab->tocsave_htab);
4269 bfd_hash_table_free (&htab->branch_hash_table);
4270 bfd_hash_table_free (&htab->stub_hash_table);
4271 _bfd_elf_link_hash_table_free (obfd);
4272 }
4273
4274 /* Create a ppc64 ELF linker hash table. */
4275
4276 static struct bfd_link_hash_table *
4277 ppc64_elf_link_hash_table_create (bfd *abfd)
4278 {
4279 struct ppc_link_hash_table *htab;
4280 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4281
4282 htab = bfd_zmalloc (amt);
4283 if (htab == NULL)
4284 return NULL;
4285
4286 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4287 sizeof (struct ppc_link_hash_entry),
4288 PPC64_ELF_DATA))
4289 {
4290 free (htab);
4291 return NULL;
4292 }
4293
4294 /* Init the stub hash table too. */
4295 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4296 sizeof (struct ppc_stub_hash_entry)))
4297 {
4298 _bfd_elf_link_hash_table_free (abfd);
4299 return NULL;
4300 }
4301
4302 /* And the branch hash table. */
4303 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4304 sizeof (struct ppc_branch_hash_entry)))
4305 {
4306 bfd_hash_table_free (&htab->stub_hash_table);
4307 _bfd_elf_link_hash_table_free (abfd);
4308 return NULL;
4309 }
4310
4311 htab->tocsave_htab = htab_try_create (1024,
4312 tocsave_htab_hash,
4313 tocsave_htab_eq,
4314 NULL);
4315 if (htab->tocsave_htab == NULL)
4316 {
4317 ppc64_elf_link_hash_table_free (abfd);
4318 return NULL;
4319 }
4320 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4321
4322 /* Initializing two fields of the union is just cosmetic. We really
4323 only care about glist, but when compiled on a 32-bit host the
4324 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4325 debugger inspection of these fields look nicer. */
4326 htab->elf.init_got_refcount.refcount = 0;
4327 htab->elf.init_got_refcount.glist = NULL;
4328 htab->elf.init_plt_refcount.refcount = 0;
4329 htab->elf.init_plt_refcount.glist = NULL;
4330 htab->elf.init_got_offset.offset = 0;
4331 htab->elf.init_got_offset.glist = NULL;
4332 htab->elf.init_plt_offset.offset = 0;
4333 htab->elf.init_plt_offset.glist = NULL;
4334
4335 return &htab->elf.root;
4336 }
4337
4338 /* Create sections for linker generated code. */
4339
4340 static bfd_boolean
4341 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4342 {
4343 struct ppc_link_hash_table *htab;
4344 flagword flags;
4345
4346 htab = ppc_hash_table (info);
4347
4348 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4349 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4350 if (htab->params->save_restore_funcs)
4351 {
4352 /* Create .sfpr for code to save and restore fp regs. */
4353 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4354 flags);
4355 if (htab->sfpr == NULL
4356 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4357 return FALSE;
4358 }
4359
4360 if (bfd_link_relocatable (info))
4361 return TRUE;
4362
4363 /* Create .glink for lazy dynamic linking support. */
4364 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4365 flags);
4366 if (htab->glink == NULL
4367 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4368 return FALSE;
4369
4370 if (!info->no_ld_generated_unwind_info)
4371 {
4372 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4373 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4374 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4375 ".eh_frame",
4376 flags);
4377 if (htab->glink_eh_frame == NULL
4378 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4379 return FALSE;
4380 }
4381
4382 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4383 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4384 if (htab->elf.iplt == NULL
4385 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4386 return FALSE;
4387
4388 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4389 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390 htab->elf.irelplt
4391 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4392 if (htab->elf.irelplt == NULL
4393 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4394 return FALSE;
4395
4396 /* Create branch lookup table for plt_branch stubs. */
4397 flags = (SEC_ALLOC | SEC_LOAD
4398 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4399 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4400 flags);
4401 if (htab->brlt == NULL
4402 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4403 return FALSE;
4404
4405 if (!bfd_link_pic (info))
4406 return TRUE;
4407
4408 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4409 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4410 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4411 ".rela.branch_lt",
4412 flags);
4413 if (htab->relbrlt == NULL
4414 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4415 return FALSE;
4416
4417 return TRUE;
4418 }
4419
4420 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4421
4422 bfd_boolean
4423 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4424 struct ppc64_elf_params *params)
4425 {
4426 struct ppc_link_hash_table *htab;
4427
4428 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4429
4430 /* Always hook our dynamic sections into the first bfd, which is the
4431 linker created stub bfd. This ensures that the GOT header is at
4432 the start of the output TOC section. */
4433 htab = ppc_hash_table (info);
4434 htab->elf.dynobj = params->stub_bfd;
4435 htab->params = params;
4436
4437 return create_linkage_sections (htab->elf.dynobj, info);
4438 }
4439
4440 /* Build a name for an entry in the stub hash table. */
4441
4442 static char *
4443 ppc_stub_name (const asection *input_section,
4444 const asection *sym_sec,
4445 const struct ppc_link_hash_entry *h,
4446 const Elf_Internal_Rela *rel)
4447 {
4448 char *stub_name;
4449 ssize_t len;
4450
4451 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4452 offsets from a sym as a branch target? In fact, we could
4453 probably assume the addend is always zero. */
4454 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4455
4456 if (h)
4457 {
4458 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4459 stub_name = bfd_malloc (len);
4460 if (stub_name == NULL)
4461 return stub_name;
4462
4463 len = sprintf (stub_name, "%08x.%s+%x",
4464 input_section->id & 0xffffffff,
4465 h->elf.root.root.string,
4466 (int) rel->r_addend & 0xffffffff);
4467 }
4468 else
4469 {
4470 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4471 stub_name = bfd_malloc (len);
4472 if (stub_name == NULL)
4473 return stub_name;
4474
4475 len = sprintf (stub_name, "%08x.%x:%x+%x",
4476 input_section->id & 0xffffffff,
4477 sym_sec->id & 0xffffffff,
4478 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4479 (int) rel->r_addend & 0xffffffff);
4480 }
4481 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4482 stub_name[len - 2] = 0;
4483 return stub_name;
4484 }
4485
4486 /* Look up an entry in the stub hash. Stub entries are cached because
4487 creating the stub name takes a bit of time. */
4488
4489 static struct ppc_stub_hash_entry *
4490 ppc_get_stub_entry (const asection *input_section,
4491 const asection *sym_sec,
4492 struct ppc_link_hash_entry *h,
4493 const Elf_Internal_Rela *rel,
4494 struct ppc_link_hash_table *htab)
4495 {
4496 struct ppc_stub_hash_entry *stub_entry;
4497 struct map_stub *group;
4498
4499 /* If this input section is part of a group of sections sharing one
4500 stub section, then use the id of the first section in the group.
4501 Stub names need to include a section id, as there may well be
4502 more than one stub used to reach say, printf, and we need to
4503 distinguish between them. */
4504 group = htab->sec_info[input_section->id].u.group;
4505
4506 if (h != NULL && h->u.stub_cache != NULL
4507 && h->u.stub_cache->h == h
4508 && h->u.stub_cache->group == group)
4509 {
4510 stub_entry = h->u.stub_cache;
4511 }
4512 else
4513 {
4514 char *stub_name;
4515
4516 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4517 if (stub_name == NULL)
4518 return NULL;
4519
4520 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4521 stub_name, FALSE, FALSE);
4522 if (h != NULL)
4523 h->u.stub_cache = stub_entry;
4524
4525 free (stub_name);
4526 }
4527
4528 return stub_entry;
4529 }
4530
4531 /* Add a new stub entry to the stub hash. Not all fields of the new
4532 stub entry are initialised. */
4533
4534 static struct ppc_stub_hash_entry *
4535 ppc_add_stub (const char *stub_name,
4536 asection *section,
4537 struct bfd_link_info *info)
4538 {
4539 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4540 struct map_stub *group;
4541 asection *link_sec;
4542 asection *stub_sec;
4543 struct ppc_stub_hash_entry *stub_entry;
4544
4545 group = htab->sec_info[section->id].u.group;
4546 link_sec = group->link_sec;
4547 stub_sec = group->stub_sec;
4548 if (stub_sec == NULL)
4549 {
4550 size_t namelen;
4551 bfd_size_type len;
4552 char *s_name;
4553
4554 namelen = strlen (link_sec->name);
4555 len = namelen + sizeof (STUB_SUFFIX);
4556 s_name = bfd_alloc (htab->params->stub_bfd, len);
4557 if (s_name == NULL)
4558 return NULL;
4559
4560 memcpy (s_name, link_sec->name, namelen);
4561 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4562 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4563 if (stub_sec == NULL)
4564 return NULL;
4565 group->stub_sec = stub_sec;
4566 }
4567
4568 /* Enter this entry into the linker stub hash table. */
4569 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4570 TRUE, FALSE);
4571 if (stub_entry == NULL)
4572 {
4573 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4574 section->owner, stub_name);
4575 return NULL;
4576 }
4577
4578 stub_entry->group = group;
4579 stub_entry->stub_offset = 0;
4580 return stub_entry;
4581 }
4582
4583 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4584 not already done. */
4585
4586 static bfd_boolean
4587 create_got_section (bfd *abfd, struct bfd_link_info *info)
4588 {
4589 asection *got, *relgot;
4590 flagword flags;
4591 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4592
4593 if (!is_ppc64_elf (abfd))
4594 return FALSE;
4595 if (htab == NULL)
4596 return FALSE;
4597
4598 if (!htab->elf.sgot
4599 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4600 return FALSE;
4601
4602 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4603 | SEC_LINKER_CREATED);
4604
4605 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4606 if (!got
4607 || !bfd_set_section_alignment (abfd, got, 3))
4608 return FALSE;
4609
4610 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4611 flags | SEC_READONLY);
4612 if (!relgot
4613 || ! bfd_set_section_alignment (abfd, relgot, 3))
4614 return FALSE;
4615
4616 ppc64_elf_tdata (abfd)->got = got;
4617 ppc64_elf_tdata (abfd)->relgot = relgot;
4618 return TRUE;
4619 }
4620
4621 /* Create the dynamic sections, and set up shortcuts. */
4622
4623 static bfd_boolean
4624 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4625 {
4626 struct ppc_link_hash_table *htab;
4627
4628 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4629 return FALSE;
4630
4631 htab = ppc_hash_table (info);
4632 if (htab == NULL)
4633 return FALSE;
4634
4635 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4636 if (!bfd_link_pic (info))
4637 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4638
4639 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4640 || (!bfd_link_pic (info) && !htab->relbss))
4641 abort ();
4642
4643 return TRUE;
4644 }
4645
4646 /* Follow indirect and warning symbol links. */
4647
4648 static inline struct bfd_link_hash_entry *
4649 follow_link (struct bfd_link_hash_entry *h)
4650 {
4651 while (h->type == bfd_link_hash_indirect
4652 || h->type == bfd_link_hash_warning)
4653 h = h->u.i.link;
4654 return h;
4655 }
4656
4657 static inline struct elf_link_hash_entry *
4658 elf_follow_link (struct elf_link_hash_entry *h)
4659 {
4660 return (struct elf_link_hash_entry *) follow_link (&h->root);
4661 }
4662
4663 static inline struct ppc_link_hash_entry *
4664 ppc_follow_link (struct ppc_link_hash_entry *h)
4665 {
4666 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4667 }
4668
4669 /* Merge PLT info on FROM with that on TO. */
4670
4671 static void
4672 move_plt_plist (struct ppc_link_hash_entry *from,
4673 struct ppc_link_hash_entry *to)
4674 {
4675 if (from->elf.plt.plist != NULL)
4676 {
4677 if (to->elf.plt.plist != NULL)
4678 {
4679 struct plt_entry **entp;
4680 struct plt_entry *ent;
4681
4682 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4683 {
4684 struct plt_entry *dent;
4685
4686 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4687 if (dent->addend == ent->addend)
4688 {
4689 dent->plt.refcount += ent->plt.refcount;
4690 *entp = ent->next;
4691 break;
4692 }
4693 if (dent == NULL)
4694 entp = &ent->next;
4695 }
4696 *entp = to->elf.plt.plist;
4697 }
4698
4699 to->elf.plt.plist = from->elf.plt.plist;
4700 from->elf.plt.plist = NULL;
4701 }
4702 }
4703
4704 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4705
4706 static void
4707 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4708 struct elf_link_hash_entry *dir,
4709 struct elf_link_hash_entry *ind)
4710 {
4711 struct ppc_link_hash_entry *edir, *eind;
4712
4713 edir = (struct ppc_link_hash_entry *) dir;
4714 eind = (struct ppc_link_hash_entry *) ind;
4715
4716 edir->is_func |= eind->is_func;
4717 edir->is_func_descriptor |= eind->is_func_descriptor;
4718 edir->tls_mask |= eind->tls_mask;
4719 if (eind->oh != NULL)
4720 edir->oh = ppc_follow_link (eind->oh);
4721
4722 /* If called to transfer flags for a weakdef during processing
4723 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4724 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4725 if (!(ELIMINATE_COPY_RELOCS
4726 && eind->elf.root.type != bfd_link_hash_indirect
4727 && edir->elf.dynamic_adjusted))
4728 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4729
4730 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4731 edir->elf.ref_regular |= eind->elf.ref_regular;
4732 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4733 edir->elf.needs_plt |= eind->elf.needs_plt;
4734 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4735
4736 /* Copy over any dynamic relocs we may have on the indirect sym. */
4737 if (eind->dyn_relocs != NULL)
4738 {
4739 if (edir->dyn_relocs != NULL)
4740 {
4741 struct elf_dyn_relocs **pp;
4742 struct elf_dyn_relocs *p;
4743
4744 /* Add reloc counts against the indirect sym to the direct sym
4745 list. Merge any entries against the same section. */
4746 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4747 {
4748 struct elf_dyn_relocs *q;
4749
4750 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4751 if (q->sec == p->sec)
4752 {
4753 q->pc_count += p->pc_count;
4754 q->count += p->count;
4755 *pp = p->next;
4756 break;
4757 }
4758 if (q == NULL)
4759 pp = &p->next;
4760 }
4761 *pp = edir->dyn_relocs;
4762 }
4763
4764 edir->dyn_relocs = eind->dyn_relocs;
4765 eind->dyn_relocs = NULL;
4766 }
4767
4768 /* If we were called to copy over info for a weak sym, that's all.
4769 You might think dyn_relocs need not be copied over; After all,
4770 both syms will be dynamic or both non-dynamic so we're just
4771 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4772 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4773 dyn_relocs in read-only sections, and it does so on what is the
4774 DIR sym here. */
4775 if (eind->elf.root.type != bfd_link_hash_indirect)
4776 return;
4777
4778 /* Copy over got entries that we may have already seen to the
4779 symbol which just became indirect. */
4780 if (eind->elf.got.glist != NULL)
4781 {
4782 if (edir->elf.got.glist != NULL)
4783 {
4784 struct got_entry **entp;
4785 struct got_entry *ent;
4786
4787 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4788 {
4789 struct got_entry *dent;
4790
4791 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4792 if (dent->addend == ent->addend
4793 && dent->owner == ent->owner
4794 && dent->tls_type == ent->tls_type)
4795 {
4796 dent->got.refcount += ent->got.refcount;
4797 *entp = ent->next;
4798 break;
4799 }
4800 if (dent == NULL)
4801 entp = &ent->next;
4802 }
4803 *entp = edir->elf.got.glist;
4804 }
4805
4806 edir->elf.got.glist = eind->elf.got.glist;
4807 eind->elf.got.glist = NULL;
4808 }
4809
4810 /* And plt entries. */
4811 move_plt_plist (eind, edir);
4812
4813 if (eind->elf.dynindx != -1)
4814 {
4815 if (edir->elf.dynindx != -1)
4816 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4817 edir->elf.dynstr_index);
4818 edir->elf.dynindx = eind->elf.dynindx;
4819 edir->elf.dynstr_index = eind->elf.dynstr_index;
4820 eind->elf.dynindx = -1;
4821 eind->elf.dynstr_index = 0;
4822 }
4823 }
4824
4825 /* Find the function descriptor hash entry from the given function code
4826 hash entry FH. Link the entries via their OH fields. */
4827
4828 static struct ppc_link_hash_entry *
4829 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4830 {
4831 struct ppc_link_hash_entry *fdh = fh->oh;
4832
4833 if (fdh == NULL)
4834 {
4835 const char *fd_name = fh->elf.root.root.string + 1;
4836
4837 fdh = (struct ppc_link_hash_entry *)
4838 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4839 if (fdh == NULL)
4840 return fdh;
4841
4842 fdh->is_func_descriptor = 1;
4843 fdh->oh = fh;
4844 fh->is_func = 1;
4845 fh->oh = fdh;
4846 }
4847
4848 return ppc_follow_link (fdh);
4849 }
4850
4851 /* Make a fake function descriptor sym for the code sym FH. */
4852
4853 static struct ppc_link_hash_entry *
4854 make_fdh (struct bfd_link_info *info,
4855 struct ppc_link_hash_entry *fh)
4856 {
4857 bfd *abfd;
4858 asymbol *newsym;
4859 struct bfd_link_hash_entry *bh;
4860 struct ppc_link_hash_entry *fdh;
4861
4862 abfd = fh->elf.root.u.undef.abfd;
4863 newsym = bfd_make_empty_symbol (abfd);
4864 newsym->name = fh->elf.root.root.string + 1;
4865 newsym->section = bfd_und_section_ptr;
4866 newsym->value = 0;
4867 newsym->flags = BSF_WEAK;
4868
4869 bh = NULL;
4870 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4871 newsym->flags, newsym->section,
4872 newsym->value, NULL, FALSE, FALSE,
4873 &bh))
4874 return NULL;
4875
4876 fdh = (struct ppc_link_hash_entry *) bh;
4877 fdh->elf.non_elf = 0;
4878 fdh->fake = 1;
4879 fdh->is_func_descriptor = 1;
4880 fdh->oh = fh;
4881 fh->is_func = 1;
4882 fh->oh = fdh;
4883 return fdh;
4884 }
4885
4886 /* Fix function descriptor symbols defined in .opd sections to be
4887 function type. */
4888
4889 static bfd_boolean
4890 ppc64_elf_add_symbol_hook (bfd *ibfd,
4891 struct bfd_link_info *info,
4892 Elf_Internal_Sym *isym,
4893 const char **name,
4894 flagword *flags ATTRIBUTE_UNUSED,
4895 asection **sec,
4896 bfd_vma *value)
4897 {
4898 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4899 && (ibfd->flags & DYNAMIC) == 0
4900 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4901 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4902
4903 if (*sec != NULL
4904 && strcmp ((*sec)->name, ".opd") == 0)
4905 {
4906 asection *code_sec;
4907
4908 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4909 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4910 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4911
4912 /* If the symbol is a function defined in .opd, and the function
4913 code is in a discarded group, let it appear to be undefined. */
4914 if (!bfd_link_relocatable (info)
4915 && (*sec)->reloc_count != 0
4916 && opd_entry_value (*sec, *value, &code_sec, NULL,
4917 FALSE) != (bfd_vma) -1
4918 && discarded_section (code_sec))
4919 {
4920 *sec = bfd_und_section_ptr;
4921 isym->st_shndx = SHN_UNDEF;
4922 }
4923 }
4924 else if (*sec != NULL
4925 && strcmp ((*sec)->name, ".toc") == 0
4926 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4927 {
4928 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4929 if (htab != NULL)
4930 htab->params->object_in_toc = 1;
4931 }
4932
4933 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4934 {
4935 if (abiversion (ibfd) == 0)
4936 set_abiversion (ibfd, 2);
4937 else if (abiversion (ibfd) == 1)
4938 {
4939 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4940 " for ABI version 1\n"), name);
4941 bfd_set_error (bfd_error_bad_value);
4942 return FALSE;
4943 }
4944 }
4945
4946 return TRUE;
4947 }
4948
4949 /* Merge non-visibility st_other attributes: local entry point. */
4950
4951 static void
4952 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4953 const Elf_Internal_Sym *isym,
4954 bfd_boolean definition,
4955 bfd_boolean dynamic)
4956 {
4957 if (definition && !dynamic)
4958 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4959 | ELF_ST_VISIBILITY (h->other));
4960 }
4961
4962 /* This function makes an old ABI object reference to ".bar" cause the
4963 inclusion of a new ABI object archive that defines "bar".
4964 NAME is a symbol defined in an archive. Return a symbol in the hash
4965 table that might be satisfied by the archive symbols. */
4966
4967 static struct elf_link_hash_entry *
4968 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4969 struct bfd_link_info *info,
4970 const char *name)
4971 {
4972 struct elf_link_hash_entry *h;
4973 char *dot_name;
4974 size_t len;
4975
4976 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4977 if (h != NULL
4978 /* Don't return this sym if it is a fake function descriptor
4979 created by add_symbol_adjust. */
4980 && !(h->root.type == bfd_link_hash_undefweak
4981 && ((struct ppc_link_hash_entry *) h)->fake))
4982 return h;
4983
4984 if (name[0] == '.')
4985 return h;
4986
4987 len = strlen (name);
4988 dot_name = bfd_alloc (abfd, len + 2);
4989 if (dot_name == NULL)
4990 return (struct elf_link_hash_entry *) 0 - 1;
4991 dot_name[0] = '.';
4992 memcpy (dot_name + 1, name, len + 1);
4993 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4994 bfd_release (abfd, dot_name);
4995 return h;
4996 }
4997
4998 /* This function satisfies all old ABI object references to ".bar" if a
4999 new ABI object defines "bar". Well, at least, undefined dot symbols
5000 are made weak. This stops later archive searches from including an
5001 object if we already have a function descriptor definition. It also
5002 prevents the linker complaining about undefined symbols.
5003 We also check and correct mismatched symbol visibility here. The
5004 most restrictive visibility of the function descriptor and the
5005 function entry symbol is used. */
5006
5007 static bfd_boolean
5008 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5009 {
5010 struct ppc_link_hash_table *htab;
5011 struct ppc_link_hash_entry *fdh;
5012
5013 if (eh->elf.root.type == bfd_link_hash_indirect)
5014 return TRUE;
5015
5016 if (eh->elf.root.type == bfd_link_hash_warning)
5017 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5018
5019 if (eh->elf.root.root.string[0] != '.')
5020 abort ();
5021
5022 htab = ppc_hash_table (info);
5023 if (htab == NULL)
5024 return FALSE;
5025
5026 fdh = lookup_fdh (eh, htab);
5027 if (fdh == NULL)
5028 {
5029 if (!bfd_link_relocatable (info)
5030 && (eh->elf.root.type == bfd_link_hash_undefined
5031 || eh->elf.root.type == bfd_link_hash_undefweak)
5032 && eh->elf.ref_regular)
5033 {
5034 /* Make an undefweak function descriptor sym, which is enough to
5035 pull in an --as-needed shared lib, but won't cause link
5036 errors. Archives are handled elsewhere. */
5037 fdh = make_fdh (info, eh);
5038 if (fdh == NULL)
5039 return FALSE;
5040 fdh->elf.ref_regular = 1;
5041 }
5042 }
5043 else
5044 {
5045 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5046 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5047 if (entry_vis < descr_vis)
5048 fdh->elf.other += entry_vis - descr_vis;
5049 else if (entry_vis > descr_vis)
5050 eh->elf.other += descr_vis - entry_vis;
5051
5052 if ((fdh->elf.root.type == bfd_link_hash_defined
5053 || fdh->elf.root.type == bfd_link_hash_defweak)
5054 && eh->elf.root.type == bfd_link_hash_undefined)
5055 {
5056 eh->elf.root.type = bfd_link_hash_undefweak;
5057 eh->was_undefined = 1;
5058 htab->twiddled_syms = 1;
5059 }
5060 }
5061
5062 return TRUE;
5063 }
5064
5065 /* Set up opd section info and abiversion for IBFD, and process list
5066 of dot-symbols we made in link_hash_newfunc. */
5067
5068 static bfd_boolean
5069 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5070 {
5071 struct ppc_link_hash_table *htab;
5072 struct ppc_link_hash_entry **p, *eh;
5073 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5074
5075 if (opd != NULL && opd->size != 0)
5076 {
5077 if (abiversion (ibfd) == 0)
5078 set_abiversion (ibfd, 1);
5079 else if (abiversion (ibfd) == 2)
5080 {
5081 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5082 " version %d\n"),
5083 ibfd, abiversion (ibfd));
5084 bfd_set_error (bfd_error_bad_value);
5085 return FALSE;
5086 }
5087
5088 if ((ibfd->flags & DYNAMIC) == 0
5089 && (opd->flags & SEC_RELOC) != 0
5090 && opd->reloc_count != 0
5091 && !bfd_is_abs_section (opd->output_section))
5092 {
5093 /* Garbage collection needs some extra help with .opd sections.
5094 We don't want to necessarily keep everything referenced by
5095 relocs in .opd, as that would keep all functions. Instead,
5096 if we reference an .opd symbol (a function descriptor), we
5097 want to keep the function code symbol's section. This is
5098 easy for global symbols, but for local syms we need to keep
5099 information about the associated function section. */
5100 bfd_size_type amt;
5101 asection **opd_sym_map;
5102
5103 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5104 opd_sym_map = bfd_zalloc (ibfd, amt);
5105 if (opd_sym_map == NULL)
5106 return FALSE;
5107 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5108 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5109 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5110 }
5111 }
5112
5113 if (!is_ppc64_elf (info->output_bfd))
5114 return TRUE;
5115 htab = ppc_hash_table (info);
5116 if (htab == NULL)
5117 return FALSE;
5118
5119 /* For input files without an explicit abiversion in e_flags
5120 we should have flagged any with symbol st_other bits set
5121 as ELFv1 and above flagged those with .opd as ELFv2.
5122 Set the output abiversion if not yet set, and for any input
5123 still ambiguous, take its abiversion from the output.
5124 Differences in ABI are reported later. */
5125 if (abiversion (info->output_bfd) == 0)
5126 set_abiversion (info->output_bfd, abiversion (ibfd));
5127 else if (abiversion (ibfd) == 0)
5128 set_abiversion (ibfd, abiversion (info->output_bfd));
5129
5130 p = &htab->dot_syms;
5131 while ((eh = *p) != NULL)
5132 {
5133 *p = NULL;
5134 if (&eh->elf == htab->elf.hgot)
5135 ;
5136 else if (htab->elf.hgot == NULL
5137 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5138 htab->elf.hgot = &eh->elf;
5139 else if (!add_symbol_adjust (eh, info))
5140 return FALSE;
5141 p = &eh->u.next_dot_sym;
5142 }
5143
5144 /* Clear the list for non-ppc64 input files. */
5145 p = &htab->dot_syms;
5146 while ((eh = *p) != NULL)
5147 {
5148 *p = NULL;
5149 p = &eh->u.next_dot_sym;
5150 }
5151
5152 /* We need to fix the undefs list for any syms we have twiddled to
5153 undef_weak. */
5154 if (htab->twiddled_syms)
5155 {
5156 bfd_link_repair_undef_list (&htab->elf.root);
5157 htab->twiddled_syms = 0;
5158 }
5159 return TRUE;
5160 }
5161
5162 /* Undo hash table changes when an --as-needed input file is determined
5163 not to be needed. */
5164
5165 static bfd_boolean
5166 ppc64_elf_notice_as_needed (bfd *ibfd,
5167 struct bfd_link_info *info,
5168 enum notice_asneeded_action act)
5169 {
5170 if (act == notice_not_needed)
5171 {
5172 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5173
5174 if (htab == NULL)
5175 return FALSE;
5176
5177 htab->dot_syms = NULL;
5178 }
5179 return _bfd_elf_notice_as_needed (ibfd, info, act);
5180 }
5181
5182 /* If --just-symbols against a final linked binary, then assume we need
5183 toc adjusting stubs when calling functions defined there. */
5184
5185 static void
5186 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5187 {
5188 if ((sec->flags & SEC_CODE) != 0
5189 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5190 && is_ppc64_elf (sec->owner))
5191 {
5192 if (abiversion (sec->owner) >= 2
5193 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5194 sec->has_toc_reloc = 1;
5195 }
5196 _bfd_elf_link_just_syms (sec, info);
5197 }
5198
5199 static struct plt_entry **
5200 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5201 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5202 {
5203 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5204 struct plt_entry **local_plt;
5205 unsigned char *local_got_tls_masks;
5206
5207 if (local_got_ents == NULL)
5208 {
5209 bfd_size_type size = symtab_hdr->sh_info;
5210
5211 size *= (sizeof (*local_got_ents)
5212 + sizeof (*local_plt)
5213 + sizeof (*local_got_tls_masks));
5214 local_got_ents = bfd_zalloc (abfd, size);
5215 if (local_got_ents == NULL)
5216 return NULL;
5217 elf_local_got_ents (abfd) = local_got_ents;
5218 }
5219
5220 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5221 {
5222 struct got_entry *ent;
5223
5224 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5225 if (ent->addend == r_addend
5226 && ent->owner == abfd
5227 && ent->tls_type == tls_type)
5228 break;
5229 if (ent == NULL)
5230 {
5231 bfd_size_type amt = sizeof (*ent);
5232 ent = bfd_alloc (abfd, amt);
5233 if (ent == NULL)
5234 return FALSE;
5235 ent->next = local_got_ents[r_symndx];
5236 ent->addend = r_addend;
5237 ent->owner = abfd;
5238 ent->tls_type = tls_type;
5239 ent->is_indirect = FALSE;
5240 ent->got.refcount = 0;
5241 local_got_ents[r_symndx] = ent;
5242 }
5243 ent->got.refcount += 1;
5244 }
5245
5246 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5247 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5248 local_got_tls_masks[r_symndx] |= tls_type;
5249
5250 return local_plt + r_symndx;
5251 }
5252
5253 static bfd_boolean
5254 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5255 {
5256 struct plt_entry *ent;
5257
5258 for (ent = *plist; ent != NULL; ent = ent->next)
5259 if (ent->addend == addend)
5260 break;
5261 if (ent == NULL)
5262 {
5263 bfd_size_type amt = sizeof (*ent);
5264 ent = bfd_alloc (abfd, amt);
5265 if (ent == NULL)
5266 return FALSE;
5267 ent->next = *plist;
5268 ent->addend = addend;
5269 ent->plt.refcount = 0;
5270 *plist = ent;
5271 }
5272 ent->plt.refcount += 1;
5273 return TRUE;
5274 }
5275
5276 static bfd_boolean
5277 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5278 {
5279 return (r_type == R_PPC64_REL24
5280 || r_type == R_PPC64_REL14
5281 || r_type == R_PPC64_REL14_BRTAKEN
5282 || r_type == R_PPC64_REL14_BRNTAKEN
5283 || r_type == R_PPC64_ADDR24
5284 || r_type == R_PPC64_ADDR14
5285 || r_type == R_PPC64_ADDR14_BRTAKEN
5286 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5287 }
5288
5289 /* Look through the relocs for a section during the first phase, and
5290 calculate needed space in the global offset table, procedure
5291 linkage table, and dynamic reloc sections. */
5292
5293 static bfd_boolean
5294 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5295 asection *sec, const Elf_Internal_Rela *relocs)
5296 {
5297 struct ppc_link_hash_table *htab;
5298 Elf_Internal_Shdr *symtab_hdr;
5299 struct elf_link_hash_entry **sym_hashes;
5300 const Elf_Internal_Rela *rel;
5301 const Elf_Internal_Rela *rel_end;
5302 asection *sreloc;
5303 asection **opd_sym_map;
5304 struct elf_link_hash_entry *tga, *dottga;
5305
5306 if (bfd_link_relocatable (info))
5307 return TRUE;
5308
5309 /* Don't do anything special with non-loaded, non-alloced sections.
5310 In particular, any relocs in such sections should not affect GOT
5311 and PLT reference counting (ie. we don't allow them to create GOT
5312 or PLT entries), there's no possibility or desire to optimize TLS
5313 relocs, and there's not much point in propagating relocs to shared
5314 libs that the dynamic linker won't relocate. */
5315 if ((sec->flags & SEC_ALLOC) == 0)
5316 return TRUE;
5317
5318 BFD_ASSERT (is_ppc64_elf (abfd));
5319
5320 htab = ppc_hash_table (info);
5321 if (htab == NULL)
5322 return FALSE;
5323
5324 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5325 FALSE, FALSE, TRUE);
5326 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5327 FALSE, FALSE, TRUE);
5328 symtab_hdr = &elf_symtab_hdr (abfd);
5329 sym_hashes = elf_sym_hashes (abfd);
5330 sreloc = NULL;
5331 opd_sym_map = NULL;
5332 if (ppc64_elf_section_data (sec) != NULL
5333 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5334 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5335
5336 rel_end = relocs + sec->reloc_count;
5337 for (rel = relocs; rel < rel_end; rel++)
5338 {
5339 unsigned long r_symndx;
5340 struct elf_link_hash_entry *h;
5341 enum elf_ppc64_reloc_type r_type;
5342 int tls_type;
5343 struct _ppc64_elf_section_data *ppc64_sec;
5344 struct plt_entry **ifunc, **plt_list;
5345
5346 r_symndx = ELF64_R_SYM (rel->r_info);
5347 if (r_symndx < symtab_hdr->sh_info)
5348 h = NULL;
5349 else
5350 {
5351 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5352 h = elf_follow_link (h);
5353
5354 /* PR15323, ref flags aren't set for references in the same
5355 object. */
5356 h->root.non_ir_ref = 1;
5357
5358 if (h == htab->elf.hgot)
5359 sec->has_toc_reloc = 1;
5360 }
5361
5362 tls_type = 0;
5363 ifunc = NULL;
5364 if (h != NULL)
5365 {
5366 if (h->type == STT_GNU_IFUNC)
5367 {
5368 h->needs_plt = 1;
5369 ifunc = &h->plt.plist;
5370 }
5371 }
5372 else
5373 {
5374 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5375 abfd, r_symndx);
5376 if (isym == NULL)
5377 return FALSE;
5378
5379 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5380 {
5381 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5382 rel->r_addend, PLT_IFUNC);
5383 if (ifunc == NULL)
5384 return FALSE;
5385 }
5386 }
5387
5388 r_type = ELF64_R_TYPE (rel->r_info);
5389 switch (r_type)
5390 {
5391 case R_PPC64_TLSGD:
5392 case R_PPC64_TLSLD:
5393 /* These special tls relocs tie a call to __tls_get_addr with
5394 its parameter symbol. */
5395 break;
5396
5397 case R_PPC64_GOT_TLSLD16:
5398 case R_PPC64_GOT_TLSLD16_LO:
5399 case R_PPC64_GOT_TLSLD16_HI:
5400 case R_PPC64_GOT_TLSLD16_HA:
5401 tls_type = TLS_TLS | TLS_LD;
5402 goto dogottls;
5403
5404 case R_PPC64_GOT_TLSGD16:
5405 case R_PPC64_GOT_TLSGD16_LO:
5406 case R_PPC64_GOT_TLSGD16_HI:
5407 case R_PPC64_GOT_TLSGD16_HA:
5408 tls_type = TLS_TLS | TLS_GD;
5409 goto dogottls;
5410
5411 case R_PPC64_GOT_TPREL16_DS:
5412 case R_PPC64_GOT_TPREL16_LO_DS:
5413 case R_PPC64_GOT_TPREL16_HI:
5414 case R_PPC64_GOT_TPREL16_HA:
5415 if (bfd_link_pic (info))
5416 info->flags |= DF_STATIC_TLS;
5417 tls_type = TLS_TLS | TLS_TPREL;
5418 goto dogottls;
5419
5420 case R_PPC64_GOT_DTPREL16_DS:
5421 case R_PPC64_GOT_DTPREL16_LO_DS:
5422 case R_PPC64_GOT_DTPREL16_HI:
5423 case R_PPC64_GOT_DTPREL16_HA:
5424 tls_type = TLS_TLS | TLS_DTPREL;
5425 dogottls:
5426 sec->has_tls_reloc = 1;
5427 /* Fall thru */
5428
5429 case R_PPC64_GOT16:
5430 case R_PPC64_GOT16_DS:
5431 case R_PPC64_GOT16_HA:
5432 case R_PPC64_GOT16_HI:
5433 case R_PPC64_GOT16_LO:
5434 case R_PPC64_GOT16_LO_DS:
5435 /* This symbol requires a global offset table entry. */
5436 sec->has_toc_reloc = 1;
5437 if (r_type == R_PPC64_GOT_TLSLD16
5438 || r_type == R_PPC64_GOT_TLSGD16
5439 || r_type == R_PPC64_GOT_TPREL16_DS
5440 || r_type == R_PPC64_GOT_DTPREL16_DS
5441 || r_type == R_PPC64_GOT16
5442 || r_type == R_PPC64_GOT16_DS)
5443 {
5444 htab->do_multi_toc = 1;
5445 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5446 }
5447
5448 if (ppc64_elf_tdata (abfd)->got == NULL
5449 && !create_got_section (abfd, info))
5450 return FALSE;
5451
5452 if (h != NULL)
5453 {
5454 struct ppc_link_hash_entry *eh;
5455 struct got_entry *ent;
5456
5457 eh = (struct ppc_link_hash_entry *) h;
5458 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5459 if (ent->addend == rel->r_addend
5460 && ent->owner == abfd
5461 && ent->tls_type == tls_type)
5462 break;
5463 if (ent == NULL)
5464 {
5465 bfd_size_type amt = sizeof (*ent);
5466 ent = bfd_alloc (abfd, amt);
5467 if (ent == NULL)
5468 return FALSE;
5469 ent->next = eh->elf.got.glist;
5470 ent->addend = rel->r_addend;
5471 ent->owner = abfd;
5472 ent->tls_type = tls_type;
5473 ent->is_indirect = FALSE;
5474 ent->got.refcount = 0;
5475 eh->elf.got.glist = ent;
5476 }
5477 ent->got.refcount += 1;
5478 eh->tls_mask |= tls_type;
5479 }
5480 else
5481 /* This is a global offset table entry for a local symbol. */
5482 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5483 rel->r_addend, tls_type))
5484 return FALSE;
5485
5486 /* We may also need a plt entry if the symbol turns out to be
5487 an ifunc. */
5488 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5489 {
5490 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5491 return FALSE;
5492 }
5493 break;
5494
5495 case R_PPC64_PLT16_HA:
5496 case R_PPC64_PLT16_HI:
5497 case R_PPC64_PLT16_LO:
5498 case R_PPC64_PLT32:
5499 case R_PPC64_PLT64:
5500 /* This symbol requires a procedure linkage table entry. */
5501 plt_list = ifunc;
5502 if (h != NULL)
5503 {
5504 h->needs_plt = 1;
5505 if (h->root.root.string[0] == '.'
5506 && h->root.root.string[1] != '\0')
5507 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5508 plt_list = &h->plt.plist;
5509 }
5510 if (plt_list == NULL)
5511 {
5512 /* It does not make sense to have a procedure linkage
5513 table entry for a non-ifunc local symbol. */
5514 info->callbacks->einfo
5515 (_("%P: %H: %s reloc against local symbol\n"),
5516 abfd, sec, rel->r_offset,
5517 ppc64_elf_howto_table[r_type]->name);
5518 bfd_set_error (bfd_error_bad_value);
5519 return FALSE;
5520 }
5521 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5522 return FALSE;
5523 break;
5524
5525 /* The following relocations don't need to propagate the
5526 relocation if linking a shared object since they are
5527 section relative. */
5528 case R_PPC64_SECTOFF:
5529 case R_PPC64_SECTOFF_LO:
5530 case R_PPC64_SECTOFF_HI:
5531 case R_PPC64_SECTOFF_HA:
5532 case R_PPC64_SECTOFF_DS:
5533 case R_PPC64_SECTOFF_LO_DS:
5534 case R_PPC64_DTPREL16:
5535 case R_PPC64_DTPREL16_LO:
5536 case R_PPC64_DTPREL16_HI:
5537 case R_PPC64_DTPREL16_HA:
5538 case R_PPC64_DTPREL16_DS:
5539 case R_PPC64_DTPREL16_LO_DS:
5540 case R_PPC64_DTPREL16_HIGH:
5541 case R_PPC64_DTPREL16_HIGHA:
5542 case R_PPC64_DTPREL16_HIGHER:
5543 case R_PPC64_DTPREL16_HIGHERA:
5544 case R_PPC64_DTPREL16_HIGHEST:
5545 case R_PPC64_DTPREL16_HIGHESTA:
5546 break;
5547
5548 /* Nor do these. */
5549 case R_PPC64_REL16:
5550 case R_PPC64_REL16_LO:
5551 case R_PPC64_REL16_HI:
5552 case R_PPC64_REL16_HA:
5553 case R_PPC64_REL16DX_HA:
5554 break;
5555
5556 /* Not supported as a dynamic relocation. */
5557 case R_PPC64_ADDR64_LOCAL:
5558 if (bfd_link_pic (info))
5559 {
5560 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5561 ppc_howto_init ();
5562 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5563 "in shared libraries and PIEs.\n"),
5564 abfd, sec, rel->r_offset,
5565 ppc64_elf_howto_table[r_type]->name);
5566 bfd_set_error (bfd_error_bad_value);
5567 return FALSE;
5568 }
5569 break;
5570
5571 case R_PPC64_TOC16:
5572 case R_PPC64_TOC16_DS:
5573 htab->do_multi_toc = 1;
5574 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5575 case R_PPC64_TOC16_LO:
5576 case R_PPC64_TOC16_HI:
5577 case R_PPC64_TOC16_HA:
5578 case R_PPC64_TOC16_LO_DS:
5579 sec->has_toc_reloc = 1;
5580 break;
5581
5582 /* Marker reloc. */
5583 case R_PPC64_ENTRY:
5584 break;
5585
5586 /* This relocation describes the C++ object vtable hierarchy.
5587 Reconstruct it for later use during GC. */
5588 case R_PPC64_GNU_VTINHERIT:
5589 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5590 return FALSE;
5591 break;
5592
5593 /* This relocation describes which C++ vtable entries are actually
5594 used. Record for later use during GC. */
5595 case R_PPC64_GNU_VTENTRY:
5596 BFD_ASSERT (h != NULL);
5597 if (h != NULL
5598 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5599 return FALSE;
5600 break;
5601
5602 case R_PPC64_REL14:
5603 case R_PPC64_REL14_BRTAKEN:
5604 case R_PPC64_REL14_BRNTAKEN:
5605 {
5606 asection *dest = NULL;
5607
5608 /* Heuristic: If jumping outside our section, chances are
5609 we are going to need a stub. */
5610 if (h != NULL)
5611 {
5612 /* If the sym is weak it may be overridden later, so
5613 don't assume we know where a weak sym lives. */
5614 if (h->root.type == bfd_link_hash_defined)
5615 dest = h->root.u.def.section;
5616 }
5617 else
5618 {
5619 Elf_Internal_Sym *isym;
5620
5621 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5622 abfd, r_symndx);
5623 if (isym == NULL)
5624 return FALSE;
5625
5626 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5627 }
5628
5629 if (dest != sec)
5630 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5631 }
5632 /* Fall through. */
5633
5634 case R_PPC64_REL24:
5635 plt_list = ifunc;
5636 if (h != NULL)
5637 {
5638 h->needs_plt = 1;
5639 if (h->root.root.string[0] == '.'
5640 && h->root.root.string[1] != '\0')
5641 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5642
5643 if (h == tga || h == dottga)
5644 {
5645 sec->has_tls_reloc = 1;
5646 if (rel != relocs
5647 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5648 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5649 /* We have a new-style __tls_get_addr call with
5650 a marker reloc. */
5651 ;
5652 else
5653 /* Mark this section as having an old-style call. */
5654 sec->has_tls_get_addr_call = 1;
5655 }
5656 plt_list = &h->plt.plist;
5657 }
5658
5659 /* We may need a .plt entry if the function this reloc
5660 refers to is in a shared lib. */
5661 if (plt_list
5662 && !update_plt_info (abfd, plt_list, rel->r_addend))
5663 return FALSE;
5664 break;
5665
5666 case R_PPC64_ADDR14:
5667 case R_PPC64_ADDR14_BRNTAKEN:
5668 case R_PPC64_ADDR14_BRTAKEN:
5669 case R_PPC64_ADDR24:
5670 goto dodyn;
5671
5672 case R_PPC64_TPREL64:
5673 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5674 if (bfd_link_pic (info))
5675 info->flags |= DF_STATIC_TLS;
5676 goto dotlstoc;
5677
5678 case R_PPC64_DTPMOD64:
5679 if (rel + 1 < rel_end
5680 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5681 && rel[1].r_offset == rel->r_offset + 8)
5682 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5683 else
5684 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5685 goto dotlstoc;
5686
5687 case R_PPC64_DTPREL64:
5688 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5689 if (rel != relocs
5690 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5691 && rel[-1].r_offset == rel->r_offset - 8)
5692 /* This is the second reloc of a dtpmod, dtprel pair.
5693 Don't mark with TLS_DTPREL. */
5694 goto dodyn;
5695
5696 dotlstoc:
5697 sec->has_tls_reloc = 1;
5698 if (h != NULL)
5699 {
5700 struct ppc_link_hash_entry *eh;
5701 eh = (struct ppc_link_hash_entry *) h;
5702 eh->tls_mask |= tls_type;
5703 }
5704 else
5705 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5706 rel->r_addend, tls_type))
5707 return FALSE;
5708
5709 ppc64_sec = ppc64_elf_section_data (sec);
5710 if (ppc64_sec->sec_type != sec_toc)
5711 {
5712 bfd_size_type amt;
5713
5714 /* One extra to simplify get_tls_mask. */
5715 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5716 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5717 if (ppc64_sec->u.toc.symndx == NULL)
5718 return FALSE;
5719 amt = sec->size * sizeof (bfd_vma) / 8;
5720 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5721 if (ppc64_sec->u.toc.add == NULL)
5722 return FALSE;
5723 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5724 ppc64_sec->sec_type = sec_toc;
5725 }
5726 BFD_ASSERT (rel->r_offset % 8 == 0);
5727 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5728 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5729
5730 /* Mark the second slot of a GD or LD entry.
5731 -1 to indicate GD and -2 to indicate LD. */
5732 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5733 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5734 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5735 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5736 goto dodyn;
5737
5738 case R_PPC64_TPREL16:
5739 case R_PPC64_TPREL16_LO:
5740 case R_PPC64_TPREL16_HI:
5741 case R_PPC64_TPREL16_HA:
5742 case R_PPC64_TPREL16_DS:
5743 case R_PPC64_TPREL16_LO_DS:
5744 case R_PPC64_TPREL16_HIGH:
5745 case R_PPC64_TPREL16_HIGHA:
5746 case R_PPC64_TPREL16_HIGHER:
5747 case R_PPC64_TPREL16_HIGHERA:
5748 case R_PPC64_TPREL16_HIGHEST:
5749 case R_PPC64_TPREL16_HIGHESTA:
5750 if (bfd_link_pic (info))
5751 {
5752 info->flags |= DF_STATIC_TLS;
5753 goto dodyn;
5754 }
5755 break;
5756
5757 case R_PPC64_ADDR64:
5758 if (opd_sym_map != NULL
5759 && rel + 1 < rel_end
5760 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5761 {
5762 if (h != NULL)
5763 {
5764 if (h->root.root.string[0] == '.'
5765 && h->root.root.string[1] != 0
5766 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5767 ;
5768 else
5769 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5770 }
5771 else
5772 {
5773 asection *s;
5774 Elf_Internal_Sym *isym;
5775
5776 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5777 abfd, r_symndx);
5778 if (isym == NULL)
5779 return FALSE;
5780
5781 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5782 if (s != NULL && s != sec)
5783 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5784 }
5785 }
5786 /* Fall through. */
5787
5788 case R_PPC64_ADDR16:
5789 case R_PPC64_ADDR16_DS:
5790 case R_PPC64_ADDR16_HA:
5791 case R_PPC64_ADDR16_HI:
5792 case R_PPC64_ADDR16_HIGH:
5793 case R_PPC64_ADDR16_HIGHA:
5794 case R_PPC64_ADDR16_HIGHER:
5795 case R_PPC64_ADDR16_HIGHERA:
5796 case R_PPC64_ADDR16_HIGHEST:
5797 case R_PPC64_ADDR16_HIGHESTA:
5798 case R_PPC64_ADDR16_LO:
5799 case R_PPC64_ADDR16_LO_DS:
5800 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5801 && rel->r_addend == 0)
5802 {
5803 /* We may need a .plt entry if this reloc refers to a
5804 function in a shared lib. */
5805 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5806 return FALSE;
5807 h->pointer_equality_needed = 1;
5808 }
5809 /* Fall through. */
5810
5811 case R_PPC64_REL30:
5812 case R_PPC64_REL32:
5813 case R_PPC64_REL64:
5814 case R_PPC64_ADDR32:
5815 case R_PPC64_UADDR16:
5816 case R_PPC64_UADDR32:
5817 case R_PPC64_UADDR64:
5818 case R_PPC64_TOC:
5819 if (h != NULL && !bfd_link_pic (info))
5820 /* We may need a copy reloc. */
5821 h->non_got_ref = 1;
5822
5823 /* Don't propagate .opd relocs. */
5824 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5825 break;
5826
5827 /* If we are creating a shared library, and this is a reloc
5828 against a global symbol, or a non PC relative reloc
5829 against a local symbol, then we need to copy the reloc
5830 into the shared library. However, if we are linking with
5831 -Bsymbolic, we do not need to copy a reloc against a
5832 global symbol which is defined in an object we are
5833 including in the link (i.e., DEF_REGULAR is set). At
5834 this point we have not seen all the input files, so it is
5835 possible that DEF_REGULAR is not set now but will be set
5836 later (it is never cleared). In case of a weak definition,
5837 DEF_REGULAR may be cleared later by a strong definition in
5838 a shared library. We account for that possibility below by
5839 storing information in the dyn_relocs field of the hash
5840 table entry. A similar situation occurs when creating
5841 shared libraries and symbol visibility changes render the
5842 symbol local.
5843
5844 If on the other hand, we are creating an executable, we
5845 may need to keep relocations for symbols satisfied by a
5846 dynamic library if we manage to avoid copy relocs for the
5847 symbol. */
5848 dodyn:
5849 if ((bfd_link_pic (info)
5850 && (must_be_dyn_reloc (info, r_type)
5851 || (h != NULL
5852 && (!SYMBOLIC_BIND (info, h)
5853 || h->root.type == bfd_link_hash_defweak
5854 || !h->def_regular))))
5855 || (ELIMINATE_COPY_RELOCS
5856 && !bfd_link_pic (info)
5857 && h != NULL
5858 && (h->root.type == bfd_link_hash_defweak
5859 || !h->def_regular))
5860 || (!bfd_link_pic (info)
5861 && ifunc != NULL))
5862 {
5863 /* We must copy these reloc types into the output file.
5864 Create a reloc section in dynobj and make room for
5865 this reloc. */
5866 if (sreloc == NULL)
5867 {
5868 sreloc = _bfd_elf_make_dynamic_reloc_section
5869 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5870
5871 if (sreloc == NULL)
5872 return FALSE;
5873 }
5874
5875 /* If this is a global symbol, we count the number of
5876 relocations we need for this symbol. */
5877 if (h != NULL)
5878 {
5879 struct elf_dyn_relocs *p;
5880 struct elf_dyn_relocs **head;
5881
5882 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5883 p = *head;
5884 if (p == NULL || p->sec != sec)
5885 {
5886 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5887 if (p == NULL)
5888 return FALSE;
5889 p->next = *head;
5890 *head = p;
5891 p->sec = sec;
5892 p->count = 0;
5893 p->pc_count = 0;
5894 }
5895 p->count += 1;
5896 if (!must_be_dyn_reloc (info, r_type))
5897 p->pc_count += 1;
5898 }
5899 else
5900 {
5901 /* Track dynamic relocs needed for local syms too.
5902 We really need local syms available to do this
5903 easily. Oh well. */
5904 struct ppc_dyn_relocs *p;
5905 struct ppc_dyn_relocs **head;
5906 bfd_boolean is_ifunc;
5907 asection *s;
5908 void *vpp;
5909 Elf_Internal_Sym *isym;
5910
5911 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5912 abfd, r_symndx);
5913 if (isym == NULL)
5914 return FALSE;
5915
5916 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5917 if (s == NULL)
5918 s = sec;
5919
5920 vpp = &elf_section_data (s)->local_dynrel;
5921 head = (struct ppc_dyn_relocs **) vpp;
5922 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5923 p = *head;
5924 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5925 p = p->next;
5926 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5927 {
5928 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5929 if (p == NULL)
5930 return FALSE;
5931 p->next = *head;
5932 *head = p;
5933 p->sec = sec;
5934 p->ifunc = is_ifunc;
5935 p->count = 0;
5936 }
5937 p->count += 1;
5938 }
5939 }
5940 break;
5941
5942 default:
5943 break;
5944 }
5945 }
5946
5947 return TRUE;
5948 }
5949
5950 /* Merge backend specific data from an object file to the output
5951 object file when linking. */
5952
5953 static bfd_boolean
5954 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5955 {
5956 unsigned long iflags, oflags;
5957
5958 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5959 return TRUE;
5960
5961 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5962 return TRUE;
5963
5964 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5965 return FALSE;
5966
5967 iflags = elf_elfheader (ibfd)->e_flags;
5968 oflags = elf_elfheader (obfd)->e_flags;
5969
5970 if (iflags & ~EF_PPC64_ABI)
5971 {
5972 (*_bfd_error_handler)
5973 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5974 bfd_set_error (bfd_error_bad_value);
5975 return FALSE;
5976 }
5977 else if (iflags != oflags && iflags != 0)
5978 {
5979 (*_bfd_error_handler)
5980 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5981 ibfd, iflags, oflags);
5982 bfd_set_error (bfd_error_bad_value);
5983 return FALSE;
5984 }
5985
5986 /* Merge Tag_compatibility attributes and any common GNU ones. */
5987 _bfd_elf_merge_object_attributes (ibfd, obfd);
5988
5989 return TRUE;
5990 }
5991
5992 static bfd_boolean
5993 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5994 {
5995 /* Print normal ELF private data. */
5996 _bfd_elf_print_private_bfd_data (abfd, ptr);
5997
5998 if (elf_elfheader (abfd)->e_flags != 0)
5999 {
6000 FILE *file = ptr;
6001
6002 /* xgettext:c-format */
6003 fprintf (file, _("private flags = 0x%lx:"),
6004 elf_elfheader (abfd)->e_flags);
6005
6006 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6007 fprintf (file, _(" [abiv%ld]"),
6008 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6009 fputc ('\n', file);
6010 }
6011
6012 return TRUE;
6013 }
6014
6015 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6016 of the code entry point, and its section, which must be in the same
6017 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6018
6019 static bfd_vma
6020 opd_entry_value (asection *opd_sec,
6021 bfd_vma offset,
6022 asection **code_sec,
6023 bfd_vma *code_off,
6024 bfd_boolean in_code_sec)
6025 {
6026 bfd *opd_bfd = opd_sec->owner;
6027 Elf_Internal_Rela *relocs;
6028 Elf_Internal_Rela *lo, *hi, *look;
6029 bfd_vma val;
6030
6031 /* No relocs implies we are linking a --just-symbols object, or looking
6032 at a final linked executable with addr2line or somesuch. */
6033 if (opd_sec->reloc_count == 0)
6034 {
6035 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6036
6037 if (contents == NULL)
6038 {
6039 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6040 return (bfd_vma) -1;
6041 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6042 }
6043
6044 /* PR 17512: file: 64b9dfbb. */
6045 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6046 return (bfd_vma) -1;
6047
6048 val = bfd_get_64 (opd_bfd, contents + offset);
6049 if (code_sec != NULL)
6050 {
6051 asection *sec, *likely = NULL;
6052
6053 if (in_code_sec)
6054 {
6055 sec = *code_sec;
6056 if (sec->vma <= val
6057 && val < sec->vma + sec->size)
6058 likely = sec;
6059 else
6060 val = -1;
6061 }
6062 else
6063 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6064 if (sec->vma <= val
6065 && (sec->flags & SEC_LOAD) != 0
6066 && (sec->flags & SEC_ALLOC) != 0)
6067 likely = sec;
6068 if (likely != NULL)
6069 {
6070 *code_sec = likely;
6071 if (code_off != NULL)
6072 *code_off = val - likely->vma;
6073 }
6074 }
6075 return val;
6076 }
6077
6078 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6079
6080 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6081 if (relocs == NULL)
6082 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6083 /* PR 17512: file: df8e1fd6. */
6084 if (relocs == NULL)
6085 return (bfd_vma) -1;
6086
6087 /* Go find the opd reloc at the sym address. */
6088 lo = relocs;
6089 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6090 val = (bfd_vma) -1;
6091 while (lo < hi)
6092 {
6093 look = lo + (hi - lo) / 2;
6094 if (look->r_offset < offset)
6095 lo = look + 1;
6096 else if (look->r_offset > offset)
6097 hi = look;
6098 else
6099 {
6100 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6101
6102 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6103 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6104 {
6105 unsigned long symndx = ELF64_R_SYM (look->r_info);
6106 asection *sec = NULL;
6107
6108 if (symndx >= symtab_hdr->sh_info
6109 && elf_sym_hashes (opd_bfd) != NULL)
6110 {
6111 struct elf_link_hash_entry **sym_hashes;
6112 struct elf_link_hash_entry *rh;
6113
6114 sym_hashes = elf_sym_hashes (opd_bfd);
6115 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6116 if (rh != NULL)
6117 {
6118 rh = elf_follow_link (rh);
6119 if (rh->root.type != bfd_link_hash_defined
6120 && rh->root.type != bfd_link_hash_defweak)
6121 break;
6122 if (rh->root.u.def.section->owner == opd_bfd)
6123 {
6124 val = rh->root.u.def.value;
6125 sec = rh->root.u.def.section;
6126 }
6127 }
6128 }
6129
6130 if (sec == NULL)
6131 {
6132 Elf_Internal_Sym *sym;
6133
6134 if (symndx < symtab_hdr->sh_info)
6135 {
6136 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6137 if (sym == NULL)
6138 {
6139 size_t symcnt = symtab_hdr->sh_info;
6140 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6141 symcnt, 0,
6142 NULL, NULL, NULL);
6143 if (sym == NULL)
6144 break;
6145 symtab_hdr->contents = (bfd_byte *) sym;
6146 }
6147 sym += symndx;
6148 }
6149 else
6150 {
6151 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6152 1, symndx,
6153 NULL, NULL, NULL);
6154 if (sym == NULL)
6155 break;
6156 }
6157 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6158 if (sec == NULL)
6159 break;
6160 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6161 val = sym->st_value;
6162 }
6163
6164 val += look->r_addend;
6165 if (code_off != NULL)
6166 *code_off = val;
6167 if (code_sec != NULL)
6168 {
6169 if (in_code_sec && *code_sec != sec)
6170 return -1;
6171 else
6172 *code_sec = sec;
6173 }
6174 if (sec->output_section != NULL)
6175 val += sec->output_section->vma + sec->output_offset;
6176 }
6177 break;
6178 }
6179 }
6180
6181 return val;
6182 }
6183
6184 /* If the ELF symbol SYM might be a function in SEC, return the
6185 function size and set *CODE_OFF to the function's entry point,
6186 otherwise return zero. */
6187
6188 static bfd_size_type
6189 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6190 bfd_vma *code_off)
6191 {
6192 bfd_size_type size;
6193
6194 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6195 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6196 return 0;
6197
6198 size = 0;
6199 if (!(sym->flags & BSF_SYNTHETIC))
6200 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6201
6202 if (strcmp (sym->section->name, ".opd") == 0)
6203 {
6204 struct _opd_sec_data *opd = get_opd_info (sym->section);
6205 bfd_vma symval = sym->value;
6206
6207 if (opd != NULL
6208 && opd->adjust != NULL
6209 && elf_section_data (sym->section)->relocs != NULL)
6210 {
6211 /* opd_entry_value will use cached relocs that have been
6212 adjusted, but with raw symbols. That means both local
6213 and global symbols need adjusting. */
6214 long adjust = opd->adjust[OPD_NDX (symval)];
6215 if (adjust == -1)
6216 return 0;
6217 symval += adjust;
6218 }
6219
6220 if (opd_entry_value (sym->section, symval,
6221 &sec, code_off, TRUE) == (bfd_vma) -1)
6222 return 0;
6223 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6224 symbol. This size has nothing to do with the code size of the
6225 function, which is what we're supposed to return, but the
6226 code size isn't available without looking up the dot-sym.
6227 However, doing that would be a waste of time particularly
6228 since elf_find_function will look at the dot-sym anyway.
6229 Now, elf_find_function will keep the largest size of any
6230 function sym found at the code address of interest, so return
6231 1 here to avoid it incorrectly caching a larger function size
6232 for a small function. This does mean we return the wrong
6233 size for a new-ABI function of size 24, but all that does is
6234 disable caching for such functions. */
6235 if (size == 24)
6236 size = 1;
6237 }
6238 else
6239 {
6240 if (sym->section != sec)
6241 return 0;
6242 *code_off = sym->value;
6243 }
6244 if (size == 0)
6245 size = 1;
6246 return size;
6247 }
6248
6249 /* Return true if symbol is defined in a regular object file. */
6250
6251 static bfd_boolean
6252 is_static_defined (struct elf_link_hash_entry *h)
6253 {
6254 return ((h->root.type == bfd_link_hash_defined
6255 || h->root.type == bfd_link_hash_defweak)
6256 && h->root.u.def.section != NULL
6257 && h->root.u.def.section->output_section != NULL);
6258 }
6259
6260 /* If FDH is a function descriptor symbol, return the associated code
6261 entry symbol if it is defined. Return NULL otherwise. */
6262
6263 static struct ppc_link_hash_entry *
6264 defined_code_entry (struct ppc_link_hash_entry *fdh)
6265 {
6266 if (fdh->is_func_descriptor)
6267 {
6268 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6269 if (fh->elf.root.type == bfd_link_hash_defined
6270 || fh->elf.root.type == bfd_link_hash_defweak)
6271 return fh;
6272 }
6273 return NULL;
6274 }
6275
6276 /* If FH is a function code entry symbol, return the associated
6277 function descriptor symbol if it is defined. Return NULL otherwise. */
6278
6279 static struct ppc_link_hash_entry *
6280 defined_func_desc (struct ppc_link_hash_entry *fh)
6281 {
6282 if (fh->oh != NULL
6283 && fh->oh->is_func_descriptor)
6284 {
6285 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6286 if (fdh->elf.root.type == bfd_link_hash_defined
6287 || fdh->elf.root.type == bfd_link_hash_defweak)
6288 return fdh;
6289 }
6290 return NULL;
6291 }
6292
6293 /* Mark all our entry sym sections, both opd and code section. */
6294
6295 static void
6296 ppc64_elf_gc_keep (struct bfd_link_info *info)
6297 {
6298 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6299 struct bfd_sym_chain *sym;
6300
6301 if (htab == NULL)
6302 return;
6303
6304 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6305 {
6306 struct ppc_link_hash_entry *eh, *fh;
6307 asection *sec;
6308
6309 eh = (struct ppc_link_hash_entry *)
6310 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6311 if (eh == NULL)
6312 continue;
6313 if (eh->elf.root.type != bfd_link_hash_defined
6314 && eh->elf.root.type != bfd_link_hash_defweak)
6315 continue;
6316
6317 fh = defined_code_entry (eh);
6318 if (fh != NULL)
6319 {
6320 sec = fh->elf.root.u.def.section;
6321 sec->flags |= SEC_KEEP;
6322 }
6323 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6324 && opd_entry_value (eh->elf.root.u.def.section,
6325 eh->elf.root.u.def.value,
6326 &sec, NULL, FALSE) != (bfd_vma) -1)
6327 sec->flags |= SEC_KEEP;
6328
6329 sec = eh->elf.root.u.def.section;
6330 sec->flags |= SEC_KEEP;
6331 }
6332 }
6333
6334 /* Mark sections containing dynamically referenced symbols. When
6335 building shared libraries, we must assume that any visible symbol is
6336 referenced. */
6337
6338 static bfd_boolean
6339 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6340 {
6341 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6342 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6343 struct ppc_link_hash_entry *fdh;
6344 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6345
6346 /* Dynamic linking info is on the func descriptor sym. */
6347 fdh = defined_func_desc (eh);
6348 if (fdh != NULL)
6349 eh = fdh;
6350
6351 if ((eh->elf.root.type == bfd_link_hash_defined
6352 || eh->elf.root.type == bfd_link_hash_defweak)
6353 && (eh->elf.ref_dynamic
6354 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6355 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6356 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6357 && (!bfd_link_executable (info)
6358 || info->export_dynamic
6359 || (eh->elf.dynamic
6360 && d != NULL
6361 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6362 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6363 || !bfd_hide_sym_by_version (info->version_info,
6364 eh->elf.root.root.string)))))
6365 {
6366 asection *code_sec;
6367 struct ppc_link_hash_entry *fh;
6368
6369 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6370
6371 /* Function descriptor syms cause the associated
6372 function code sym section to be marked. */
6373 fh = defined_code_entry (eh);
6374 if (fh != NULL)
6375 {
6376 code_sec = fh->elf.root.u.def.section;
6377 code_sec->flags |= SEC_KEEP;
6378 }
6379 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6380 && opd_entry_value (eh->elf.root.u.def.section,
6381 eh->elf.root.u.def.value,
6382 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6383 code_sec->flags |= SEC_KEEP;
6384 }
6385
6386 return TRUE;
6387 }
6388
6389 /* Return the section that should be marked against GC for a given
6390 relocation. */
6391
6392 static asection *
6393 ppc64_elf_gc_mark_hook (asection *sec,
6394 struct bfd_link_info *info,
6395 Elf_Internal_Rela *rel,
6396 struct elf_link_hash_entry *h,
6397 Elf_Internal_Sym *sym)
6398 {
6399 asection *rsec;
6400
6401 /* Syms return NULL if we're marking .opd, so we avoid marking all
6402 function sections, as all functions are referenced in .opd. */
6403 rsec = NULL;
6404 if (get_opd_info (sec) != NULL)
6405 return rsec;
6406
6407 if (h != NULL)
6408 {
6409 enum elf_ppc64_reloc_type r_type;
6410 struct ppc_link_hash_entry *eh, *fh, *fdh;
6411
6412 r_type = ELF64_R_TYPE (rel->r_info);
6413 switch (r_type)
6414 {
6415 case R_PPC64_GNU_VTINHERIT:
6416 case R_PPC64_GNU_VTENTRY:
6417 break;
6418
6419 default:
6420 switch (h->root.type)
6421 {
6422 case bfd_link_hash_defined:
6423 case bfd_link_hash_defweak:
6424 eh = (struct ppc_link_hash_entry *) h;
6425 fdh = defined_func_desc (eh);
6426 if (fdh != NULL)
6427 eh = fdh;
6428
6429 /* Function descriptor syms cause the associated
6430 function code sym section to be marked. */
6431 fh = defined_code_entry (eh);
6432 if (fh != NULL)
6433 {
6434 /* They also mark their opd section. */
6435 eh->elf.root.u.def.section->gc_mark = 1;
6436
6437 rsec = fh->elf.root.u.def.section;
6438 }
6439 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6440 && opd_entry_value (eh->elf.root.u.def.section,
6441 eh->elf.root.u.def.value,
6442 &rsec, NULL, FALSE) != (bfd_vma) -1)
6443 eh->elf.root.u.def.section->gc_mark = 1;
6444 else
6445 rsec = h->root.u.def.section;
6446 break;
6447
6448 case bfd_link_hash_common:
6449 rsec = h->root.u.c.p->section;
6450 break;
6451
6452 default:
6453 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6454 }
6455 }
6456 }
6457 else
6458 {
6459 struct _opd_sec_data *opd;
6460
6461 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6462 opd = get_opd_info (rsec);
6463 if (opd != NULL && opd->func_sec != NULL)
6464 {
6465 rsec->gc_mark = 1;
6466
6467 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6468 }
6469 }
6470
6471 return rsec;
6472 }
6473
6474 /* Update the .got, .plt. and dynamic reloc reference counts for the
6475 section being removed. */
6476
6477 static bfd_boolean
6478 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6479 asection *sec, const Elf_Internal_Rela *relocs)
6480 {
6481 struct ppc_link_hash_table *htab;
6482 Elf_Internal_Shdr *symtab_hdr;
6483 struct elf_link_hash_entry **sym_hashes;
6484 struct got_entry **local_got_ents;
6485 const Elf_Internal_Rela *rel, *relend;
6486
6487 if (bfd_link_relocatable (info))
6488 return TRUE;
6489
6490 if ((sec->flags & SEC_ALLOC) == 0)
6491 return TRUE;
6492
6493 elf_section_data (sec)->local_dynrel = NULL;
6494
6495 htab = ppc_hash_table (info);
6496 if (htab == NULL)
6497 return FALSE;
6498
6499 symtab_hdr = &elf_symtab_hdr (abfd);
6500 sym_hashes = elf_sym_hashes (abfd);
6501 local_got_ents = elf_local_got_ents (abfd);
6502
6503 relend = relocs + sec->reloc_count;
6504 for (rel = relocs; rel < relend; rel++)
6505 {
6506 unsigned long r_symndx;
6507 enum elf_ppc64_reloc_type r_type;
6508 struct elf_link_hash_entry *h = NULL;
6509 struct plt_entry **plt_list;
6510 unsigned char tls_type = 0;
6511
6512 r_symndx = ELF64_R_SYM (rel->r_info);
6513 r_type = ELF64_R_TYPE (rel->r_info);
6514 if (r_symndx >= symtab_hdr->sh_info)
6515 {
6516 struct ppc_link_hash_entry *eh;
6517 struct elf_dyn_relocs **pp;
6518 struct elf_dyn_relocs *p;
6519
6520 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6521 h = elf_follow_link (h);
6522 eh = (struct ppc_link_hash_entry *) h;
6523
6524 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6525 if (p->sec == sec)
6526 {
6527 /* Everything must go for SEC. */
6528 *pp = p->next;
6529 break;
6530 }
6531 }
6532
6533 switch (r_type)
6534 {
6535 case R_PPC64_GOT_TLSLD16:
6536 case R_PPC64_GOT_TLSLD16_LO:
6537 case R_PPC64_GOT_TLSLD16_HI:
6538 case R_PPC64_GOT_TLSLD16_HA:
6539 tls_type = TLS_TLS | TLS_LD;
6540 goto dogot;
6541
6542 case R_PPC64_GOT_TLSGD16:
6543 case R_PPC64_GOT_TLSGD16_LO:
6544 case R_PPC64_GOT_TLSGD16_HI:
6545 case R_PPC64_GOT_TLSGD16_HA:
6546 tls_type = TLS_TLS | TLS_GD;
6547 goto dogot;
6548
6549 case R_PPC64_GOT_TPREL16_DS:
6550 case R_PPC64_GOT_TPREL16_LO_DS:
6551 case R_PPC64_GOT_TPREL16_HI:
6552 case R_PPC64_GOT_TPREL16_HA:
6553 tls_type = TLS_TLS | TLS_TPREL;
6554 goto dogot;
6555
6556 case R_PPC64_GOT_DTPREL16_DS:
6557 case R_PPC64_GOT_DTPREL16_LO_DS:
6558 case R_PPC64_GOT_DTPREL16_HI:
6559 case R_PPC64_GOT_DTPREL16_HA:
6560 tls_type = TLS_TLS | TLS_DTPREL;
6561 goto dogot;
6562
6563 case R_PPC64_GOT16:
6564 case R_PPC64_GOT16_DS:
6565 case R_PPC64_GOT16_HA:
6566 case R_PPC64_GOT16_HI:
6567 case R_PPC64_GOT16_LO:
6568 case R_PPC64_GOT16_LO_DS:
6569 dogot:
6570 {
6571 struct got_entry *ent;
6572
6573 if (h != NULL)
6574 ent = h->got.glist;
6575 else
6576 ent = local_got_ents[r_symndx];
6577
6578 for (; ent != NULL; ent = ent->next)
6579 if (ent->addend == rel->r_addend
6580 && ent->owner == abfd
6581 && ent->tls_type == tls_type)
6582 break;
6583 if (ent == NULL)
6584 abort ();
6585 if (ent->got.refcount > 0)
6586 ent->got.refcount -= 1;
6587 }
6588 break;
6589
6590 case R_PPC64_PLT16_HA:
6591 case R_PPC64_PLT16_HI:
6592 case R_PPC64_PLT16_LO:
6593 case R_PPC64_PLT32:
6594 case R_PPC64_PLT64:
6595 case R_PPC64_REL14:
6596 case R_PPC64_REL14_BRNTAKEN:
6597 case R_PPC64_REL14_BRTAKEN:
6598 case R_PPC64_REL24:
6599 plt_list = NULL;
6600 if (h != NULL)
6601 plt_list = &h->plt.plist;
6602 else if (local_got_ents != NULL)
6603 {
6604 struct plt_entry **local_plt = (struct plt_entry **)
6605 (local_got_ents + symtab_hdr->sh_info);
6606 unsigned char *local_got_tls_masks = (unsigned char *)
6607 (local_plt + symtab_hdr->sh_info);
6608 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6609 plt_list = local_plt + r_symndx;
6610 }
6611 if (plt_list)
6612 {
6613 struct plt_entry *ent;
6614
6615 for (ent = *plt_list; ent != NULL; ent = ent->next)
6616 if (ent->addend == rel->r_addend)
6617 break;
6618 if (ent != NULL && ent->plt.refcount > 0)
6619 ent->plt.refcount -= 1;
6620 }
6621 break;
6622
6623 default:
6624 break;
6625 }
6626 }
6627 return TRUE;
6628 }
6629
6630 /* The maximum size of .sfpr. */
6631 #define SFPR_MAX (218*4)
6632
6633 struct sfpr_def_parms
6634 {
6635 const char name[12];
6636 unsigned char lo, hi;
6637 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6638 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6639 };
6640
6641 /* Auto-generate _save*, _rest* functions in .sfpr.
6642 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6643 instead. */
6644
6645 static bfd_boolean
6646 sfpr_define (struct bfd_link_info *info,
6647 const struct sfpr_def_parms *parm,
6648 asection *stub_sec)
6649 {
6650 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6651 unsigned int i;
6652 size_t len = strlen (parm->name);
6653 bfd_boolean writing = FALSE;
6654 char sym[16];
6655
6656 if (htab == NULL)
6657 return FALSE;
6658
6659 memcpy (sym, parm->name, len);
6660 sym[len + 2] = 0;
6661
6662 for (i = parm->lo; i <= parm->hi; i++)
6663 {
6664 struct ppc_link_hash_entry *h;
6665
6666 sym[len + 0] = i / 10 + '0';
6667 sym[len + 1] = i % 10 + '0';
6668 h = (struct ppc_link_hash_entry *)
6669 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6670 if (stub_sec != NULL)
6671 {
6672 if (h != NULL
6673 && h->elf.root.type == bfd_link_hash_defined
6674 && h->elf.root.u.def.section == htab->sfpr)
6675 {
6676 struct elf_link_hash_entry *s;
6677 char buf[32];
6678 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6679 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6680 if (s == NULL)
6681 return FALSE;
6682 if (s->root.type == bfd_link_hash_new
6683 || (s->root.type = bfd_link_hash_defined
6684 && s->root.u.def.section == stub_sec))
6685 {
6686 s->root.type = bfd_link_hash_defined;
6687 s->root.u.def.section = stub_sec;
6688 s->root.u.def.value = (stub_sec->size
6689 + h->elf.root.u.def.value);
6690 s->ref_regular = 1;
6691 s->def_regular = 1;
6692 s->ref_regular_nonweak = 1;
6693 s->forced_local = 1;
6694 s->non_elf = 0;
6695 s->root.linker_def = 1;
6696 }
6697 }
6698 continue;
6699 }
6700 if (h != NULL)
6701 {
6702 h->save_res = 1;
6703 if (!h->elf.def_regular)
6704 {
6705 h->elf.root.type = bfd_link_hash_defined;
6706 h->elf.root.u.def.section = htab->sfpr;
6707 h->elf.root.u.def.value = htab->sfpr->size;
6708 h->elf.type = STT_FUNC;
6709 h->elf.def_regular = 1;
6710 h->elf.non_elf = 0;
6711 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6712 writing = TRUE;
6713 if (htab->sfpr->contents == NULL)
6714 {
6715 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6716 if (htab->sfpr->contents == NULL)
6717 return FALSE;
6718 }
6719 }
6720 }
6721 if (writing)
6722 {
6723 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6724 if (i != parm->hi)
6725 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6726 else
6727 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6728 htab->sfpr->size = p - htab->sfpr->contents;
6729 }
6730 }
6731
6732 return TRUE;
6733 }
6734
6735 static bfd_byte *
6736 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6737 {
6738 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6739 return p + 4;
6740 }
6741
6742 static bfd_byte *
6743 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6744 {
6745 p = savegpr0 (abfd, p, r);
6746 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6747 p = p + 4;
6748 bfd_put_32 (abfd, BLR, p);
6749 return p + 4;
6750 }
6751
6752 static bfd_byte *
6753 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6754 {
6755 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6756 return p + 4;
6757 }
6758
6759 static bfd_byte *
6760 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6761 {
6762 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6763 p = p + 4;
6764 p = restgpr0 (abfd, p, r);
6765 bfd_put_32 (abfd, MTLR_R0, p);
6766 p = p + 4;
6767 if (r == 29)
6768 {
6769 p = restgpr0 (abfd, p, 30);
6770 p = restgpr0 (abfd, p, 31);
6771 }
6772 bfd_put_32 (abfd, BLR, p);
6773 return p + 4;
6774 }
6775
6776 static bfd_byte *
6777 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6778 {
6779 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6780 return p + 4;
6781 }
6782
6783 static bfd_byte *
6784 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6785 {
6786 p = savegpr1 (abfd, p, r);
6787 bfd_put_32 (abfd, BLR, p);
6788 return p + 4;
6789 }
6790
6791 static bfd_byte *
6792 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6793 {
6794 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6795 return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6800 {
6801 p = restgpr1 (abfd, p, r);
6802 bfd_put_32 (abfd, BLR, p);
6803 return p + 4;
6804 }
6805
6806 static bfd_byte *
6807 savefpr (bfd *abfd, bfd_byte *p, int r)
6808 {
6809 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6810 return p + 4;
6811 }
6812
6813 static bfd_byte *
6814 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6815 {
6816 p = savefpr (abfd, p, r);
6817 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6818 p = p + 4;
6819 bfd_put_32 (abfd, BLR, p);
6820 return p + 4;
6821 }
6822
6823 static bfd_byte *
6824 restfpr (bfd *abfd, bfd_byte *p, int r)
6825 {
6826 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6827 return p + 4;
6828 }
6829
6830 static bfd_byte *
6831 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6832 {
6833 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6834 p = p + 4;
6835 p = restfpr (abfd, p, r);
6836 bfd_put_32 (abfd, MTLR_R0, p);
6837 p = p + 4;
6838 if (r == 29)
6839 {
6840 p = restfpr (abfd, p, 30);
6841 p = restfpr (abfd, p, 31);
6842 }
6843 bfd_put_32 (abfd, BLR, p);
6844 return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850 p = savefpr (abfd, p, r);
6851 bfd_put_32 (abfd, BLR, p);
6852 return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6857 {
6858 p = restfpr (abfd, p, r);
6859 bfd_put_32 (abfd, BLR, p);
6860 return p + 4;
6861 }
6862
6863 static bfd_byte *
6864 savevr (bfd *abfd, bfd_byte *p, int r)
6865 {
6866 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6867 p = p + 4;
6868 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6869 return p + 4;
6870 }
6871
6872 static bfd_byte *
6873 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6874 {
6875 p = savevr (abfd, p, r);
6876 bfd_put_32 (abfd, BLR, p);
6877 return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 restvr (bfd *abfd, bfd_byte *p, int r)
6882 {
6883 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6884 p = p + 4;
6885 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6886 return p + 4;
6887 }
6888
6889 static bfd_byte *
6890 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6891 {
6892 p = restvr (abfd, p, r);
6893 bfd_put_32 (abfd, BLR, p);
6894 return p + 4;
6895 }
6896
6897 /* Called via elf_link_hash_traverse to transfer dynamic linking
6898 information on function code symbol entries to their corresponding
6899 function descriptor symbol entries. */
6900
6901 static bfd_boolean
6902 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6903 {
6904 struct bfd_link_info *info;
6905 struct ppc_link_hash_table *htab;
6906 struct plt_entry *ent;
6907 struct ppc_link_hash_entry *fh;
6908 struct ppc_link_hash_entry *fdh;
6909 bfd_boolean force_local;
6910
6911 fh = (struct ppc_link_hash_entry *) h;
6912 if (fh->elf.root.type == bfd_link_hash_indirect)
6913 return TRUE;
6914
6915 info = inf;
6916 htab = ppc_hash_table (info);
6917 if (htab == NULL)
6918 return FALSE;
6919
6920 /* Resolve undefined references to dot-symbols as the value
6921 in the function descriptor, if we have one in a regular object.
6922 This is to satisfy cases like ".quad .foo". Calls to functions
6923 in dynamic objects are handled elsewhere. */
6924 if (fh->elf.root.type == bfd_link_hash_undefweak
6925 && fh->was_undefined
6926 && (fdh = defined_func_desc (fh)) != NULL
6927 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6928 && opd_entry_value (fdh->elf.root.u.def.section,
6929 fdh->elf.root.u.def.value,
6930 &fh->elf.root.u.def.section,
6931 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6932 {
6933 fh->elf.root.type = fdh->elf.root.type;
6934 fh->elf.forced_local = 1;
6935 fh->elf.def_regular = fdh->elf.def_regular;
6936 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6937 }
6938
6939 /* If this is a function code symbol, transfer dynamic linking
6940 information to the function descriptor symbol. */
6941 if (!fh->is_func)
6942 return TRUE;
6943
6944 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6945 if (ent->plt.refcount > 0)
6946 break;
6947 if (ent == NULL
6948 || fh->elf.root.root.string[0] != '.'
6949 || fh->elf.root.root.string[1] == '\0')
6950 return TRUE;
6951
6952 /* Find the corresponding function descriptor symbol. Create it
6953 as undefined if necessary. */
6954
6955 fdh = lookup_fdh (fh, htab);
6956 if (fdh == NULL
6957 && !bfd_link_executable (info)
6958 && (fh->elf.root.type == bfd_link_hash_undefined
6959 || fh->elf.root.type == bfd_link_hash_undefweak))
6960 {
6961 fdh = make_fdh (info, fh);
6962 if (fdh == NULL)
6963 return FALSE;
6964 }
6965
6966 /* Fake function descriptors are made undefweak. If the function
6967 code symbol is strong undefined, make the fake sym the same.
6968 If the function code symbol is defined, then force the fake
6969 descriptor local; We can't support overriding of symbols in a
6970 shared library on a fake descriptor. */
6971
6972 if (fdh != NULL
6973 && fdh->fake
6974 && fdh->elf.root.type == bfd_link_hash_undefweak)
6975 {
6976 if (fh->elf.root.type == bfd_link_hash_undefined)
6977 {
6978 fdh->elf.root.type = bfd_link_hash_undefined;
6979 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6980 }
6981 else if (fh->elf.root.type == bfd_link_hash_defined
6982 || fh->elf.root.type == bfd_link_hash_defweak)
6983 {
6984 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6985 }
6986 }
6987
6988 if (fdh != NULL
6989 && !fdh->elf.forced_local
6990 && (!bfd_link_executable (info)
6991 || fdh->elf.def_dynamic
6992 || fdh->elf.ref_dynamic
6993 || (fdh->elf.root.type == bfd_link_hash_undefweak
6994 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6995 {
6996 if (fdh->elf.dynindx == -1)
6997 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6998 return FALSE;
6999 fdh->elf.ref_regular |= fh->elf.ref_regular;
7000 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7001 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7002 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7003 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7004 {
7005 move_plt_plist (fh, fdh);
7006 fdh->elf.needs_plt = 1;
7007 }
7008 fdh->is_func_descriptor = 1;
7009 fdh->oh = fh;
7010 fh->oh = fdh;
7011 }
7012
7013 /* Now that the info is on the function descriptor, clear the
7014 function code sym info. Any function code syms for which we
7015 don't have a definition in a regular file, we force local.
7016 This prevents a shared library from exporting syms that have
7017 been imported from another library. Function code syms that
7018 are really in the library we must leave global to prevent the
7019 linker dragging in a definition from a static library. */
7020 force_local = (!fh->elf.def_regular
7021 || fdh == NULL
7022 || !fdh->elf.def_regular
7023 || fdh->elf.forced_local);
7024 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7025
7026 return TRUE;
7027 }
7028
7029 static const struct sfpr_def_parms save_res_funcs[] =
7030 {
7031 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7032 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7033 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7034 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7035 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7036 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7037 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7038 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7039 { "._savef", 14, 31, savefpr, savefpr1_tail },
7040 { "._restf", 14, 31, restfpr, restfpr1_tail },
7041 { "_savevr_", 20, 31, savevr, savevr_tail },
7042 { "_restvr_", 20, 31, restvr, restvr_tail }
7043 };
7044
7045 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7046 this hook to a) provide some gcc support functions, and b) transfer
7047 dynamic linking information gathered so far on function code symbol
7048 entries, to their corresponding function descriptor symbol entries. */
7049
7050 static bfd_boolean
7051 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7052 struct bfd_link_info *info)
7053 {
7054 struct ppc_link_hash_table *htab;
7055
7056 htab = ppc_hash_table (info);
7057 if (htab == NULL)
7058 return FALSE;
7059
7060 /* Provide any missing _save* and _rest* functions. */
7061 if (htab->sfpr != NULL)
7062 {
7063 unsigned int i;
7064
7065 htab->sfpr->size = 0;
7066 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7067 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7068 return FALSE;
7069 if (htab->sfpr->size == 0)
7070 htab->sfpr->flags |= SEC_EXCLUDE;
7071 }
7072
7073 if (bfd_link_relocatable (info))
7074 return TRUE;
7075
7076 if (htab->elf.hgot != NULL)
7077 {
7078 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7079 /* Make .TOC. defined so as to prevent it being made dynamic.
7080 The wrong value here is fixed later in ppc64_elf_set_toc. */
7081 if (!htab->elf.hgot->def_regular
7082 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7083 {
7084 htab->elf.hgot->root.type = bfd_link_hash_defined;
7085 htab->elf.hgot->root.u.def.value = 0;
7086 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7087 htab->elf.hgot->def_regular = 1;
7088 htab->elf.hgot->root.linker_def = 1;
7089 }
7090 htab->elf.hgot->type = STT_OBJECT;
7091 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7092 | STV_HIDDEN);
7093 }
7094
7095 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7096
7097 return TRUE;
7098 }
7099
7100 /* Return true if we have dynamic relocs that apply to read-only sections. */
7101
7102 static bfd_boolean
7103 readonly_dynrelocs (struct elf_link_hash_entry *h)
7104 {
7105 struct ppc_link_hash_entry *eh;
7106 struct elf_dyn_relocs *p;
7107
7108 eh = (struct ppc_link_hash_entry *) h;
7109 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7110 {
7111 asection *s = p->sec->output_section;
7112
7113 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7114 return TRUE;
7115 }
7116 return FALSE;
7117 }
7118
7119 /* Adjust a symbol defined by a dynamic object and referenced by a
7120 regular object. The current definition is in some section of the
7121 dynamic object, but we're not including those sections. We have to
7122 change the definition to something the rest of the link can
7123 understand. */
7124
7125 static bfd_boolean
7126 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7127 struct elf_link_hash_entry *h)
7128 {
7129 struct ppc_link_hash_table *htab;
7130 asection *s;
7131
7132 htab = ppc_hash_table (info);
7133 if (htab == NULL)
7134 return FALSE;
7135
7136 /* Deal with function syms. */
7137 if (h->type == STT_FUNC
7138 || h->type == STT_GNU_IFUNC
7139 || h->needs_plt)
7140 {
7141 /* Clear procedure linkage table information for any symbol that
7142 won't need a .plt entry. */
7143 struct plt_entry *ent;
7144 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7145 if (ent->plt.refcount > 0)
7146 break;
7147 if (ent == NULL
7148 || (h->type != STT_GNU_IFUNC
7149 && (SYMBOL_CALLS_LOCAL (info, h)
7150 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7151 && h->root.type == bfd_link_hash_undefweak)))
7152 || ((struct ppc_link_hash_entry *) h)->save_res)
7153 {
7154 h->plt.plist = NULL;
7155 h->needs_plt = 0;
7156 h->pointer_equality_needed = 0;
7157 }
7158 else if (abiversion (info->output_bfd) == 2)
7159 {
7160 /* Taking a function's address in a read/write section
7161 doesn't require us to define the function symbol in the
7162 executable on a global entry stub. A dynamic reloc can
7163 be used instead. */
7164 if (h->pointer_equality_needed
7165 && h->type != STT_GNU_IFUNC
7166 && !readonly_dynrelocs (h))
7167 {
7168 h->pointer_equality_needed = 0;
7169 h->non_got_ref = 0;
7170 }
7171
7172 /* After adjust_dynamic_symbol, non_got_ref set in the
7173 non-shared case means that we have allocated space in
7174 .dynbss for the symbol and thus dyn_relocs for this
7175 symbol should be discarded.
7176 If we get here we know we are making a PLT entry for this
7177 symbol, and in an executable we'd normally resolve
7178 relocations against this symbol to the PLT entry. Allow
7179 dynamic relocs if the reference is weak, and the dynamic
7180 relocs will not cause text relocation. */
7181 else if (!h->ref_regular_nonweak
7182 && h->non_got_ref
7183 && h->type != STT_GNU_IFUNC
7184 && !readonly_dynrelocs (h))
7185 h->non_got_ref = 0;
7186
7187 /* If making a plt entry, then we don't need copy relocs. */
7188 return TRUE;
7189 }
7190 }
7191 else
7192 h->plt.plist = NULL;
7193
7194 /* If this is a weak symbol, and there is a real definition, the
7195 processor independent code will have arranged for us to see the
7196 real definition first, and we can just use the same value. */
7197 if (h->u.weakdef != NULL)
7198 {
7199 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7200 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7201 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7202 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7203 if (ELIMINATE_COPY_RELOCS)
7204 h->non_got_ref = h->u.weakdef->non_got_ref;
7205 return TRUE;
7206 }
7207
7208 /* If we are creating a shared library, we must presume that the
7209 only references to the symbol are via the global offset table.
7210 For such cases we need not do anything here; the relocations will
7211 be handled correctly by relocate_section. */
7212 if (bfd_link_pic (info))
7213 return TRUE;
7214
7215 /* If there are no references to this symbol that do not use the
7216 GOT, we don't need to generate a copy reloc. */
7217 if (!h->non_got_ref)
7218 return TRUE;
7219
7220 /* Don't generate a copy reloc for symbols defined in the executable. */
7221 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7222 return TRUE;
7223
7224 /* If -z nocopyreloc was given, don't generate them either. */
7225 if (info->nocopyreloc)
7226 {
7227 h->non_got_ref = 0;
7228 return TRUE;
7229 }
7230
7231 /* If we didn't find any dynamic relocs in read-only sections, then
7232 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7233 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7234 {
7235 h->non_got_ref = 0;
7236 return TRUE;
7237 }
7238
7239 /* Protected variables do not work with .dynbss. The copy in
7240 .dynbss won't be used by the shared library with the protected
7241 definition for the variable. Text relocations are preferable
7242 to an incorrect program. */
7243 if (h->protected_def)
7244 {
7245 h->non_got_ref = 0;
7246 return TRUE;
7247 }
7248
7249 if (h->plt.plist != NULL)
7250 {
7251 /* We should never get here, but unfortunately there are versions
7252 of gcc out there that improperly (for this ABI) put initialized
7253 function pointers, vtable refs and suchlike in read-only
7254 sections. Allow them to proceed, but warn that this might
7255 break at runtime. */
7256 info->callbacks->einfo
7257 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7258 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7259 h->root.root.string);
7260 }
7261
7262 /* This is a reference to a symbol defined by a dynamic object which
7263 is not a function. */
7264
7265 /* We must allocate the symbol in our .dynbss section, which will
7266 become part of the .bss section of the executable. There will be
7267 an entry for this symbol in the .dynsym section. The dynamic
7268 object will contain position independent code, so all references
7269 from the dynamic object to this symbol will go through the global
7270 offset table. The dynamic linker will use the .dynsym entry to
7271 determine the address it must put in the global offset table, so
7272 both the dynamic object and the regular object will refer to the
7273 same memory location for the variable. */
7274
7275 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7276 to copy the initial value out of the dynamic object and into the
7277 runtime process image. We need to remember the offset into the
7278 .rela.bss section we are going to use. */
7279 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7280 {
7281 htab->relbss->size += sizeof (Elf64_External_Rela);
7282 h->needs_copy = 1;
7283 }
7284
7285 s = htab->dynbss;
7286
7287 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7288 }
7289
7290 /* If given a function descriptor symbol, hide both the function code
7291 sym and the descriptor. */
7292 static void
7293 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7294 struct elf_link_hash_entry *h,
7295 bfd_boolean force_local)
7296 {
7297 struct ppc_link_hash_entry *eh;
7298 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7299
7300 eh = (struct ppc_link_hash_entry *) h;
7301 if (eh->is_func_descriptor)
7302 {
7303 struct ppc_link_hash_entry *fh = eh->oh;
7304
7305 if (fh == NULL)
7306 {
7307 const char *p, *q;
7308 struct ppc_link_hash_table *htab;
7309 char save;
7310
7311 /* We aren't supposed to use alloca in BFD because on
7312 systems which do not have alloca the version in libiberty
7313 calls xmalloc, which might cause the program to crash
7314 when it runs out of memory. This function doesn't have a
7315 return status, so there's no way to gracefully return an
7316 error. So cheat. We know that string[-1] can be safely
7317 accessed; It's either a string in an ELF string table,
7318 or allocated in an objalloc structure. */
7319
7320 p = eh->elf.root.root.string - 1;
7321 save = *p;
7322 *(char *) p = '.';
7323 htab = ppc_hash_table (info);
7324 if (htab == NULL)
7325 return;
7326
7327 fh = (struct ppc_link_hash_entry *)
7328 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7329 *(char *) p = save;
7330
7331 /* Unfortunately, if it so happens that the string we were
7332 looking for was allocated immediately before this string,
7333 then we overwrote the string terminator. That's the only
7334 reason the lookup should fail. */
7335 if (fh == NULL)
7336 {
7337 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7338 while (q >= eh->elf.root.root.string && *q == *p)
7339 --q, --p;
7340 if (q < eh->elf.root.root.string && *p == '.')
7341 fh = (struct ppc_link_hash_entry *)
7342 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7343 }
7344 if (fh != NULL)
7345 {
7346 eh->oh = fh;
7347 fh->oh = eh;
7348 }
7349 }
7350 if (fh != NULL)
7351 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7352 }
7353 }
7354
7355 static bfd_boolean
7356 get_sym_h (struct elf_link_hash_entry **hp,
7357 Elf_Internal_Sym **symp,
7358 asection **symsecp,
7359 unsigned char **tls_maskp,
7360 Elf_Internal_Sym **locsymsp,
7361 unsigned long r_symndx,
7362 bfd *ibfd)
7363 {
7364 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7365
7366 if (r_symndx >= symtab_hdr->sh_info)
7367 {
7368 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7369 struct elf_link_hash_entry *h;
7370
7371 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7372 h = elf_follow_link (h);
7373
7374 if (hp != NULL)
7375 *hp = h;
7376
7377 if (symp != NULL)
7378 *symp = NULL;
7379
7380 if (symsecp != NULL)
7381 {
7382 asection *symsec = NULL;
7383 if (h->root.type == bfd_link_hash_defined
7384 || h->root.type == bfd_link_hash_defweak)
7385 symsec = h->root.u.def.section;
7386 *symsecp = symsec;
7387 }
7388
7389 if (tls_maskp != NULL)
7390 {
7391 struct ppc_link_hash_entry *eh;
7392
7393 eh = (struct ppc_link_hash_entry *) h;
7394 *tls_maskp = &eh->tls_mask;
7395 }
7396 }
7397 else
7398 {
7399 Elf_Internal_Sym *sym;
7400 Elf_Internal_Sym *locsyms = *locsymsp;
7401
7402 if (locsyms == NULL)
7403 {
7404 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7405 if (locsyms == NULL)
7406 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7407 symtab_hdr->sh_info,
7408 0, NULL, NULL, NULL);
7409 if (locsyms == NULL)
7410 return FALSE;
7411 *locsymsp = locsyms;
7412 }
7413 sym = locsyms + r_symndx;
7414
7415 if (hp != NULL)
7416 *hp = NULL;
7417
7418 if (symp != NULL)
7419 *symp = sym;
7420
7421 if (symsecp != NULL)
7422 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7423
7424 if (tls_maskp != NULL)
7425 {
7426 struct got_entry **lgot_ents;
7427 unsigned char *tls_mask;
7428
7429 tls_mask = NULL;
7430 lgot_ents = elf_local_got_ents (ibfd);
7431 if (lgot_ents != NULL)
7432 {
7433 struct plt_entry **local_plt = (struct plt_entry **)
7434 (lgot_ents + symtab_hdr->sh_info);
7435 unsigned char *lgot_masks = (unsigned char *)
7436 (local_plt + symtab_hdr->sh_info);
7437 tls_mask = &lgot_masks[r_symndx];
7438 }
7439 *tls_maskp = tls_mask;
7440 }
7441 }
7442 return TRUE;
7443 }
7444
7445 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7446 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7447 type suitable for optimization, and 1 otherwise. */
7448
7449 static int
7450 get_tls_mask (unsigned char **tls_maskp,
7451 unsigned long *toc_symndx,
7452 bfd_vma *toc_addend,
7453 Elf_Internal_Sym **locsymsp,
7454 const Elf_Internal_Rela *rel,
7455 bfd *ibfd)
7456 {
7457 unsigned long r_symndx;
7458 int next_r;
7459 struct elf_link_hash_entry *h;
7460 Elf_Internal_Sym *sym;
7461 asection *sec;
7462 bfd_vma off;
7463
7464 r_symndx = ELF64_R_SYM (rel->r_info);
7465 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7466 return 0;
7467
7468 if ((*tls_maskp != NULL && **tls_maskp != 0)
7469 || sec == NULL
7470 || ppc64_elf_section_data (sec) == NULL
7471 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7472 return 1;
7473
7474 /* Look inside a TOC section too. */
7475 if (h != NULL)
7476 {
7477 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7478 off = h->root.u.def.value;
7479 }
7480 else
7481 off = sym->st_value;
7482 off += rel->r_addend;
7483 BFD_ASSERT (off % 8 == 0);
7484 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7485 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7486 if (toc_symndx != NULL)
7487 *toc_symndx = r_symndx;
7488 if (toc_addend != NULL)
7489 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7490 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7491 return 0;
7492 if ((h == NULL || is_static_defined (h))
7493 && (next_r == -1 || next_r == -2))
7494 return 1 - next_r;
7495 return 1;
7496 }
7497
7498 /* Find (or create) an entry in the tocsave hash table. */
7499
7500 static struct tocsave_entry *
7501 tocsave_find (struct ppc_link_hash_table *htab,
7502 enum insert_option insert,
7503 Elf_Internal_Sym **local_syms,
7504 const Elf_Internal_Rela *irela,
7505 bfd *ibfd)
7506 {
7507 unsigned long r_indx;
7508 struct elf_link_hash_entry *h;
7509 Elf_Internal_Sym *sym;
7510 struct tocsave_entry ent, *p;
7511 hashval_t hash;
7512 struct tocsave_entry **slot;
7513
7514 r_indx = ELF64_R_SYM (irela->r_info);
7515 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7516 return NULL;
7517 if (ent.sec == NULL || ent.sec->output_section == NULL)
7518 {
7519 (*_bfd_error_handler)
7520 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7521 return NULL;
7522 }
7523
7524 if (h != NULL)
7525 ent.offset = h->root.u.def.value;
7526 else
7527 ent.offset = sym->st_value;
7528 ent.offset += irela->r_addend;
7529
7530 hash = tocsave_htab_hash (&ent);
7531 slot = ((struct tocsave_entry **)
7532 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7533 if (slot == NULL)
7534 return NULL;
7535
7536 if (*slot == NULL)
7537 {
7538 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7539 if (p == NULL)
7540 return NULL;
7541 *p = ent;
7542 *slot = p;
7543 }
7544 return *slot;
7545 }
7546
7547 /* Adjust all global syms defined in opd sections. In gcc generated
7548 code for the old ABI, these will already have been done. */
7549
7550 static bfd_boolean
7551 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7552 {
7553 struct ppc_link_hash_entry *eh;
7554 asection *sym_sec;
7555 struct _opd_sec_data *opd;
7556
7557 if (h->root.type == bfd_link_hash_indirect)
7558 return TRUE;
7559
7560 if (h->root.type != bfd_link_hash_defined
7561 && h->root.type != bfd_link_hash_defweak)
7562 return TRUE;
7563
7564 eh = (struct ppc_link_hash_entry *) h;
7565 if (eh->adjust_done)
7566 return TRUE;
7567
7568 sym_sec = eh->elf.root.u.def.section;
7569 opd = get_opd_info (sym_sec);
7570 if (opd != NULL && opd->adjust != NULL)
7571 {
7572 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7573 if (adjust == -1)
7574 {
7575 /* This entry has been deleted. */
7576 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7577 if (dsec == NULL)
7578 {
7579 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7580 if (discarded_section (dsec))
7581 {
7582 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7583 break;
7584 }
7585 }
7586 eh->elf.root.u.def.value = 0;
7587 eh->elf.root.u.def.section = dsec;
7588 }
7589 else
7590 eh->elf.root.u.def.value += adjust;
7591 eh->adjust_done = 1;
7592 }
7593 return TRUE;
7594 }
7595
7596 /* Handles decrementing dynamic reloc counts for the reloc specified by
7597 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7598 have already been determined. */
7599
7600 static bfd_boolean
7601 dec_dynrel_count (bfd_vma r_info,
7602 asection *sec,
7603 struct bfd_link_info *info,
7604 Elf_Internal_Sym **local_syms,
7605 struct elf_link_hash_entry *h,
7606 Elf_Internal_Sym *sym)
7607 {
7608 enum elf_ppc64_reloc_type r_type;
7609 asection *sym_sec = NULL;
7610
7611 /* Can this reloc be dynamic? This switch, and later tests here
7612 should be kept in sync with the code in check_relocs. */
7613 r_type = ELF64_R_TYPE (r_info);
7614 switch (r_type)
7615 {
7616 default:
7617 return TRUE;
7618
7619 case R_PPC64_TPREL16:
7620 case R_PPC64_TPREL16_LO:
7621 case R_PPC64_TPREL16_HI:
7622 case R_PPC64_TPREL16_HA:
7623 case R_PPC64_TPREL16_DS:
7624 case R_PPC64_TPREL16_LO_DS:
7625 case R_PPC64_TPREL16_HIGH:
7626 case R_PPC64_TPREL16_HIGHA:
7627 case R_PPC64_TPREL16_HIGHER:
7628 case R_PPC64_TPREL16_HIGHERA:
7629 case R_PPC64_TPREL16_HIGHEST:
7630 case R_PPC64_TPREL16_HIGHESTA:
7631 if (!bfd_link_pic (info))
7632 return TRUE;
7633
7634 case R_PPC64_TPREL64:
7635 case R_PPC64_DTPMOD64:
7636 case R_PPC64_DTPREL64:
7637 case R_PPC64_ADDR64:
7638 case R_PPC64_REL30:
7639 case R_PPC64_REL32:
7640 case R_PPC64_REL64:
7641 case R_PPC64_ADDR14:
7642 case R_PPC64_ADDR14_BRNTAKEN:
7643 case R_PPC64_ADDR14_BRTAKEN:
7644 case R_PPC64_ADDR16:
7645 case R_PPC64_ADDR16_DS:
7646 case R_PPC64_ADDR16_HA:
7647 case R_PPC64_ADDR16_HI:
7648 case R_PPC64_ADDR16_HIGH:
7649 case R_PPC64_ADDR16_HIGHA:
7650 case R_PPC64_ADDR16_HIGHER:
7651 case R_PPC64_ADDR16_HIGHERA:
7652 case R_PPC64_ADDR16_HIGHEST:
7653 case R_PPC64_ADDR16_HIGHESTA:
7654 case R_PPC64_ADDR16_LO:
7655 case R_PPC64_ADDR16_LO_DS:
7656 case R_PPC64_ADDR24:
7657 case R_PPC64_ADDR32:
7658 case R_PPC64_UADDR16:
7659 case R_PPC64_UADDR32:
7660 case R_PPC64_UADDR64:
7661 case R_PPC64_TOC:
7662 break;
7663 }
7664
7665 if (local_syms != NULL)
7666 {
7667 unsigned long r_symndx;
7668 bfd *ibfd = sec->owner;
7669
7670 r_symndx = ELF64_R_SYM (r_info);
7671 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7672 return FALSE;
7673 }
7674
7675 if ((bfd_link_pic (info)
7676 && (must_be_dyn_reloc (info, r_type)
7677 || (h != NULL
7678 && (!SYMBOLIC_BIND (info, h)
7679 || h->root.type == bfd_link_hash_defweak
7680 || !h->def_regular))))
7681 || (ELIMINATE_COPY_RELOCS
7682 && !bfd_link_pic (info)
7683 && h != NULL
7684 && (h->root.type == bfd_link_hash_defweak
7685 || !h->def_regular)))
7686 ;
7687 else
7688 return TRUE;
7689
7690 if (h != NULL)
7691 {
7692 struct elf_dyn_relocs *p;
7693 struct elf_dyn_relocs **pp;
7694 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7695
7696 /* elf_gc_sweep may have already removed all dyn relocs associated
7697 with local syms for a given section. Also, symbol flags are
7698 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7699 report a dynreloc miscount. */
7700 if (*pp == NULL && info->gc_sections)
7701 return TRUE;
7702
7703 while ((p = *pp) != NULL)
7704 {
7705 if (p->sec == sec)
7706 {
7707 if (!must_be_dyn_reloc (info, r_type))
7708 p->pc_count -= 1;
7709 p->count -= 1;
7710 if (p->count == 0)
7711 *pp = p->next;
7712 return TRUE;
7713 }
7714 pp = &p->next;
7715 }
7716 }
7717 else
7718 {
7719 struct ppc_dyn_relocs *p;
7720 struct ppc_dyn_relocs **pp;
7721 void *vpp;
7722 bfd_boolean is_ifunc;
7723
7724 if (local_syms == NULL)
7725 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7726 if (sym_sec == NULL)
7727 sym_sec = sec;
7728
7729 vpp = &elf_section_data (sym_sec)->local_dynrel;
7730 pp = (struct ppc_dyn_relocs **) vpp;
7731
7732 if (*pp == NULL && info->gc_sections)
7733 return TRUE;
7734
7735 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7736 while ((p = *pp) != NULL)
7737 {
7738 if (p->sec == sec && p->ifunc == is_ifunc)
7739 {
7740 p->count -= 1;
7741 if (p->count == 0)
7742 *pp = p->next;
7743 return TRUE;
7744 }
7745 pp = &p->next;
7746 }
7747 }
7748
7749 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7750 sec->owner, sec);
7751 bfd_set_error (bfd_error_bad_value);
7752 return FALSE;
7753 }
7754
7755 /* Remove unused Official Procedure Descriptor entries. Currently we
7756 only remove those associated with functions in discarded link-once
7757 sections, or weakly defined functions that have been overridden. It
7758 would be possible to remove many more entries for statically linked
7759 applications. */
7760
7761 bfd_boolean
7762 ppc64_elf_edit_opd (struct bfd_link_info *info)
7763 {
7764 bfd *ibfd;
7765 bfd_boolean some_edited = FALSE;
7766 asection *need_pad = NULL;
7767 struct ppc_link_hash_table *htab;
7768
7769 htab = ppc_hash_table (info);
7770 if (htab == NULL)
7771 return FALSE;
7772
7773 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7774 {
7775 asection *sec;
7776 Elf_Internal_Rela *relstart, *rel, *relend;
7777 Elf_Internal_Shdr *symtab_hdr;
7778 Elf_Internal_Sym *local_syms;
7779 struct _opd_sec_data *opd;
7780 bfd_boolean need_edit, add_aux_fields, broken;
7781 bfd_size_type cnt_16b = 0;
7782
7783 if (!is_ppc64_elf (ibfd))
7784 continue;
7785
7786 sec = bfd_get_section_by_name (ibfd, ".opd");
7787 if (sec == NULL || sec->size == 0)
7788 continue;
7789
7790 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7791 continue;
7792
7793 if (sec->output_section == bfd_abs_section_ptr)
7794 continue;
7795
7796 /* Look through the section relocs. */
7797 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7798 continue;
7799
7800 local_syms = NULL;
7801 symtab_hdr = &elf_symtab_hdr (ibfd);
7802
7803 /* Read the relocations. */
7804 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7805 info->keep_memory);
7806 if (relstart == NULL)
7807 return FALSE;
7808
7809 /* First run through the relocs to check they are sane, and to
7810 determine whether we need to edit this opd section. */
7811 need_edit = FALSE;
7812 broken = FALSE;
7813 need_pad = sec;
7814 relend = relstart + sec->reloc_count;
7815 for (rel = relstart; rel < relend; )
7816 {
7817 enum elf_ppc64_reloc_type r_type;
7818 unsigned long r_symndx;
7819 asection *sym_sec;
7820 struct elf_link_hash_entry *h;
7821 Elf_Internal_Sym *sym;
7822 bfd_vma offset;
7823
7824 /* .opd contains an array of 16 or 24 byte entries. We're
7825 only interested in the reloc pointing to a function entry
7826 point. */
7827 offset = rel->r_offset;
7828 if (rel + 1 == relend
7829 || rel[1].r_offset != offset + 8)
7830 {
7831 /* If someone messes with .opd alignment then after a
7832 "ld -r" we might have padding in the middle of .opd.
7833 Also, there's nothing to prevent someone putting
7834 something silly in .opd with the assembler. No .opd
7835 optimization for them! */
7836 broken_opd:
7837 (*_bfd_error_handler)
7838 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7839 broken = TRUE;
7840 break;
7841 }
7842
7843 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7844 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7845 {
7846 (*_bfd_error_handler)
7847 (_("%B: unexpected reloc type %u in .opd section"),
7848 ibfd, r_type);
7849 broken = TRUE;
7850 break;
7851 }
7852
7853 r_symndx = ELF64_R_SYM (rel->r_info);
7854 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7855 r_symndx, ibfd))
7856 goto error_ret;
7857
7858 if (sym_sec == NULL || sym_sec->owner == NULL)
7859 {
7860 const char *sym_name;
7861 if (h != NULL)
7862 sym_name = h->root.root.string;
7863 else
7864 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7865 sym_sec);
7866
7867 (*_bfd_error_handler)
7868 (_("%B: undefined sym `%s' in .opd section"),
7869 ibfd, sym_name);
7870 broken = TRUE;
7871 break;
7872 }
7873
7874 /* opd entries are always for functions defined in the
7875 current input bfd. If the symbol isn't defined in the
7876 input bfd, then we won't be using the function in this
7877 bfd; It must be defined in a linkonce section in another
7878 bfd, or is weak. It's also possible that we are
7879 discarding the function due to a linker script /DISCARD/,
7880 which we test for via the output_section. */
7881 if (sym_sec->owner != ibfd
7882 || sym_sec->output_section == bfd_abs_section_ptr)
7883 need_edit = TRUE;
7884
7885 rel += 2;
7886 if (rel + 1 == relend
7887 || (rel + 2 < relend
7888 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7889 ++rel;
7890
7891 if (rel == relend)
7892 {
7893 if (sec->size == offset + 24)
7894 {
7895 need_pad = NULL;
7896 break;
7897 }
7898 if (sec->size == offset + 16)
7899 {
7900 cnt_16b++;
7901 break;
7902 }
7903 goto broken_opd;
7904 }
7905 else if (rel + 1 < relend
7906 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7907 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7908 {
7909 if (rel[0].r_offset == offset + 16)
7910 cnt_16b++;
7911 else if (rel[0].r_offset != offset + 24)
7912 goto broken_opd;
7913 }
7914 else
7915 goto broken_opd;
7916 }
7917
7918 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7919
7920 if (!broken && (need_edit || add_aux_fields))
7921 {
7922 Elf_Internal_Rela *write_rel;
7923 Elf_Internal_Shdr *rel_hdr;
7924 bfd_byte *rptr, *wptr;
7925 bfd_byte *new_contents;
7926 bfd_size_type amt;
7927
7928 new_contents = NULL;
7929 amt = OPD_NDX (sec->size) * sizeof (long);
7930 opd = &ppc64_elf_section_data (sec)->u.opd;
7931 opd->adjust = bfd_zalloc (sec->owner, amt);
7932 if (opd->adjust == NULL)
7933 return FALSE;
7934 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7935
7936 /* This seems a waste of time as input .opd sections are all
7937 zeros as generated by gcc, but I suppose there's no reason
7938 this will always be so. We might start putting something in
7939 the third word of .opd entries. */
7940 if ((sec->flags & SEC_IN_MEMORY) == 0)
7941 {
7942 bfd_byte *loc;
7943 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7944 {
7945 if (loc != NULL)
7946 free (loc);
7947 error_ret:
7948 if (local_syms != NULL
7949 && symtab_hdr->contents != (unsigned char *) local_syms)
7950 free (local_syms);
7951 if (elf_section_data (sec)->relocs != relstart)
7952 free (relstart);
7953 return FALSE;
7954 }
7955 sec->contents = loc;
7956 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7957 }
7958
7959 elf_section_data (sec)->relocs = relstart;
7960
7961 new_contents = sec->contents;
7962 if (add_aux_fields)
7963 {
7964 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7965 if (new_contents == NULL)
7966 return FALSE;
7967 need_pad = NULL;
7968 }
7969 wptr = new_contents;
7970 rptr = sec->contents;
7971 write_rel = relstart;
7972 for (rel = relstart; rel < relend; )
7973 {
7974 unsigned long r_symndx;
7975 asection *sym_sec;
7976 struct elf_link_hash_entry *h;
7977 struct ppc_link_hash_entry *fdh = NULL;
7978 Elf_Internal_Sym *sym;
7979 long opd_ent_size;
7980 Elf_Internal_Rela *next_rel;
7981 bfd_boolean skip;
7982
7983 r_symndx = ELF64_R_SYM (rel->r_info);
7984 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7985 r_symndx, ibfd))
7986 goto error_ret;
7987
7988 next_rel = rel + 2;
7989 if (next_rel + 1 == relend
7990 || (next_rel + 2 < relend
7991 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7992 ++next_rel;
7993
7994 /* See if the .opd entry is full 24 byte or
7995 16 byte (with fd_aux entry overlapped with next
7996 fd_func). */
7997 opd_ent_size = 24;
7998 if (next_rel == relend)
7999 {
8000 if (sec->size == rel->r_offset + 16)
8001 opd_ent_size = 16;
8002 }
8003 else if (next_rel->r_offset == rel->r_offset + 16)
8004 opd_ent_size = 16;
8005
8006 if (h != NULL
8007 && h->root.root.string[0] == '.')
8008 {
8009 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8010 if (fdh != NULL
8011 && fdh->elf.root.type != bfd_link_hash_defined
8012 && fdh->elf.root.type != bfd_link_hash_defweak)
8013 fdh = NULL;
8014 }
8015
8016 skip = (sym_sec->owner != ibfd
8017 || sym_sec->output_section == bfd_abs_section_ptr);
8018 if (skip)
8019 {
8020 if (fdh != NULL && sym_sec->owner == ibfd)
8021 {
8022 /* Arrange for the function descriptor sym
8023 to be dropped. */
8024 fdh->elf.root.u.def.value = 0;
8025 fdh->elf.root.u.def.section = sym_sec;
8026 }
8027 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8028
8029 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8030 rel = next_rel;
8031 else
8032 while (1)
8033 {
8034 if (!dec_dynrel_count (rel->r_info, sec, info,
8035 NULL, h, sym))
8036 goto error_ret;
8037
8038 if (++rel == next_rel)
8039 break;
8040
8041 r_symndx = ELF64_R_SYM (rel->r_info);
8042 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8043 r_symndx, ibfd))
8044 goto error_ret;
8045 }
8046 }
8047 else
8048 {
8049 /* We'll be keeping this opd entry. */
8050 long adjust;
8051
8052 if (fdh != NULL)
8053 {
8054 /* Redefine the function descriptor symbol to
8055 this location in the opd section. It is
8056 necessary to update the value here rather
8057 than using an array of adjustments as we do
8058 for local symbols, because various places
8059 in the generic ELF code use the value
8060 stored in u.def.value. */
8061 fdh->elf.root.u.def.value = wptr - new_contents;
8062 fdh->adjust_done = 1;
8063 }
8064
8065 /* Local syms are a bit tricky. We could
8066 tweak them as they can be cached, but
8067 we'd need to look through the local syms
8068 for the function descriptor sym which we
8069 don't have at the moment. So keep an
8070 array of adjustments. */
8071 adjust = (wptr - new_contents) - (rptr - sec->contents);
8072 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8073
8074 if (wptr != rptr)
8075 memcpy (wptr, rptr, opd_ent_size);
8076 wptr += opd_ent_size;
8077 if (add_aux_fields && opd_ent_size == 16)
8078 {
8079 memset (wptr, '\0', 8);
8080 wptr += 8;
8081 }
8082
8083 /* We need to adjust any reloc offsets to point to the
8084 new opd entries. */
8085 for ( ; rel != next_rel; ++rel)
8086 {
8087 rel->r_offset += adjust;
8088 if (write_rel != rel)
8089 memcpy (write_rel, rel, sizeof (*rel));
8090 ++write_rel;
8091 }
8092 }
8093
8094 rptr += opd_ent_size;
8095 }
8096
8097 sec->size = wptr - new_contents;
8098 sec->reloc_count = write_rel - relstart;
8099 if (add_aux_fields)
8100 {
8101 free (sec->contents);
8102 sec->contents = new_contents;
8103 }
8104
8105 /* Fudge the header size too, as this is used later in
8106 elf_bfd_final_link if we are emitting relocs. */
8107 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8108 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8109 some_edited = TRUE;
8110 }
8111 else if (elf_section_data (sec)->relocs != relstart)
8112 free (relstart);
8113
8114 if (local_syms != NULL
8115 && symtab_hdr->contents != (unsigned char *) local_syms)
8116 {
8117 if (!info->keep_memory)
8118 free (local_syms);
8119 else
8120 symtab_hdr->contents = (unsigned char *) local_syms;
8121 }
8122 }
8123
8124 if (some_edited)
8125 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8126
8127 /* If we are doing a final link and the last .opd entry is just 16 byte
8128 long, add a 8 byte padding after it. */
8129 if (need_pad != NULL && !bfd_link_relocatable (info))
8130 {
8131 bfd_byte *p;
8132
8133 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8134 {
8135 BFD_ASSERT (need_pad->size > 0);
8136
8137 p = bfd_malloc (need_pad->size + 8);
8138 if (p == NULL)
8139 return FALSE;
8140
8141 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8142 p, 0, need_pad->size))
8143 return FALSE;
8144
8145 need_pad->contents = p;
8146 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8147 }
8148 else
8149 {
8150 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8151 if (p == NULL)
8152 return FALSE;
8153
8154 need_pad->contents = p;
8155 }
8156
8157 memset (need_pad->contents + need_pad->size, 0, 8);
8158 need_pad->size += 8;
8159 }
8160
8161 return TRUE;
8162 }
8163
8164 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8165
8166 asection *
8167 ppc64_elf_tls_setup (struct bfd_link_info *info)
8168 {
8169 struct ppc_link_hash_table *htab;
8170
8171 htab = ppc_hash_table (info);
8172 if (htab == NULL)
8173 return NULL;
8174
8175 if (abiversion (info->output_bfd) == 1)
8176 htab->opd_abi = 1;
8177
8178 if (htab->params->no_multi_toc)
8179 htab->do_multi_toc = 0;
8180 else if (!htab->do_multi_toc)
8181 htab->params->no_multi_toc = 1;
8182
8183 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8184 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8185 FALSE, FALSE, TRUE));
8186 /* Move dynamic linking info to the function descriptor sym. */
8187 if (htab->tls_get_addr != NULL)
8188 func_desc_adjust (&htab->tls_get_addr->elf, info);
8189 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8190 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8191 FALSE, FALSE, TRUE));
8192 if (htab->params->tls_get_addr_opt)
8193 {
8194 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8195
8196 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8197 FALSE, FALSE, TRUE);
8198 if (opt != NULL)
8199 func_desc_adjust (opt, info);
8200 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8201 FALSE, FALSE, TRUE);
8202 if (opt_fd != NULL
8203 && (opt_fd->root.type == bfd_link_hash_defined
8204 || opt_fd->root.type == bfd_link_hash_defweak))
8205 {
8206 /* If glibc supports an optimized __tls_get_addr call stub,
8207 signalled by the presence of __tls_get_addr_opt, and we'll
8208 be calling __tls_get_addr via a plt call stub, then
8209 make __tls_get_addr point to __tls_get_addr_opt. */
8210 tga_fd = &htab->tls_get_addr_fd->elf;
8211 if (htab->elf.dynamic_sections_created
8212 && tga_fd != NULL
8213 && (tga_fd->type == STT_FUNC
8214 || tga_fd->needs_plt)
8215 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8216 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8217 && tga_fd->root.type == bfd_link_hash_undefweak)))
8218 {
8219 struct plt_entry *ent;
8220
8221 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8222 if (ent->plt.refcount > 0)
8223 break;
8224 if (ent != NULL)
8225 {
8226 tga_fd->root.type = bfd_link_hash_indirect;
8227 tga_fd->root.u.i.link = &opt_fd->root;
8228 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8229 opt_fd->forced_local = 0;
8230 if (opt_fd->dynindx != -1)
8231 {
8232 /* Use __tls_get_addr_opt in dynamic relocations. */
8233 opt_fd->dynindx = -1;
8234 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8235 opt_fd->dynstr_index);
8236 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8237 return NULL;
8238 }
8239 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8240 tga = &htab->tls_get_addr->elf;
8241 if (opt != NULL && tga != NULL)
8242 {
8243 tga->root.type = bfd_link_hash_indirect;
8244 tga->root.u.i.link = &opt->root;
8245 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8246 opt->forced_local = 0;
8247 _bfd_elf_link_hash_hide_symbol (info, opt,
8248 tga->forced_local);
8249 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8250 }
8251 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8252 htab->tls_get_addr_fd->is_func_descriptor = 1;
8253 if (htab->tls_get_addr != NULL)
8254 {
8255 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8256 htab->tls_get_addr->is_func = 1;
8257 }
8258 }
8259 }
8260 }
8261 else if (htab->params->tls_get_addr_opt < 0)
8262 htab->params->tls_get_addr_opt = 0;
8263 }
8264 return _bfd_elf_tls_setup (info->output_bfd, info);
8265 }
8266
8267 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8268 HASH1 or HASH2. */
8269
8270 static bfd_boolean
8271 branch_reloc_hash_match (const bfd *ibfd,
8272 const Elf_Internal_Rela *rel,
8273 const struct ppc_link_hash_entry *hash1,
8274 const struct ppc_link_hash_entry *hash2)
8275 {
8276 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8277 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8278 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8279
8280 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8281 {
8282 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8283 struct elf_link_hash_entry *h;
8284
8285 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8286 h = elf_follow_link (h);
8287 if (h == &hash1->elf || h == &hash2->elf)
8288 return TRUE;
8289 }
8290 return FALSE;
8291 }
8292
8293 /* Run through all the TLS relocs looking for optimization
8294 opportunities. The linker has been hacked (see ppc64elf.em) to do
8295 a preliminary section layout so that we know the TLS segment
8296 offsets. We can't optimize earlier because some optimizations need
8297 to know the tp offset, and we need to optimize before allocating
8298 dynamic relocations. */
8299
8300 bfd_boolean
8301 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8302 {
8303 bfd *ibfd;
8304 asection *sec;
8305 struct ppc_link_hash_table *htab;
8306 unsigned char *toc_ref;
8307 int pass;
8308
8309 if (!bfd_link_executable (info))
8310 return TRUE;
8311
8312 htab = ppc_hash_table (info);
8313 if (htab == NULL)
8314 return FALSE;
8315
8316 /* Make two passes over the relocs. On the first pass, mark toc
8317 entries involved with tls relocs, and check that tls relocs
8318 involved in setting up a tls_get_addr call are indeed followed by
8319 such a call. If they are not, we can't do any tls optimization.
8320 On the second pass twiddle tls_mask flags to notify
8321 relocate_section that optimization can be done, and adjust got
8322 and plt refcounts. */
8323 toc_ref = NULL;
8324 for (pass = 0; pass < 2; ++pass)
8325 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8326 {
8327 Elf_Internal_Sym *locsyms = NULL;
8328 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8329
8330 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8331 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8332 {
8333 Elf_Internal_Rela *relstart, *rel, *relend;
8334 bfd_boolean found_tls_get_addr_arg = 0;
8335
8336 /* Read the relocations. */
8337 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8338 info->keep_memory);
8339 if (relstart == NULL)
8340 {
8341 free (toc_ref);
8342 return FALSE;
8343 }
8344
8345 relend = relstart + sec->reloc_count;
8346 for (rel = relstart; rel < relend; rel++)
8347 {
8348 enum elf_ppc64_reloc_type r_type;
8349 unsigned long r_symndx;
8350 struct elf_link_hash_entry *h;
8351 Elf_Internal_Sym *sym;
8352 asection *sym_sec;
8353 unsigned char *tls_mask;
8354 unsigned char tls_set, tls_clear, tls_type = 0;
8355 bfd_vma value;
8356 bfd_boolean ok_tprel, is_local;
8357 long toc_ref_index = 0;
8358 int expecting_tls_get_addr = 0;
8359 bfd_boolean ret = FALSE;
8360
8361 r_symndx = ELF64_R_SYM (rel->r_info);
8362 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8363 r_symndx, ibfd))
8364 {
8365 err_free_rel:
8366 if (elf_section_data (sec)->relocs != relstart)
8367 free (relstart);
8368 if (toc_ref != NULL)
8369 free (toc_ref);
8370 if (locsyms != NULL
8371 && (elf_symtab_hdr (ibfd).contents
8372 != (unsigned char *) locsyms))
8373 free (locsyms);
8374 return ret;
8375 }
8376
8377 if (h != NULL)
8378 {
8379 if (h->root.type == bfd_link_hash_defined
8380 || h->root.type == bfd_link_hash_defweak)
8381 value = h->root.u.def.value;
8382 else if (h->root.type == bfd_link_hash_undefweak)
8383 value = 0;
8384 else
8385 {
8386 found_tls_get_addr_arg = 0;
8387 continue;
8388 }
8389 }
8390 else
8391 /* Symbols referenced by TLS relocs must be of type
8392 STT_TLS. So no need for .opd local sym adjust. */
8393 value = sym->st_value;
8394
8395 ok_tprel = FALSE;
8396 is_local = FALSE;
8397 if (h == NULL
8398 || !h->def_dynamic)
8399 {
8400 is_local = TRUE;
8401 if (h != NULL
8402 && h->root.type == bfd_link_hash_undefweak)
8403 ok_tprel = TRUE;
8404 else if (sym_sec != NULL
8405 && sym_sec->output_section != NULL)
8406 {
8407 value += sym_sec->output_offset;
8408 value += sym_sec->output_section->vma;
8409 value -= htab->elf.tls_sec->vma;
8410 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8411 < (bfd_vma) 1 << 32);
8412 }
8413 }
8414
8415 r_type = ELF64_R_TYPE (rel->r_info);
8416 /* If this section has old-style __tls_get_addr calls
8417 without marker relocs, then check that each
8418 __tls_get_addr call reloc is preceded by a reloc
8419 that conceivably belongs to the __tls_get_addr arg
8420 setup insn. If we don't find matching arg setup
8421 relocs, don't do any tls optimization. */
8422 if (pass == 0
8423 && sec->has_tls_get_addr_call
8424 && h != NULL
8425 && (h == &htab->tls_get_addr->elf
8426 || h == &htab->tls_get_addr_fd->elf)
8427 && !found_tls_get_addr_arg
8428 && is_branch_reloc (r_type))
8429 {
8430 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8431 "TLS optimization disabled\n"),
8432 ibfd, sec, rel->r_offset);
8433 ret = TRUE;
8434 goto err_free_rel;
8435 }
8436
8437 found_tls_get_addr_arg = 0;
8438 switch (r_type)
8439 {
8440 case R_PPC64_GOT_TLSLD16:
8441 case R_PPC64_GOT_TLSLD16_LO:
8442 expecting_tls_get_addr = 1;
8443 found_tls_get_addr_arg = 1;
8444 /* Fall thru */
8445
8446 case R_PPC64_GOT_TLSLD16_HI:
8447 case R_PPC64_GOT_TLSLD16_HA:
8448 /* These relocs should never be against a symbol
8449 defined in a shared lib. Leave them alone if
8450 that turns out to be the case. */
8451 if (!is_local)
8452 continue;
8453
8454 /* LD -> LE */
8455 tls_set = 0;
8456 tls_clear = TLS_LD;
8457 tls_type = TLS_TLS | TLS_LD;
8458 break;
8459
8460 case R_PPC64_GOT_TLSGD16:
8461 case R_PPC64_GOT_TLSGD16_LO:
8462 expecting_tls_get_addr = 1;
8463 found_tls_get_addr_arg = 1;
8464 /* Fall thru */
8465
8466 case R_PPC64_GOT_TLSGD16_HI:
8467 case R_PPC64_GOT_TLSGD16_HA:
8468 if (ok_tprel)
8469 /* GD -> LE */
8470 tls_set = 0;
8471 else
8472 /* GD -> IE */
8473 tls_set = TLS_TLS | TLS_TPRELGD;
8474 tls_clear = TLS_GD;
8475 tls_type = TLS_TLS | TLS_GD;
8476 break;
8477
8478 case R_PPC64_GOT_TPREL16_DS:
8479 case R_PPC64_GOT_TPREL16_LO_DS:
8480 case R_PPC64_GOT_TPREL16_HI:
8481 case R_PPC64_GOT_TPREL16_HA:
8482 if (ok_tprel)
8483 {
8484 /* IE -> LE */
8485 tls_set = 0;
8486 tls_clear = TLS_TPREL;
8487 tls_type = TLS_TLS | TLS_TPREL;
8488 break;
8489 }
8490 continue;
8491
8492 case R_PPC64_TLSGD:
8493 case R_PPC64_TLSLD:
8494 found_tls_get_addr_arg = 1;
8495 /* Fall thru */
8496
8497 case R_PPC64_TLS:
8498 case R_PPC64_TOC16:
8499 case R_PPC64_TOC16_LO:
8500 if (sym_sec == NULL || sym_sec != toc)
8501 continue;
8502
8503 /* Mark this toc entry as referenced by a TLS
8504 code sequence. We can do that now in the
8505 case of R_PPC64_TLS, and after checking for
8506 tls_get_addr for the TOC16 relocs. */
8507 if (toc_ref == NULL)
8508 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8509 if (toc_ref == NULL)
8510 goto err_free_rel;
8511
8512 if (h != NULL)
8513 value = h->root.u.def.value;
8514 else
8515 value = sym->st_value;
8516 value += rel->r_addend;
8517 if (value % 8 != 0)
8518 continue;
8519 BFD_ASSERT (value < toc->size
8520 && toc->output_offset % 8 == 0);
8521 toc_ref_index = (value + toc->output_offset) / 8;
8522 if (r_type == R_PPC64_TLS
8523 || r_type == R_PPC64_TLSGD
8524 || r_type == R_PPC64_TLSLD)
8525 {
8526 toc_ref[toc_ref_index] = 1;
8527 continue;
8528 }
8529
8530 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8531 continue;
8532
8533 tls_set = 0;
8534 tls_clear = 0;
8535 expecting_tls_get_addr = 2;
8536 break;
8537
8538 case R_PPC64_TPREL64:
8539 if (pass == 0
8540 || sec != toc
8541 || toc_ref == NULL
8542 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8543 continue;
8544 if (ok_tprel)
8545 {
8546 /* IE -> LE */
8547 tls_set = TLS_EXPLICIT;
8548 tls_clear = TLS_TPREL;
8549 break;
8550 }
8551 continue;
8552
8553 case R_PPC64_DTPMOD64:
8554 if (pass == 0
8555 || sec != toc
8556 || toc_ref == NULL
8557 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8558 continue;
8559 if (rel + 1 < relend
8560 && (rel[1].r_info
8561 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8562 && rel[1].r_offset == rel->r_offset + 8)
8563 {
8564 if (ok_tprel)
8565 /* GD -> LE */
8566 tls_set = TLS_EXPLICIT | TLS_GD;
8567 else
8568 /* GD -> IE */
8569 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8570 tls_clear = TLS_GD;
8571 }
8572 else
8573 {
8574 if (!is_local)
8575 continue;
8576
8577 /* LD -> LE */
8578 tls_set = TLS_EXPLICIT;
8579 tls_clear = TLS_LD;
8580 }
8581 break;
8582
8583 default:
8584 continue;
8585 }
8586
8587 if (pass == 0)
8588 {
8589 if (!expecting_tls_get_addr
8590 || !sec->has_tls_get_addr_call)
8591 continue;
8592
8593 if (rel + 1 < relend
8594 && branch_reloc_hash_match (ibfd, rel + 1,
8595 htab->tls_get_addr,
8596 htab->tls_get_addr_fd))
8597 {
8598 if (expecting_tls_get_addr == 2)
8599 {
8600 /* Check for toc tls entries. */
8601 unsigned char *toc_tls;
8602 int retval;
8603
8604 retval = get_tls_mask (&toc_tls, NULL, NULL,
8605 &locsyms,
8606 rel, ibfd);
8607 if (retval == 0)
8608 goto err_free_rel;
8609 if (toc_tls != NULL)
8610 {
8611 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8612 found_tls_get_addr_arg = 1;
8613 if (retval > 1)
8614 toc_ref[toc_ref_index] = 1;
8615 }
8616 }
8617 continue;
8618 }
8619
8620 if (expecting_tls_get_addr != 1)
8621 continue;
8622
8623 /* Uh oh, we didn't find the expected call. We
8624 could just mark this symbol to exclude it
8625 from tls optimization but it's safer to skip
8626 the entire optimization. */
8627 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8628 "TLS optimization disabled\n"),
8629 ibfd, sec, rel->r_offset);
8630 ret = TRUE;
8631 goto err_free_rel;
8632 }
8633
8634 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8635 {
8636 struct plt_entry *ent;
8637 for (ent = htab->tls_get_addr->elf.plt.plist;
8638 ent != NULL;
8639 ent = ent->next)
8640 if (ent->addend == 0)
8641 {
8642 if (ent->plt.refcount > 0)
8643 {
8644 ent->plt.refcount -= 1;
8645 expecting_tls_get_addr = 0;
8646 }
8647 break;
8648 }
8649 }
8650
8651 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8652 {
8653 struct plt_entry *ent;
8654 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8655 ent != NULL;
8656 ent = ent->next)
8657 if (ent->addend == 0)
8658 {
8659 if (ent->plt.refcount > 0)
8660 ent->plt.refcount -= 1;
8661 break;
8662 }
8663 }
8664
8665 if (tls_clear == 0)
8666 continue;
8667
8668 if ((tls_set & TLS_EXPLICIT) == 0)
8669 {
8670 struct got_entry *ent;
8671
8672 /* Adjust got entry for this reloc. */
8673 if (h != NULL)
8674 ent = h->got.glist;
8675 else
8676 ent = elf_local_got_ents (ibfd)[r_symndx];
8677
8678 for (; ent != NULL; ent = ent->next)
8679 if (ent->addend == rel->r_addend
8680 && ent->owner == ibfd
8681 && ent->tls_type == tls_type)
8682 break;
8683 if (ent == NULL)
8684 abort ();
8685
8686 if (tls_set == 0)
8687 {
8688 /* We managed to get rid of a got entry. */
8689 if (ent->got.refcount > 0)
8690 ent->got.refcount -= 1;
8691 }
8692 }
8693 else
8694 {
8695 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8696 we'll lose one or two dyn relocs. */
8697 if (!dec_dynrel_count (rel->r_info, sec, info,
8698 NULL, h, sym))
8699 return FALSE;
8700
8701 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8702 {
8703 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8704 NULL, h, sym))
8705 return FALSE;
8706 }
8707 }
8708
8709 *tls_mask |= tls_set;
8710 *tls_mask &= ~tls_clear;
8711 }
8712
8713 if (elf_section_data (sec)->relocs != relstart)
8714 free (relstart);
8715 }
8716
8717 if (locsyms != NULL
8718 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8719 {
8720 if (!info->keep_memory)
8721 free (locsyms);
8722 else
8723 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8724 }
8725 }
8726
8727 if (toc_ref != NULL)
8728 free (toc_ref);
8729 return TRUE;
8730 }
8731
8732 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8733 the values of any global symbols in a toc section that has been
8734 edited. Globals in toc sections should be a rarity, so this function
8735 sets a flag if any are found in toc sections other than the one just
8736 edited, so that futher hash table traversals can be avoided. */
8737
8738 struct adjust_toc_info
8739 {
8740 asection *toc;
8741 unsigned long *skip;
8742 bfd_boolean global_toc_syms;
8743 };
8744
8745 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8746
8747 static bfd_boolean
8748 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8749 {
8750 struct ppc_link_hash_entry *eh;
8751 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8752 unsigned long i;
8753
8754 if (h->root.type != bfd_link_hash_defined
8755 && h->root.type != bfd_link_hash_defweak)
8756 return TRUE;
8757
8758 eh = (struct ppc_link_hash_entry *) h;
8759 if (eh->adjust_done)
8760 return TRUE;
8761
8762 if (eh->elf.root.u.def.section == toc_inf->toc)
8763 {
8764 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8765 i = toc_inf->toc->rawsize >> 3;
8766 else
8767 i = eh->elf.root.u.def.value >> 3;
8768
8769 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8770 {
8771 (*_bfd_error_handler)
8772 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8773 do
8774 ++i;
8775 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8776 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8777 }
8778
8779 eh->elf.root.u.def.value -= toc_inf->skip[i];
8780 eh->adjust_done = 1;
8781 }
8782 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8783 toc_inf->global_toc_syms = TRUE;
8784
8785 return TRUE;
8786 }
8787
8788 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8789
8790 static bfd_boolean
8791 ok_lo_toc_insn (unsigned int insn)
8792 {
8793 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8794 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8795 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8796 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8797 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8798 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8799 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8800 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8801 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8802 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8803 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8804 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8805 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8806 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8807 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8808 && (insn & 3) != 1)
8809 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8810 && ((insn & 3) == 0 || (insn & 3) == 3))
8811 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8812 }
8813
8814 /* Examine all relocs referencing .toc sections in order to remove
8815 unused .toc entries. */
8816
8817 bfd_boolean
8818 ppc64_elf_edit_toc (struct bfd_link_info *info)
8819 {
8820 bfd *ibfd;
8821 struct adjust_toc_info toc_inf;
8822 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8823
8824 htab->do_toc_opt = 1;
8825 toc_inf.global_toc_syms = TRUE;
8826 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8827 {
8828 asection *toc, *sec;
8829 Elf_Internal_Shdr *symtab_hdr;
8830 Elf_Internal_Sym *local_syms;
8831 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8832 unsigned long *skip, *drop;
8833 unsigned char *used;
8834 unsigned char *keep, last, some_unused;
8835
8836 if (!is_ppc64_elf (ibfd))
8837 continue;
8838
8839 toc = bfd_get_section_by_name (ibfd, ".toc");
8840 if (toc == NULL
8841 || toc->size == 0
8842 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8843 || discarded_section (toc))
8844 continue;
8845
8846 toc_relocs = NULL;
8847 local_syms = NULL;
8848 symtab_hdr = &elf_symtab_hdr (ibfd);
8849
8850 /* Look at sections dropped from the final link. */
8851 skip = NULL;
8852 relstart = NULL;
8853 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8854 {
8855 if (sec->reloc_count == 0
8856 || !discarded_section (sec)
8857 || get_opd_info (sec)
8858 || (sec->flags & SEC_ALLOC) == 0
8859 || (sec->flags & SEC_DEBUGGING) != 0)
8860 continue;
8861
8862 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8863 if (relstart == NULL)
8864 goto error_ret;
8865
8866 /* Run through the relocs to see which toc entries might be
8867 unused. */
8868 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8869 {
8870 enum elf_ppc64_reloc_type r_type;
8871 unsigned long r_symndx;
8872 asection *sym_sec;
8873 struct elf_link_hash_entry *h;
8874 Elf_Internal_Sym *sym;
8875 bfd_vma val;
8876
8877 r_type = ELF64_R_TYPE (rel->r_info);
8878 switch (r_type)
8879 {
8880 default:
8881 continue;
8882
8883 case R_PPC64_TOC16:
8884 case R_PPC64_TOC16_LO:
8885 case R_PPC64_TOC16_HI:
8886 case R_PPC64_TOC16_HA:
8887 case R_PPC64_TOC16_DS:
8888 case R_PPC64_TOC16_LO_DS:
8889 break;
8890 }
8891
8892 r_symndx = ELF64_R_SYM (rel->r_info);
8893 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8894 r_symndx, ibfd))
8895 goto error_ret;
8896
8897 if (sym_sec != toc)
8898 continue;
8899
8900 if (h != NULL)
8901 val = h->root.u.def.value;
8902 else
8903 val = sym->st_value;
8904 val += rel->r_addend;
8905
8906 if (val >= toc->size)
8907 continue;
8908
8909 /* Anything in the toc ought to be aligned to 8 bytes.
8910 If not, don't mark as unused. */
8911 if (val & 7)
8912 continue;
8913
8914 if (skip == NULL)
8915 {
8916 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8917 if (skip == NULL)
8918 goto error_ret;
8919 }
8920
8921 skip[val >> 3] = ref_from_discarded;
8922 }
8923
8924 if (elf_section_data (sec)->relocs != relstart)
8925 free (relstart);
8926 }
8927
8928 /* For largetoc loads of address constants, we can convert
8929 . addis rx,2,addr@got@ha
8930 . ld ry,addr@got@l(rx)
8931 to
8932 . addis rx,2,addr@toc@ha
8933 . addi ry,rx,addr@toc@l
8934 when addr is within 2G of the toc pointer. This then means
8935 that the word storing "addr" in the toc is no longer needed. */
8936
8937 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8938 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8939 && toc->reloc_count != 0)
8940 {
8941 /* Read toc relocs. */
8942 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8943 info->keep_memory);
8944 if (toc_relocs == NULL)
8945 goto error_ret;
8946
8947 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8948 {
8949 enum elf_ppc64_reloc_type r_type;
8950 unsigned long r_symndx;
8951 asection *sym_sec;
8952 struct elf_link_hash_entry *h;
8953 Elf_Internal_Sym *sym;
8954 bfd_vma val, addr;
8955
8956 r_type = ELF64_R_TYPE (rel->r_info);
8957 if (r_type != R_PPC64_ADDR64)
8958 continue;
8959
8960 r_symndx = ELF64_R_SYM (rel->r_info);
8961 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8962 r_symndx, ibfd))
8963 goto error_ret;
8964
8965 if (sym_sec == NULL
8966 || sym_sec->output_section == NULL
8967 || discarded_section (sym_sec))
8968 continue;
8969
8970 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8971 continue;
8972
8973 if (h != NULL)
8974 {
8975 if (h->type == STT_GNU_IFUNC)
8976 continue;
8977 val = h->root.u.def.value;
8978 }
8979 else
8980 {
8981 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8982 continue;
8983 val = sym->st_value;
8984 }
8985 val += rel->r_addend;
8986 val += sym_sec->output_section->vma + sym_sec->output_offset;
8987
8988 /* We don't yet know the exact toc pointer value, but we
8989 know it will be somewhere in the toc section. Don't
8990 optimize if the difference from any possible toc
8991 pointer is outside [ff..f80008000, 7fff7fff]. */
8992 addr = toc->output_section->vma + TOC_BASE_OFF;
8993 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8994 continue;
8995
8996 addr = toc->output_section->vma + toc->output_section->rawsize;
8997 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8998 continue;
8999
9000 if (skip == NULL)
9001 {
9002 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9003 if (skip == NULL)
9004 goto error_ret;
9005 }
9006
9007 skip[rel->r_offset >> 3]
9008 |= can_optimize | ((rel - toc_relocs) << 2);
9009 }
9010 }
9011
9012 if (skip == NULL)
9013 continue;
9014
9015 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9016 if (used == NULL)
9017 {
9018 error_ret:
9019 if (local_syms != NULL
9020 && symtab_hdr->contents != (unsigned char *) local_syms)
9021 free (local_syms);
9022 if (sec != NULL
9023 && relstart != NULL
9024 && elf_section_data (sec)->relocs != relstart)
9025 free (relstart);
9026 if (toc_relocs != NULL
9027 && elf_section_data (toc)->relocs != toc_relocs)
9028 free (toc_relocs);
9029 if (skip != NULL)
9030 free (skip);
9031 return FALSE;
9032 }
9033
9034 /* Now check all kept sections that might reference the toc.
9035 Check the toc itself last. */
9036 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9037 : ibfd->sections);
9038 sec != NULL;
9039 sec = (sec == toc ? NULL
9040 : sec->next == NULL ? toc
9041 : sec->next == toc && toc->next ? toc->next
9042 : sec->next))
9043 {
9044 int repeat;
9045
9046 if (sec->reloc_count == 0
9047 || discarded_section (sec)
9048 || get_opd_info (sec)
9049 || (sec->flags & SEC_ALLOC) == 0
9050 || (sec->flags & SEC_DEBUGGING) != 0)
9051 continue;
9052
9053 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9054 info->keep_memory);
9055 if (relstart == NULL)
9056 {
9057 free (used);
9058 goto error_ret;
9059 }
9060
9061 /* Mark toc entries referenced as used. */
9062 do
9063 {
9064 repeat = 0;
9065 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9066 {
9067 enum elf_ppc64_reloc_type r_type;
9068 unsigned long r_symndx;
9069 asection *sym_sec;
9070 struct elf_link_hash_entry *h;
9071 Elf_Internal_Sym *sym;
9072 bfd_vma val;
9073 enum {no_check, check_lo, check_ha} insn_check;
9074
9075 r_type = ELF64_R_TYPE (rel->r_info);
9076 switch (r_type)
9077 {
9078 default:
9079 insn_check = no_check;
9080 break;
9081
9082 case R_PPC64_GOT_TLSLD16_HA:
9083 case R_PPC64_GOT_TLSGD16_HA:
9084 case R_PPC64_GOT_TPREL16_HA:
9085 case R_PPC64_GOT_DTPREL16_HA:
9086 case R_PPC64_GOT16_HA:
9087 case R_PPC64_TOC16_HA:
9088 insn_check = check_ha;
9089 break;
9090
9091 case R_PPC64_GOT_TLSLD16_LO:
9092 case R_PPC64_GOT_TLSGD16_LO:
9093 case R_PPC64_GOT_TPREL16_LO_DS:
9094 case R_PPC64_GOT_DTPREL16_LO_DS:
9095 case R_PPC64_GOT16_LO:
9096 case R_PPC64_GOT16_LO_DS:
9097 case R_PPC64_TOC16_LO:
9098 case R_PPC64_TOC16_LO_DS:
9099 insn_check = check_lo;
9100 break;
9101 }
9102
9103 if (insn_check != no_check)
9104 {
9105 bfd_vma off = rel->r_offset & ~3;
9106 unsigned char buf[4];
9107 unsigned int insn;
9108
9109 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9110 {
9111 free (used);
9112 goto error_ret;
9113 }
9114 insn = bfd_get_32 (ibfd, buf);
9115 if (insn_check == check_lo
9116 ? !ok_lo_toc_insn (insn)
9117 : ((insn & ((0x3f << 26) | 0x1f << 16))
9118 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9119 {
9120 char str[12];
9121
9122 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9123 sprintf (str, "%#08x", insn);
9124 info->callbacks->einfo
9125 (_("%P: %H: toc optimization is not supported for"
9126 " %s instruction.\n"),
9127 ibfd, sec, rel->r_offset & ~3, str);
9128 }
9129 }
9130
9131 switch (r_type)
9132 {
9133 case R_PPC64_TOC16:
9134 case R_PPC64_TOC16_LO:
9135 case R_PPC64_TOC16_HI:
9136 case R_PPC64_TOC16_HA:
9137 case R_PPC64_TOC16_DS:
9138 case R_PPC64_TOC16_LO_DS:
9139 /* In case we're taking addresses of toc entries. */
9140 case R_PPC64_ADDR64:
9141 break;
9142
9143 default:
9144 continue;
9145 }
9146
9147 r_symndx = ELF64_R_SYM (rel->r_info);
9148 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9149 r_symndx, ibfd))
9150 {
9151 free (used);
9152 goto error_ret;
9153 }
9154
9155 if (sym_sec != toc)
9156 continue;
9157
9158 if (h != NULL)
9159 val = h->root.u.def.value;
9160 else
9161 val = sym->st_value;
9162 val += rel->r_addend;
9163
9164 if (val >= toc->size)
9165 continue;
9166
9167 if ((skip[val >> 3] & can_optimize) != 0)
9168 {
9169 bfd_vma off;
9170 unsigned char opc;
9171
9172 switch (r_type)
9173 {
9174 case R_PPC64_TOC16_HA:
9175 break;
9176
9177 case R_PPC64_TOC16_LO_DS:
9178 off = rel->r_offset;
9179 off += (bfd_big_endian (ibfd) ? -2 : 3);
9180 if (!bfd_get_section_contents (ibfd, sec, &opc,
9181 off, 1))
9182 {
9183 free (used);
9184 goto error_ret;
9185 }
9186 if ((opc & (0x3f << 2)) == (58u << 2))
9187 break;
9188 /* Fall thru */
9189
9190 default:
9191 /* Wrong sort of reloc, or not a ld. We may
9192 as well clear ref_from_discarded too. */
9193 skip[val >> 3] = 0;
9194 }
9195 }
9196
9197 if (sec != toc)
9198 used[val >> 3] = 1;
9199 /* For the toc section, we only mark as used if this
9200 entry itself isn't unused. */
9201 else if ((used[rel->r_offset >> 3]
9202 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9203 && !used[val >> 3])
9204 {
9205 /* Do all the relocs again, to catch reference
9206 chains. */
9207 repeat = 1;
9208 used[val >> 3] = 1;
9209 }
9210 }
9211 }
9212 while (repeat);
9213
9214 if (elf_section_data (sec)->relocs != relstart)
9215 free (relstart);
9216 }
9217
9218 /* Merge the used and skip arrays. Assume that TOC
9219 doublewords not appearing as either used or unused belong
9220 to to an entry more than one doubleword in size. */
9221 for (drop = skip, keep = used, last = 0, some_unused = 0;
9222 drop < skip + (toc->size + 7) / 8;
9223 ++drop, ++keep)
9224 {
9225 if (*keep)
9226 {
9227 *drop &= ~ref_from_discarded;
9228 if ((*drop & can_optimize) != 0)
9229 some_unused = 1;
9230 last = 0;
9231 }
9232 else if ((*drop & ref_from_discarded) != 0)
9233 {
9234 some_unused = 1;
9235 last = ref_from_discarded;
9236 }
9237 else
9238 *drop = last;
9239 }
9240
9241 free (used);
9242
9243 if (some_unused)
9244 {
9245 bfd_byte *contents, *src;
9246 unsigned long off;
9247 Elf_Internal_Sym *sym;
9248 bfd_boolean local_toc_syms = FALSE;
9249
9250 /* Shuffle the toc contents, and at the same time convert the
9251 skip array from booleans into offsets. */
9252 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9253 goto error_ret;
9254
9255 elf_section_data (toc)->this_hdr.contents = contents;
9256
9257 for (src = contents, off = 0, drop = skip;
9258 src < contents + toc->size;
9259 src += 8, ++drop)
9260 {
9261 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9262 off += 8;
9263 else if (off != 0)
9264 {
9265 *drop = off;
9266 memcpy (src - off, src, 8);
9267 }
9268 }
9269 *drop = off;
9270 toc->rawsize = toc->size;
9271 toc->size = src - contents - off;
9272
9273 /* Adjust addends for relocs against the toc section sym,
9274 and optimize any accesses we can. */
9275 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9276 {
9277 if (sec->reloc_count == 0
9278 || discarded_section (sec))
9279 continue;
9280
9281 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9282 info->keep_memory);
9283 if (relstart == NULL)
9284 goto error_ret;
9285
9286 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9287 {
9288 enum elf_ppc64_reloc_type r_type;
9289 unsigned long r_symndx;
9290 asection *sym_sec;
9291 struct elf_link_hash_entry *h;
9292 bfd_vma val;
9293
9294 r_type = ELF64_R_TYPE (rel->r_info);
9295 switch (r_type)
9296 {
9297 default:
9298 continue;
9299
9300 case R_PPC64_TOC16:
9301 case R_PPC64_TOC16_LO:
9302 case R_PPC64_TOC16_HI:
9303 case R_PPC64_TOC16_HA:
9304 case R_PPC64_TOC16_DS:
9305 case R_PPC64_TOC16_LO_DS:
9306 case R_PPC64_ADDR64:
9307 break;
9308 }
9309
9310 r_symndx = ELF64_R_SYM (rel->r_info);
9311 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9312 r_symndx, ibfd))
9313 goto error_ret;
9314
9315 if (sym_sec != toc)
9316 continue;
9317
9318 if (h != NULL)
9319 val = h->root.u.def.value;
9320 else
9321 {
9322 val = sym->st_value;
9323 if (val != 0)
9324 local_toc_syms = TRUE;
9325 }
9326
9327 val += rel->r_addend;
9328
9329 if (val > toc->rawsize)
9330 val = toc->rawsize;
9331 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9332 continue;
9333 else if ((skip[val >> 3] & can_optimize) != 0)
9334 {
9335 Elf_Internal_Rela *tocrel
9336 = toc_relocs + (skip[val >> 3] >> 2);
9337 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9338
9339 switch (r_type)
9340 {
9341 case R_PPC64_TOC16_HA:
9342 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9343 break;
9344
9345 case R_PPC64_TOC16_LO_DS:
9346 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9347 break;
9348
9349 default:
9350 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9351 ppc_howto_init ();
9352 info->callbacks->einfo
9353 (_("%P: %H: %s references "
9354 "optimized away TOC entry\n"),
9355 ibfd, sec, rel->r_offset,
9356 ppc64_elf_howto_table[r_type]->name);
9357 bfd_set_error (bfd_error_bad_value);
9358 goto error_ret;
9359 }
9360 rel->r_addend = tocrel->r_addend;
9361 elf_section_data (sec)->relocs = relstart;
9362 continue;
9363 }
9364
9365 if (h != NULL || sym->st_value != 0)
9366 continue;
9367
9368 rel->r_addend -= skip[val >> 3];
9369 elf_section_data (sec)->relocs = relstart;
9370 }
9371
9372 if (elf_section_data (sec)->relocs != relstart)
9373 free (relstart);
9374 }
9375
9376 /* We shouldn't have local or global symbols defined in the TOC,
9377 but handle them anyway. */
9378 if (local_syms != NULL)
9379 for (sym = local_syms;
9380 sym < local_syms + symtab_hdr->sh_info;
9381 ++sym)
9382 if (sym->st_value != 0
9383 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9384 {
9385 unsigned long i;
9386
9387 if (sym->st_value > toc->rawsize)
9388 i = toc->rawsize >> 3;
9389 else
9390 i = sym->st_value >> 3;
9391
9392 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9393 {
9394 if (local_toc_syms)
9395 (*_bfd_error_handler)
9396 (_("%s defined on removed toc entry"),
9397 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9398 do
9399 ++i;
9400 while ((skip[i] & (ref_from_discarded | can_optimize)));
9401 sym->st_value = (bfd_vma) i << 3;
9402 }
9403
9404 sym->st_value -= skip[i];
9405 symtab_hdr->contents = (unsigned char *) local_syms;
9406 }
9407
9408 /* Adjust any global syms defined in this toc input section. */
9409 if (toc_inf.global_toc_syms)
9410 {
9411 toc_inf.toc = toc;
9412 toc_inf.skip = skip;
9413 toc_inf.global_toc_syms = FALSE;
9414 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9415 &toc_inf);
9416 }
9417
9418 if (toc->reloc_count != 0)
9419 {
9420 Elf_Internal_Shdr *rel_hdr;
9421 Elf_Internal_Rela *wrel;
9422 bfd_size_type sz;
9423
9424 /* Remove unused toc relocs, and adjust those we keep. */
9425 if (toc_relocs == NULL)
9426 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9427 info->keep_memory);
9428 if (toc_relocs == NULL)
9429 goto error_ret;
9430
9431 wrel = toc_relocs;
9432 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9433 if ((skip[rel->r_offset >> 3]
9434 & (ref_from_discarded | can_optimize)) == 0)
9435 {
9436 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9437 wrel->r_info = rel->r_info;
9438 wrel->r_addend = rel->r_addend;
9439 ++wrel;
9440 }
9441 else if (!dec_dynrel_count (rel->r_info, toc, info,
9442 &local_syms, NULL, NULL))
9443 goto error_ret;
9444
9445 elf_section_data (toc)->relocs = toc_relocs;
9446 toc->reloc_count = wrel - toc_relocs;
9447 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9448 sz = rel_hdr->sh_entsize;
9449 rel_hdr->sh_size = toc->reloc_count * sz;
9450 }
9451 }
9452 else if (toc_relocs != NULL
9453 && elf_section_data (toc)->relocs != toc_relocs)
9454 free (toc_relocs);
9455
9456 if (local_syms != NULL
9457 && symtab_hdr->contents != (unsigned char *) local_syms)
9458 {
9459 if (!info->keep_memory)
9460 free (local_syms);
9461 else
9462 symtab_hdr->contents = (unsigned char *) local_syms;
9463 }
9464 free (skip);
9465 }
9466
9467 return TRUE;
9468 }
9469
9470 /* Return true iff input section I references the TOC using
9471 instructions limited to +/-32k offsets. */
9472
9473 bfd_boolean
9474 ppc64_elf_has_small_toc_reloc (asection *i)
9475 {
9476 return (is_ppc64_elf (i->owner)
9477 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9478 }
9479
9480 /* Allocate space for one GOT entry. */
9481
9482 static void
9483 allocate_got (struct elf_link_hash_entry *h,
9484 struct bfd_link_info *info,
9485 struct got_entry *gent)
9486 {
9487 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9488 bfd_boolean dyn;
9489 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9490 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9491 ? 16 : 8);
9492 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9493 ? 2 : 1) * sizeof (Elf64_External_Rela);
9494 asection *got = ppc64_elf_tdata (gent->owner)->got;
9495
9496 gent->got.offset = got->size;
9497 got->size += entsize;
9498
9499 dyn = htab->elf.dynamic_sections_created;
9500 if (h->type == STT_GNU_IFUNC)
9501 {
9502 htab->elf.irelplt->size += rentsize;
9503 htab->got_reli_size += rentsize;
9504 }
9505 else if ((bfd_link_pic (info)
9506 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9507 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9508 || h->root.type != bfd_link_hash_undefweak))
9509 {
9510 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9511 relgot->size += rentsize;
9512 }
9513 }
9514
9515 /* This function merges got entries in the same toc group. */
9516
9517 static void
9518 merge_got_entries (struct got_entry **pent)
9519 {
9520 struct got_entry *ent, *ent2;
9521
9522 for (ent = *pent; ent != NULL; ent = ent->next)
9523 if (!ent->is_indirect)
9524 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9525 if (!ent2->is_indirect
9526 && ent2->addend == ent->addend
9527 && ent2->tls_type == ent->tls_type
9528 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9529 {
9530 ent2->is_indirect = TRUE;
9531 ent2->got.ent = ent;
9532 }
9533 }
9534
9535 /* Allocate space in .plt, .got and associated reloc sections for
9536 dynamic relocs. */
9537
9538 static bfd_boolean
9539 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9540 {
9541 struct bfd_link_info *info;
9542 struct ppc_link_hash_table *htab;
9543 asection *s;
9544 struct ppc_link_hash_entry *eh;
9545 struct elf_dyn_relocs *p;
9546 struct got_entry **pgent, *gent;
9547
9548 if (h->root.type == bfd_link_hash_indirect)
9549 return TRUE;
9550
9551 info = (struct bfd_link_info *) inf;
9552 htab = ppc_hash_table (info);
9553 if (htab == NULL)
9554 return FALSE;
9555
9556 if ((htab->elf.dynamic_sections_created
9557 && h->dynindx != -1
9558 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9559 || h->type == STT_GNU_IFUNC)
9560 {
9561 struct plt_entry *pent;
9562 bfd_boolean doneone = FALSE;
9563 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9564 if (pent->plt.refcount > 0)
9565 {
9566 if (!htab->elf.dynamic_sections_created
9567 || h->dynindx == -1)
9568 {
9569 s = htab->elf.iplt;
9570 pent->plt.offset = s->size;
9571 s->size += PLT_ENTRY_SIZE (htab);
9572 s = htab->elf.irelplt;
9573 }
9574 else
9575 {
9576 /* If this is the first .plt entry, make room for the special
9577 first entry. */
9578 s = htab->elf.splt;
9579 if (s->size == 0)
9580 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9581
9582 pent->plt.offset = s->size;
9583
9584 /* Make room for this entry. */
9585 s->size += PLT_ENTRY_SIZE (htab);
9586
9587 /* Make room for the .glink code. */
9588 s = htab->glink;
9589 if (s->size == 0)
9590 s->size += GLINK_CALL_STUB_SIZE;
9591 if (htab->opd_abi)
9592 {
9593 /* We need bigger stubs past index 32767. */
9594 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9595 s->size += 4;
9596 s->size += 2*4;
9597 }
9598 else
9599 s->size += 4;
9600
9601 /* We also need to make an entry in the .rela.plt section. */
9602 s = htab->elf.srelplt;
9603 }
9604 s->size += sizeof (Elf64_External_Rela);
9605 doneone = TRUE;
9606 }
9607 else
9608 pent->plt.offset = (bfd_vma) -1;
9609 if (!doneone)
9610 {
9611 h->plt.plist = NULL;
9612 h->needs_plt = 0;
9613 }
9614 }
9615 else
9616 {
9617 h->plt.plist = NULL;
9618 h->needs_plt = 0;
9619 }
9620
9621 eh = (struct ppc_link_hash_entry *) h;
9622 /* Run through the TLS GD got entries first if we're changing them
9623 to TPREL. */
9624 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9625 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9626 if (gent->got.refcount > 0
9627 && (gent->tls_type & TLS_GD) != 0)
9628 {
9629 /* This was a GD entry that has been converted to TPREL. If
9630 there happens to be a TPREL entry we can use that one. */
9631 struct got_entry *ent;
9632 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9633 if (ent->got.refcount > 0
9634 && (ent->tls_type & TLS_TPREL) != 0
9635 && ent->addend == gent->addend
9636 && ent->owner == gent->owner)
9637 {
9638 gent->got.refcount = 0;
9639 break;
9640 }
9641
9642 /* If not, then we'll be using our own TPREL entry. */
9643 if (gent->got.refcount != 0)
9644 gent->tls_type = TLS_TLS | TLS_TPREL;
9645 }
9646
9647 /* Remove any list entry that won't generate a word in the GOT before
9648 we call merge_got_entries. Otherwise we risk merging to empty
9649 entries. */
9650 pgent = &h->got.glist;
9651 while ((gent = *pgent) != NULL)
9652 if (gent->got.refcount > 0)
9653 {
9654 if ((gent->tls_type & TLS_LD) != 0
9655 && !h->def_dynamic)
9656 {
9657 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9658 *pgent = gent->next;
9659 }
9660 else
9661 pgent = &gent->next;
9662 }
9663 else
9664 *pgent = gent->next;
9665
9666 if (!htab->do_multi_toc)
9667 merge_got_entries (&h->got.glist);
9668
9669 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9670 if (!gent->is_indirect)
9671 {
9672 /* Make sure this symbol is output as a dynamic symbol.
9673 Undefined weak syms won't yet be marked as dynamic,
9674 nor will all TLS symbols. */
9675 if (h->dynindx == -1
9676 && !h->forced_local
9677 && h->type != STT_GNU_IFUNC
9678 && htab->elf.dynamic_sections_created)
9679 {
9680 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9681 return FALSE;
9682 }
9683
9684 if (!is_ppc64_elf (gent->owner))
9685 abort ();
9686
9687 allocate_got (h, info, gent);
9688 }
9689
9690 if (eh->dyn_relocs == NULL
9691 || (!htab->elf.dynamic_sections_created
9692 && h->type != STT_GNU_IFUNC))
9693 return TRUE;
9694
9695 /* In the shared -Bsymbolic case, discard space allocated for
9696 dynamic pc-relative relocs against symbols which turn out to be
9697 defined in regular objects. For the normal shared case, discard
9698 space for relocs that have become local due to symbol visibility
9699 changes. */
9700
9701 if (bfd_link_pic (info))
9702 {
9703 /* Relocs that use pc_count are those that appear on a call insn,
9704 or certain REL relocs (see must_be_dyn_reloc) that can be
9705 generated via assembly. We want calls to protected symbols to
9706 resolve directly to the function rather than going via the plt.
9707 If people want function pointer comparisons to work as expected
9708 then they should avoid writing weird assembly. */
9709 if (SYMBOL_CALLS_LOCAL (info, h))
9710 {
9711 struct elf_dyn_relocs **pp;
9712
9713 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9714 {
9715 p->count -= p->pc_count;
9716 p->pc_count = 0;
9717 if (p->count == 0)
9718 *pp = p->next;
9719 else
9720 pp = &p->next;
9721 }
9722 }
9723
9724 /* Also discard relocs on undefined weak syms with non-default
9725 visibility. */
9726 if (eh->dyn_relocs != NULL
9727 && h->root.type == bfd_link_hash_undefweak)
9728 {
9729 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9730 eh->dyn_relocs = NULL;
9731
9732 /* Make sure this symbol is output as a dynamic symbol.
9733 Undefined weak syms won't yet be marked as dynamic. */
9734 else if (h->dynindx == -1
9735 && !h->forced_local)
9736 {
9737 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9738 return FALSE;
9739 }
9740 }
9741 }
9742 else if (h->type == STT_GNU_IFUNC)
9743 {
9744 if (!h->non_got_ref)
9745 eh->dyn_relocs = NULL;
9746 }
9747 else if (ELIMINATE_COPY_RELOCS)
9748 {
9749 /* For the non-shared case, discard space for relocs against
9750 symbols which turn out to need copy relocs or are not
9751 dynamic. */
9752
9753 if (!h->non_got_ref
9754 && !h->def_regular)
9755 {
9756 /* Make sure this symbol is output as a dynamic symbol.
9757 Undefined weak syms won't yet be marked as dynamic. */
9758 if (h->dynindx == -1
9759 && !h->forced_local)
9760 {
9761 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9762 return FALSE;
9763 }
9764
9765 /* If that succeeded, we know we'll be keeping all the
9766 relocs. */
9767 if (h->dynindx != -1)
9768 goto keep;
9769 }
9770
9771 eh->dyn_relocs = NULL;
9772
9773 keep: ;
9774 }
9775
9776 /* Finally, allocate space. */
9777 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9778 {
9779 asection *sreloc = elf_section_data (p->sec)->sreloc;
9780 if (eh->elf.type == STT_GNU_IFUNC)
9781 sreloc = htab->elf.irelplt;
9782 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9783 }
9784
9785 return TRUE;
9786 }
9787
9788 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9789 to set up space for global entry stubs. These are put in glink,
9790 after the branch table. */
9791
9792 static bfd_boolean
9793 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9794 {
9795 struct bfd_link_info *info;
9796 struct ppc_link_hash_table *htab;
9797 struct plt_entry *pent;
9798 asection *s;
9799
9800 if (h->root.type == bfd_link_hash_indirect)
9801 return TRUE;
9802
9803 if (!h->pointer_equality_needed)
9804 return TRUE;
9805
9806 if (h->def_regular)
9807 return TRUE;
9808
9809 info = inf;
9810 htab = ppc_hash_table (info);
9811 if (htab == NULL)
9812 return FALSE;
9813
9814 s = htab->glink;
9815 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9816 if (pent->plt.offset != (bfd_vma) -1
9817 && pent->addend == 0)
9818 {
9819 /* For ELFv2, if this symbol is not defined in a regular file
9820 and we are not generating a shared library or pie, then we
9821 need to define the symbol in the executable on a call stub.
9822 This is to avoid text relocations. */
9823 s->size = (s->size + 15) & -16;
9824 h->root.u.def.section = s;
9825 h->root.u.def.value = s->size;
9826 s->size += 16;
9827 break;
9828 }
9829 return TRUE;
9830 }
9831
9832 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9833 read-only sections. */
9834
9835 static bfd_boolean
9836 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9837 {
9838 if (h->root.type == bfd_link_hash_indirect)
9839 return TRUE;
9840
9841 if (readonly_dynrelocs (h))
9842 {
9843 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9844
9845 /* Not an error, just cut short the traversal. */
9846 return FALSE;
9847 }
9848 return TRUE;
9849 }
9850
9851 /* Set the sizes of the dynamic sections. */
9852
9853 static bfd_boolean
9854 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9855 struct bfd_link_info *info)
9856 {
9857 struct ppc_link_hash_table *htab;
9858 bfd *dynobj;
9859 asection *s;
9860 bfd_boolean relocs;
9861 bfd *ibfd;
9862 struct got_entry *first_tlsld;
9863
9864 htab = ppc_hash_table (info);
9865 if (htab == NULL)
9866 return FALSE;
9867
9868 dynobj = htab->elf.dynobj;
9869 if (dynobj == NULL)
9870 abort ();
9871
9872 if (htab->elf.dynamic_sections_created)
9873 {
9874 /* Set the contents of the .interp section to the interpreter. */
9875 if (bfd_link_executable (info) && !info->nointerp)
9876 {
9877 s = bfd_get_linker_section (dynobj, ".interp");
9878 if (s == NULL)
9879 abort ();
9880 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9881 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9882 }
9883 }
9884
9885 /* Set up .got offsets for local syms, and space for local dynamic
9886 relocs. */
9887 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9888 {
9889 struct got_entry **lgot_ents;
9890 struct got_entry **end_lgot_ents;
9891 struct plt_entry **local_plt;
9892 struct plt_entry **end_local_plt;
9893 unsigned char *lgot_masks;
9894 bfd_size_type locsymcount;
9895 Elf_Internal_Shdr *symtab_hdr;
9896
9897 if (!is_ppc64_elf (ibfd))
9898 continue;
9899
9900 for (s = ibfd->sections; s != NULL; s = s->next)
9901 {
9902 struct ppc_dyn_relocs *p;
9903
9904 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9905 {
9906 if (!bfd_is_abs_section (p->sec)
9907 && bfd_is_abs_section (p->sec->output_section))
9908 {
9909 /* Input section has been discarded, either because
9910 it is a copy of a linkonce section or due to
9911 linker script /DISCARD/, so we'll be discarding
9912 the relocs too. */
9913 }
9914 else if (p->count != 0)
9915 {
9916 asection *srel = elf_section_data (p->sec)->sreloc;
9917 if (p->ifunc)
9918 srel = htab->elf.irelplt;
9919 srel->size += p->count * sizeof (Elf64_External_Rela);
9920 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9921 info->flags |= DF_TEXTREL;
9922 }
9923 }
9924 }
9925
9926 lgot_ents = elf_local_got_ents (ibfd);
9927 if (!lgot_ents)
9928 continue;
9929
9930 symtab_hdr = &elf_symtab_hdr (ibfd);
9931 locsymcount = symtab_hdr->sh_info;
9932 end_lgot_ents = lgot_ents + locsymcount;
9933 local_plt = (struct plt_entry **) end_lgot_ents;
9934 end_local_plt = local_plt + locsymcount;
9935 lgot_masks = (unsigned char *) end_local_plt;
9936 s = ppc64_elf_tdata (ibfd)->got;
9937 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9938 {
9939 struct got_entry **pent, *ent;
9940
9941 pent = lgot_ents;
9942 while ((ent = *pent) != NULL)
9943 if (ent->got.refcount > 0)
9944 {
9945 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9946 {
9947 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9948 *pent = ent->next;
9949 }
9950 else
9951 {
9952 unsigned int ent_size = 8;
9953 unsigned int rel_size = sizeof (Elf64_External_Rela);
9954
9955 ent->got.offset = s->size;
9956 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9957 {
9958 ent_size *= 2;
9959 rel_size *= 2;
9960 }
9961 s->size += ent_size;
9962 if ((*lgot_masks & PLT_IFUNC) != 0)
9963 {
9964 htab->elf.irelplt->size += rel_size;
9965 htab->got_reli_size += rel_size;
9966 }
9967 else if (bfd_link_pic (info))
9968 {
9969 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9970 srel->size += rel_size;
9971 }
9972 pent = &ent->next;
9973 }
9974 }
9975 else
9976 *pent = ent->next;
9977 }
9978
9979 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9980 for (; local_plt < end_local_plt; ++local_plt)
9981 {
9982 struct plt_entry *ent;
9983
9984 for (ent = *local_plt; ent != NULL; ent = ent->next)
9985 if (ent->plt.refcount > 0)
9986 {
9987 s = htab->elf.iplt;
9988 ent->plt.offset = s->size;
9989 s->size += PLT_ENTRY_SIZE (htab);
9990
9991 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9992 }
9993 else
9994 ent->plt.offset = (bfd_vma) -1;
9995 }
9996 }
9997
9998 /* Allocate global sym .plt and .got entries, and space for global
9999 sym dynamic relocs. */
10000 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10001 /* Stash the end of glink branch table. */
10002 if (htab->glink != NULL)
10003 htab->glink->rawsize = htab->glink->size;
10004
10005 if (!htab->opd_abi && !bfd_link_pic (info))
10006 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10007
10008 first_tlsld = NULL;
10009 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10010 {
10011 struct got_entry *ent;
10012
10013 if (!is_ppc64_elf (ibfd))
10014 continue;
10015
10016 ent = ppc64_tlsld_got (ibfd);
10017 if (ent->got.refcount > 0)
10018 {
10019 if (!htab->do_multi_toc && first_tlsld != NULL)
10020 {
10021 ent->is_indirect = TRUE;
10022 ent->got.ent = first_tlsld;
10023 }
10024 else
10025 {
10026 if (first_tlsld == NULL)
10027 first_tlsld = ent;
10028 s = ppc64_elf_tdata (ibfd)->got;
10029 ent->got.offset = s->size;
10030 ent->owner = ibfd;
10031 s->size += 16;
10032 if (bfd_link_pic (info))
10033 {
10034 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10035 srel->size += sizeof (Elf64_External_Rela);
10036 }
10037 }
10038 }
10039 else
10040 ent->got.offset = (bfd_vma) -1;
10041 }
10042
10043 /* We now have determined the sizes of the various dynamic sections.
10044 Allocate memory for them. */
10045 relocs = FALSE;
10046 for (s = dynobj->sections; s != NULL; s = s->next)
10047 {
10048 if ((s->flags & SEC_LINKER_CREATED) == 0)
10049 continue;
10050
10051 if (s == htab->brlt || s == htab->relbrlt)
10052 /* These haven't been allocated yet; don't strip. */
10053 continue;
10054 else if (s == htab->elf.sgot
10055 || s == htab->elf.splt
10056 || s == htab->elf.iplt
10057 || s == htab->glink
10058 || s == htab->dynbss)
10059 {
10060 /* Strip this section if we don't need it; see the
10061 comment below. */
10062 }
10063 else if (s == htab->glink_eh_frame)
10064 {
10065 if (!bfd_is_abs_section (s->output_section))
10066 /* Not sized yet. */
10067 continue;
10068 }
10069 else if (CONST_STRNEQ (s->name, ".rela"))
10070 {
10071 if (s->size != 0)
10072 {
10073 if (s != htab->elf.srelplt)
10074 relocs = TRUE;
10075
10076 /* We use the reloc_count field as a counter if we need
10077 to copy relocs into the output file. */
10078 s->reloc_count = 0;
10079 }
10080 }
10081 else
10082 {
10083 /* It's not one of our sections, so don't allocate space. */
10084 continue;
10085 }
10086
10087 if (s->size == 0)
10088 {
10089 /* If we don't need this section, strip it from the
10090 output file. This is mostly to handle .rela.bss and
10091 .rela.plt. We must create both sections in
10092 create_dynamic_sections, because they must be created
10093 before the linker maps input sections to output
10094 sections. The linker does that before
10095 adjust_dynamic_symbol is called, and it is that
10096 function which decides whether anything needs to go
10097 into these sections. */
10098 s->flags |= SEC_EXCLUDE;
10099 continue;
10100 }
10101
10102 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10103 continue;
10104
10105 /* Allocate memory for the section contents. We use bfd_zalloc
10106 here in case unused entries are not reclaimed before the
10107 section's contents are written out. This should not happen,
10108 but this way if it does we get a R_PPC64_NONE reloc in .rela
10109 sections instead of garbage.
10110 We also rely on the section contents being zero when writing
10111 the GOT. */
10112 s->contents = bfd_zalloc (dynobj, s->size);
10113 if (s->contents == NULL)
10114 return FALSE;
10115 }
10116
10117 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10118 {
10119 if (!is_ppc64_elf (ibfd))
10120 continue;
10121
10122 s = ppc64_elf_tdata (ibfd)->got;
10123 if (s != NULL && s != htab->elf.sgot)
10124 {
10125 if (s->size == 0)
10126 s->flags |= SEC_EXCLUDE;
10127 else
10128 {
10129 s->contents = bfd_zalloc (ibfd, s->size);
10130 if (s->contents == NULL)
10131 return FALSE;
10132 }
10133 }
10134 s = ppc64_elf_tdata (ibfd)->relgot;
10135 if (s != NULL)
10136 {
10137 if (s->size == 0)
10138 s->flags |= SEC_EXCLUDE;
10139 else
10140 {
10141 s->contents = bfd_zalloc (ibfd, s->size);
10142 if (s->contents == NULL)
10143 return FALSE;
10144 relocs = TRUE;
10145 s->reloc_count = 0;
10146 }
10147 }
10148 }
10149
10150 if (htab->elf.dynamic_sections_created)
10151 {
10152 bfd_boolean tls_opt;
10153
10154 /* Add some entries to the .dynamic section. We fill in the
10155 values later, in ppc64_elf_finish_dynamic_sections, but we
10156 must add the entries now so that we get the correct size for
10157 the .dynamic section. The DT_DEBUG entry is filled in by the
10158 dynamic linker and used by the debugger. */
10159 #define add_dynamic_entry(TAG, VAL) \
10160 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10161
10162 if (bfd_link_executable (info))
10163 {
10164 if (!add_dynamic_entry (DT_DEBUG, 0))
10165 return FALSE;
10166 }
10167
10168 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10169 {
10170 if (!add_dynamic_entry (DT_PLTGOT, 0)
10171 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10172 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10173 || !add_dynamic_entry (DT_JMPREL, 0)
10174 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10175 return FALSE;
10176 }
10177
10178 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10179 {
10180 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10181 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10182 return FALSE;
10183 }
10184
10185 tls_opt = (htab->params->tls_get_addr_opt
10186 && htab->tls_get_addr_fd != NULL
10187 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10188 if (tls_opt || !htab->opd_abi)
10189 {
10190 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10191 return FALSE;
10192 }
10193
10194 if (relocs)
10195 {
10196 if (!add_dynamic_entry (DT_RELA, 0)
10197 || !add_dynamic_entry (DT_RELASZ, 0)
10198 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10199 return FALSE;
10200
10201 /* If any dynamic relocs apply to a read-only section,
10202 then we need a DT_TEXTREL entry. */
10203 if ((info->flags & DF_TEXTREL) == 0)
10204 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10205
10206 if ((info->flags & DF_TEXTREL) != 0)
10207 {
10208 if (!add_dynamic_entry (DT_TEXTREL, 0))
10209 return FALSE;
10210 }
10211 }
10212 }
10213 #undef add_dynamic_entry
10214
10215 return TRUE;
10216 }
10217
10218 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10219
10220 static bfd_boolean
10221 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10222 {
10223 if (h->plt.plist != NULL
10224 && !h->def_regular
10225 && !h->pointer_equality_needed)
10226 return FALSE;
10227
10228 return _bfd_elf_hash_symbol (h);
10229 }
10230
10231 /* Determine the type of stub needed, if any, for a call. */
10232
10233 static inline enum ppc_stub_type
10234 ppc_type_of_stub (asection *input_sec,
10235 const Elf_Internal_Rela *rel,
10236 struct ppc_link_hash_entry **hash,
10237 struct plt_entry **plt_ent,
10238 bfd_vma destination,
10239 unsigned long local_off)
10240 {
10241 struct ppc_link_hash_entry *h = *hash;
10242 bfd_vma location;
10243 bfd_vma branch_offset;
10244 bfd_vma max_branch_offset;
10245 enum elf_ppc64_reloc_type r_type;
10246
10247 if (h != NULL)
10248 {
10249 struct plt_entry *ent;
10250 struct ppc_link_hash_entry *fdh = h;
10251 if (h->oh != NULL
10252 && h->oh->is_func_descriptor)
10253 {
10254 fdh = ppc_follow_link (h->oh);
10255 *hash = fdh;
10256 }
10257
10258 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10259 if (ent->addend == rel->r_addend
10260 && ent->plt.offset != (bfd_vma) -1)
10261 {
10262 *plt_ent = ent;
10263 return ppc_stub_plt_call;
10264 }
10265
10266 /* Here, we know we don't have a plt entry. If we don't have a
10267 either a defined function descriptor or a defined entry symbol
10268 in a regular object file, then it is pointless trying to make
10269 any other type of stub. */
10270 if (!is_static_defined (&fdh->elf)
10271 && !is_static_defined (&h->elf))
10272 return ppc_stub_none;
10273 }
10274 else if (elf_local_got_ents (input_sec->owner) != NULL)
10275 {
10276 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10277 struct plt_entry **local_plt = (struct plt_entry **)
10278 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10279 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10280
10281 if (local_plt[r_symndx] != NULL)
10282 {
10283 struct plt_entry *ent;
10284
10285 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10286 if (ent->addend == rel->r_addend
10287 && ent->plt.offset != (bfd_vma) -1)
10288 {
10289 *plt_ent = ent;
10290 return ppc_stub_plt_call;
10291 }
10292 }
10293 }
10294
10295 /* Determine where the call point is. */
10296 location = (input_sec->output_offset
10297 + input_sec->output_section->vma
10298 + rel->r_offset);
10299
10300 branch_offset = destination - location;
10301 r_type = ELF64_R_TYPE (rel->r_info);
10302
10303 /* Determine if a long branch stub is needed. */
10304 max_branch_offset = 1 << 25;
10305 if (r_type != R_PPC64_REL24)
10306 max_branch_offset = 1 << 15;
10307
10308 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10309 /* We need a stub. Figure out whether a long_branch or plt_branch
10310 is needed later. */
10311 return ppc_stub_long_branch;
10312
10313 return ppc_stub_none;
10314 }
10315
10316 /* With power7 weakly ordered memory model, it is possible for ld.so
10317 to update a plt entry in one thread and have another thread see a
10318 stale zero toc entry. To avoid this we need some sort of acquire
10319 barrier in the call stub. One solution is to make the load of the
10320 toc word seem to appear to depend on the load of the function entry
10321 word. Another solution is to test for r2 being zero, and branch to
10322 the appropriate glink entry if so.
10323
10324 . fake dep barrier compare
10325 . ld 12,xxx(2) ld 12,xxx(2)
10326 . mtctr 12 mtctr 12
10327 . xor 11,12,12 ld 2,xxx+8(2)
10328 . add 2,2,11 cmpldi 2,0
10329 . ld 2,xxx+8(2) bnectr+
10330 . bctr b <glink_entry>
10331
10332 The solution involving the compare turns out to be faster, so
10333 that's what we use unless the branch won't reach. */
10334
10335 #define ALWAYS_USE_FAKE_DEP 0
10336 #define ALWAYS_EMIT_R2SAVE 0
10337
10338 #define PPC_LO(v) ((v) & 0xffff)
10339 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10340 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10341
10342 static inline unsigned int
10343 plt_stub_size (struct ppc_link_hash_table *htab,
10344 struct ppc_stub_hash_entry *stub_entry,
10345 bfd_vma off)
10346 {
10347 unsigned size = 12;
10348
10349 if (ALWAYS_EMIT_R2SAVE
10350 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10351 size += 4;
10352 if (PPC_HA (off) != 0)
10353 size += 4;
10354 if (htab->opd_abi)
10355 {
10356 size += 4;
10357 if (htab->params->plt_static_chain)
10358 size += 4;
10359 if (htab->params->plt_thread_safe
10360 && htab->elf.dynamic_sections_created
10361 && stub_entry->h != NULL
10362 && stub_entry->h->elf.dynindx != -1)
10363 size += 8;
10364 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10365 size += 4;
10366 }
10367 if (stub_entry->h != NULL
10368 && (stub_entry->h == htab->tls_get_addr_fd
10369 || stub_entry->h == htab->tls_get_addr)
10370 && htab->params->tls_get_addr_opt)
10371 size += 13 * 4;
10372 return size;
10373 }
10374
10375 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10376 then return the padding needed to do so. */
10377 static inline unsigned int
10378 plt_stub_pad (struct ppc_link_hash_table *htab,
10379 struct ppc_stub_hash_entry *stub_entry,
10380 bfd_vma plt_off)
10381 {
10382 int stub_align = 1 << htab->params->plt_stub_align;
10383 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10384 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10385
10386 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10387 > ((stub_size - 1) & -stub_align))
10388 return stub_align - (stub_off & (stub_align - 1));
10389 return 0;
10390 }
10391
10392 /* Build a .plt call stub. */
10393
10394 static inline bfd_byte *
10395 build_plt_stub (struct ppc_link_hash_table *htab,
10396 struct ppc_stub_hash_entry *stub_entry,
10397 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10398 {
10399 bfd *obfd = htab->params->stub_bfd;
10400 bfd_boolean plt_load_toc = htab->opd_abi;
10401 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10402 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10403 && htab->elf.dynamic_sections_created
10404 && stub_entry->h != NULL
10405 && stub_entry->h->elf.dynindx != -1);
10406 bfd_boolean use_fake_dep = plt_thread_safe;
10407 bfd_vma cmp_branch_off = 0;
10408
10409 if (!ALWAYS_USE_FAKE_DEP
10410 && plt_load_toc
10411 && plt_thread_safe
10412 && !((stub_entry->h == htab->tls_get_addr_fd
10413 || stub_entry->h == htab->tls_get_addr)
10414 && htab->params->tls_get_addr_opt))
10415 {
10416 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10417 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10418 / PLT_ENTRY_SIZE (htab));
10419 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10420 bfd_vma to, from;
10421
10422 if (pltindex > 32768)
10423 glinkoff += (pltindex - 32768) * 4;
10424 to = (glinkoff
10425 + htab->glink->output_offset
10426 + htab->glink->output_section->vma);
10427 from = (p - stub_entry->group->stub_sec->contents
10428 + 4 * (ALWAYS_EMIT_R2SAVE
10429 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10430 + 4 * (PPC_HA (offset) != 0)
10431 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10432 != PPC_HA (offset))
10433 + 4 * (plt_static_chain != 0)
10434 + 20
10435 + stub_entry->group->stub_sec->output_offset
10436 + stub_entry->group->stub_sec->output_section->vma);
10437 cmp_branch_off = to - from;
10438 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10439 }
10440
10441 if (PPC_HA (offset) != 0)
10442 {
10443 if (r != NULL)
10444 {
10445 if (ALWAYS_EMIT_R2SAVE
10446 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10447 r[0].r_offset += 4;
10448 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10449 r[1].r_offset = r[0].r_offset + 4;
10450 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10451 r[1].r_addend = r[0].r_addend;
10452 if (plt_load_toc)
10453 {
10454 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10455 {
10456 r[2].r_offset = r[1].r_offset + 4;
10457 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10458 r[2].r_addend = r[0].r_addend;
10459 }
10460 else
10461 {
10462 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10463 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10464 r[2].r_addend = r[0].r_addend + 8;
10465 if (plt_static_chain)
10466 {
10467 r[3].r_offset = r[2].r_offset + 4;
10468 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10469 r[3].r_addend = r[0].r_addend + 16;
10470 }
10471 }
10472 }
10473 }
10474 if (ALWAYS_EMIT_R2SAVE
10475 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10476 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10477 if (plt_load_toc)
10478 {
10479 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10480 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10481 }
10482 else
10483 {
10484 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10485 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10486 }
10487 if (plt_load_toc
10488 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10489 {
10490 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10491 offset = 0;
10492 }
10493 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10494 if (plt_load_toc)
10495 {
10496 if (use_fake_dep)
10497 {
10498 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10499 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10500 }
10501 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10502 if (plt_static_chain)
10503 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10504 }
10505 }
10506 else
10507 {
10508 if (r != NULL)
10509 {
10510 if (ALWAYS_EMIT_R2SAVE
10511 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10512 r[0].r_offset += 4;
10513 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10514 if (plt_load_toc)
10515 {
10516 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10517 {
10518 r[1].r_offset = r[0].r_offset + 4;
10519 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10520 r[1].r_addend = r[0].r_addend;
10521 }
10522 else
10523 {
10524 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10525 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10526 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10527 if (plt_static_chain)
10528 {
10529 r[2].r_offset = r[1].r_offset + 4;
10530 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10531 r[2].r_addend = r[0].r_addend + 8;
10532 }
10533 }
10534 }
10535 }
10536 if (ALWAYS_EMIT_R2SAVE
10537 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10538 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10539 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10540 if (plt_load_toc
10541 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10542 {
10543 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10544 offset = 0;
10545 }
10546 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10547 if (plt_load_toc)
10548 {
10549 if (use_fake_dep)
10550 {
10551 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10552 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10553 }
10554 if (plt_static_chain)
10555 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10556 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10557 }
10558 }
10559 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10560 {
10561 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10562 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10563 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10564 }
10565 else
10566 bfd_put_32 (obfd, BCTR, p), p += 4;
10567 return p;
10568 }
10569
10570 /* Build a special .plt call stub for __tls_get_addr. */
10571
10572 #define LD_R11_0R3 0xe9630000
10573 #define LD_R12_0R3 0xe9830000
10574 #define MR_R0_R3 0x7c601b78
10575 #define CMPDI_R11_0 0x2c2b0000
10576 #define ADD_R3_R12_R13 0x7c6c6a14
10577 #define BEQLR 0x4d820020
10578 #define MR_R3_R0 0x7c030378
10579 #define STD_R11_0R1 0xf9610000
10580 #define BCTRL 0x4e800421
10581 #define LD_R11_0R1 0xe9610000
10582 #define MTLR_R11 0x7d6803a6
10583
10584 static inline bfd_byte *
10585 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10586 struct ppc_stub_hash_entry *stub_entry,
10587 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10588 {
10589 bfd *obfd = htab->params->stub_bfd;
10590
10591 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10592 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10593 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10594 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10595 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10596 bfd_put_32 (obfd, BEQLR, p), p += 4;
10597 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10598 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10599 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10600
10601 if (r != NULL)
10602 r[0].r_offset += 9 * 4;
10603 p = build_plt_stub (htab, stub_entry, p, offset, r);
10604 bfd_put_32 (obfd, BCTRL, p - 4);
10605
10606 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10607 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10608 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10609 bfd_put_32 (obfd, BLR, p), p += 4;
10610
10611 return p;
10612 }
10613
10614 static Elf_Internal_Rela *
10615 get_relocs (asection *sec, int count)
10616 {
10617 Elf_Internal_Rela *relocs;
10618 struct bfd_elf_section_data *elfsec_data;
10619
10620 elfsec_data = elf_section_data (sec);
10621 relocs = elfsec_data->relocs;
10622 if (relocs == NULL)
10623 {
10624 bfd_size_type relsize;
10625 relsize = sec->reloc_count * sizeof (*relocs);
10626 relocs = bfd_alloc (sec->owner, relsize);
10627 if (relocs == NULL)
10628 return NULL;
10629 elfsec_data->relocs = relocs;
10630 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10631 sizeof (Elf_Internal_Shdr));
10632 if (elfsec_data->rela.hdr == NULL)
10633 return NULL;
10634 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10635 * sizeof (Elf64_External_Rela));
10636 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10637 sec->reloc_count = 0;
10638 }
10639 relocs += sec->reloc_count;
10640 sec->reloc_count += count;
10641 return relocs;
10642 }
10643
10644 static bfd_vma
10645 get_r2off (struct bfd_link_info *info,
10646 struct ppc_stub_hash_entry *stub_entry)
10647 {
10648 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10649 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10650
10651 if (r2off == 0)
10652 {
10653 /* Support linking -R objects. Get the toc pointer from the
10654 opd entry. */
10655 char buf[8];
10656 if (!htab->opd_abi)
10657 return r2off;
10658 asection *opd = stub_entry->h->elf.root.u.def.section;
10659 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10660
10661 if (strcmp (opd->name, ".opd") != 0
10662 || opd->reloc_count != 0)
10663 {
10664 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10665 stub_entry->h->elf.root.root.string);
10666 bfd_set_error (bfd_error_bad_value);
10667 return (bfd_vma) -1;
10668 }
10669 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10670 return (bfd_vma) -1;
10671 r2off = bfd_get_64 (opd->owner, buf);
10672 r2off -= elf_gp (info->output_bfd);
10673 }
10674 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10675 return r2off;
10676 }
10677
10678 static bfd_boolean
10679 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10680 {
10681 struct ppc_stub_hash_entry *stub_entry;
10682 struct ppc_branch_hash_entry *br_entry;
10683 struct bfd_link_info *info;
10684 struct ppc_link_hash_table *htab;
10685 bfd_byte *loc;
10686 bfd_byte *p;
10687 bfd_vma dest, off;
10688 int size;
10689 Elf_Internal_Rela *r;
10690 asection *plt;
10691
10692 /* Massage our args to the form they really have. */
10693 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10694 info = in_arg;
10695
10696 htab = ppc_hash_table (info);
10697 if (htab == NULL)
10698 return FALSE;
10699
10700 /* Make a note of the offset within the stubs for this entry. */
10701 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10702 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10703
10704 htab->stub_count[stub_entry->stub_type - 1] += 1;
10705 switch (stub_entry->stub_type)
10706 {
10707 case ppc_stub_long_branch:
10708 case ppc_stub_long_branch_r2off:
10709 /* Branches are relative. This is where we are going to. */
10710 dest = (stub_entry->target_value
10711 + stub_entry->target_section->output_offset
10712 + stub_entry->target_section->output_section->vma);
10713 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10714 off = dest;
10715
10716 /* And this is where we are coming from. */
10717 off -= (stub_entry->stub_offset
10718 + stub_entry->group->stub_sec->output_offset
10719 + stub_entry->group->stub_sec->output_section->vma);
10720
10721 size = 4;
10722 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10723 {
10724 bfd_vma r2off = get_r2off (info, stub_entry);
10725
10726 if (r2off == (bfd_vma) -1)
10727 {
10728 htab->stub_error = TRUE;
10729 return FALSE;
10730 }
10731 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10732 loc += 4;
10733 size = 8;
10734 if (PPC_HA (r2off) != 0)
10735 {
10736 bfd_put_32 (htab->params->stub_bfd,
10737 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10738 loc += 4;
10739 size += 4;
10740 }
10741 if (PPC_LO (r2off) != 0)
10742 {
10743 bfd_put_32 (htab->params->stub_bfd,
10744 ADDI_R2_R2 | PPC_LO (r2off), loc);
10745 loc += 4;
10746 size += 4;
10747 }
10748 off -= size - 4;
10749 }
10750 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10751
10752 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10753 {
10754 info->callbacks->einfo
10755 (_("%P: long branch stub `%s' offset overflow\n"),
10756 stub_entry->root.string);
10757 htab->stub_error = TRUE;
10758 return FALSE;
10759 }
10760
10761 if (info->emitrelocations)
10762 {
10763 r = get_relocs (stub_entry->group->stub_sec, 1);
10764 if (r == NULL)
10765 return FALSE;
10766 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10767 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10768 r->r_addend = dest;
10769 if (stub_entry->h != NULL)
10770 {
10771 struct elf_link_hash_entry **hashes;
10772 unsigned long symndx;
10773 struct ppc_link_hash_entry *h;
10774
10775 hashes = elf_sym_hashes (htab->params->stub_bfd);
10776 if (hashes == NULL)
10777 {
10778 bfd_size_type hsize;
10779
10780 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10781 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10782 if (hashes == NULL)
10783 return FALSE;
10784 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10785 htab->stub_globals = 1;
10786 }
10787 symndx = htab->stub_globals++;
10788 h = stub_entry->h;
10789 hashes[symndx] = &h->elf;
10790 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10791 if (h->oh != NULL && h->oh->is_func)
10792 h = ppc_follow_link (h->oh);
10793 if (h->elf.root.u.def.section != stub_entry->target_section)
10794 /* H is an opd symbol. The addend must be zero. */
10795 r->r_addend = 0;
10796 else
10797 {
10798 off = (h->elf.root.u.def.value
10799 + h->elf.root.u.def.section->output_offset
10800 + h->elf.root.u.def.section->output_section->vma);
10801 r->r_addend -= off;
10802 }
10803 }
10804 }
10805 break;
10806
10807 case ppc_stub_plt_branch:
10808 case ppc_stub_plt_branch_r2off:
10809 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10810 stub_entry->root.string + 9,
10811 FALSE, FALSE);
10812 if (br_entry == NULL)
10813 {
10814 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10815 stub_entry->root.string);
10816 htab->stub_error = TRUE;
10817 return FALSE;
10818 }
10819
10820 dest = (stub_entry->target_value
10821 + stub_entry->target_section->output_offset
10822 + stub_entry->target_section->output_section->vma);
10823 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10824 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10825
10826 bfd_put_64 (htab->brlt->owner, dest,
10827 htab->brlt->contents + br_entry->offset);
10828
10829 if (br_entry->iter == htab->stub_iteration)
10830 {
10831 br_entry->iter = 0;
10832
10833 if (htab->relbrlt != NULL)
10834 {
10835 /* Create a reloc for the branch lookup table entry. */
10836 Elf_Internal_Rela rela;
10837 bfd_byte *rl;
10838
10839 rela.r_offset = (br_entry->offset
10840 + htab->brlt->output_offset
10841 + htab->brlt->output_section->vma);
10842 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10843 rela.r_addend = dest;
10844
10845 rl = htab->relbrlt->contents;
10846 rl += (htab->relbrlt->reloc_count++
10847 * sizeof (Elf64_External_Rela));
10848 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10849 }
10850 else if (info->emitrelocations)
10851 {
10852 r = get_relocs (htab->brlt, 1);
10853 if (r == NULL)
10854 return FALSE;
10855 /* brlt, being SEC_LINKER_CREATED does not go through the
10856 normal reloc processing. Symbols and offsets are not
10857 translated from input file to output file form, so
10858 set up the offset per the output file. */
10859 r->r_offset = (br_entry->offset
10860 + htab->brlt->output_offset
10861 + htab->brlt->output_section->vma);
10862 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10863 r->r_addend = dest;
10864 }
10865 }
10866
10867 dest = (br_entry->offset
10868 + htab->brlt->output_offset
10869 + htab->brlt->output_section->vma);
10870
10871 off = (dest
10872 - elf_gp (htab->brlt->output_section->owner)
10873 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10874
10875 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10876 {
10877 info->callbacks->einfo
10878 (_("%P: linkage table error against `%T'\n"),
10879 stub_entry->root.string);
10880 bfd_set_error (bfd_error_bad_value);
10881 htab->stub_error = TRUE;
10882 return FALSE;
10883 }
10884
10885 if (info->emitrelocations)
10886 {
10887 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10888 if (r == NULL)
10889 return FALSE;
10890 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10891 if (bfd_big_endian (info->output_bfd))
10892 r[0].r_offset += 2;
10893 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10894 r[0].r_offset += 4;
10895 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10896 r[0].r_addend = dest;
10897 if (PPC_HA (off) != 0)
10898 {
10899 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10900 r[1].r_offset = r[0].r_offset + 4;
10901 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10902 r[1].r_addend = r[0].r_addend;
10903 }
10904 }
10905
10906 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10907 {
10908 if (PPC_HA (off) != 0)
10909 {
10910 size = 16;
10911 bfd_put_32 (htab->params->stub_bfd,
10912 ADDIS_R12_R2 | PPC_HA (off), loc);
10913 loc += 4;
10914 bfd_put_32 (htab->params->stub_bfd,
10915 LD_R12_0R12 | PPC_LO (off), loc);
10916 }
10917 else
10918 {
10919 size = 12;
10920 bfd_put_32 (htab->params->stub_bfd,
10921 LD_R12_0R2 | PPC_LO (off), loc);
10922 }
10923 }
10924 else
10925 {
10926 bfd_vma r2off = get_r2off (info, stub_entry);
10927
10928 if (r2off == (bfd_vma) -1)
10929 {
10930 htab->stub_error = TRUE;
10931 return FALSE;
10932 }
10933
10934 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10935 loc += 4;
10936 size = 16;
10937 if (PPC_HA (off) != 0)
10938 {
10939 size += 4;
10940 bfd_put_32 (htab->params->stub_bfd,
10941 ADDIS_R12_R2 | PPC_HA (off), loc);
10942 loc += 4;
10943 bfd_put_32 (htab->params->stub_bfd,
10944 LD_R12_0R12 | PPC_LO (off), loc);
10945 }
10946 else
10947 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10948
10949 if (PPC_HA (r2off) != 0)
10950 {
10951 size += 4;
10952 loc += 4;
10953 bfd_put_32 (htab->params->stub_bfd,
10954 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10955 }
10956 if (PPC_LO (r2off) != 0)
10957 {
10958 size += 4;
10959 loc += 4;
10960 bfd_put_32 (htab->params->stub_bfd,
10961 ADDI_R2_R2 | PPC_LO (r2off), loc);
10962 }
10963 }
10964 loc += 4;
10965 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10966 loc += 4;
10967 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10968 break;
10969
10970 case ppc_stub_plt_call:
10971 case ppc_stub_plt_call_r2save:
10972 if (stub_entry->h != NULL
10973 && stub_entry->h->is_func_descriptor
10974 && stub_entry->h->oh != NULL)
10975 {
10976 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10977
10978 /* If the old-ABI "dot-symbol" is undefined make it weak so
10979 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
10980 if (fh->elf.root.type == bfd_link_hash_undefined)
10981 fh->elf.root.type = bfd_link_hash_undefweak;
10982 /* Stop undo_symbol_twiddle changing it back to undefined. */
10983 fh->was_undefined = 0;
10984 }
10985
10986 /* Now build the stub. */
10987 dest = stub_entry->plt_ent->plt.offset & ~1;
10988 if (dest >= (bfd_vma) -2)
10989 abort ();
10990
10991 plt = htab->elf.splt;
10992 if (!htab->elf.dynamic_sections_created
10993 || stub_entry->h == NULL
10994 || stub_entry->h->elf.dynindx == -1)
10995 plt = htab->elf.iplt;
10996
10997 dest += plt->output_offset + plt->output_section->vma;
10998
10999 if (stub_entry->h == NULL
11000 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11001 {
11002 Elf_Internal_Rela rela;
11003 bfd_byte *rl;
11004
11005 rela.r_offset = dest;
11006 if (htab->opd_abi)
11007 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11008 else
11009 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11010 rela.r_addend = (stub_entry->target_value
11011 + stub_entry->target_section->output_offset
11012 + stub_entry->target_section->output_section->vma);
11013
11014 rl = (htab->elf.irelplt->contents
11015 + (htab->elf.irelplt->reloc_count++
11016 * sizeof (Elf64_External_Rela)));
11017 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11018 stub_entry->plt_ent->plt.offset |= 1;
11019 }
11020
11021 off = (dest
11022 - elf_gp (plt->output_section->owner)
11023 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11024
11025 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11026 {
11027 info->callbacks->einfo
11028 (_("%P: linkage table error against `%T'\n"),
11029 stub_entry->h != NULL
11030 ? stub_entry->h->elf.root.root.string
11031 : "<local sym>");
11032 bfd_set_error (bfd_error_bad_value);
11033 htab->stub_error = TRUE;
11034 return FALSE;
11035 }
11036
11037 if (htab->params->plt_stub_align != 0)
11038 {
11039 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11040
11041 stub_entry->group->stub_sec->size += pad;
11042 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11043 loc += pad;
11044 }
11045
11046 r = NULL;
11047 if (info->emitrelocations)
11048 {
11049 r = get_relocs (stub_entry->group->stub_sec,
11050 ((PPC_HA (off) != 0)
11051 + (htab->opd_abi
11052 ? 2 + (htab->params->plt_static_chain
11053 && PPC_HA (off + 16) == PPC_HA (off))
11054 : 1)));
11055 if (r == NULL)
11056 return FALSE;
11057 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11058 if (bfd_big_endian (info->output_bfd))
11059 r[0].r_offset += 2;
11060 r[0].r_addend = dest;
11061 }
11062 if (stub_entry->h != NULL
11063 && (stub_entry->h == htab->tls_get_addr_fd
11064 || stub_entry->h == htab->tls_get_addr)
11065 && htab->params->tls_get_addr_opt)
11066 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11067 else
11068 p = build_plt_stub (htab, stub_entry, loc, off, r);
11069 size = p - loc;
11070 break;
11071
11072 case ppc_stub_save_res:
11073 return TRUE;
11074
11075 default:
11076 BFD_FAIL ();
11077 return FALSE;
11078 }
11079
11080 stub_entry->group->stub_sec->size += size;
11081
11082 if (htab->params->emit_stub_syms)
11083 {
11084 struct elf_link_hash_entry *h;
11085 size_t len1, len2;
11086 char *name;
11087 const char *const stub_str[] = { "long_branch",
11088 "long_branch_r2off",
11089 "plt_branch",
11090 "plt_branch_r2off",
11091 "plt_call",
11092 "plt_call" };
11093
11094 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11095 len2 = strlen (stub_entry->root.string);
11096 name = bfd_malloc (len1 + len2 + 2);
11097 if (name == NULL)
11098 return FALSE;
11099 memcpy (name, stub_entry->root.string, 9);
11100 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11101 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11102 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11103 if (h == NULL)
11104 return FALSE;
11105 if (h->root.type == bfd_link_hash_new)
11106 {
11107 h->root.type = bfd_link_hash_defined;
11108 h->root.u.def.section = stub_entry->group->stub_sec;
11109 h->root.u.def.value = stub_entry->stub_offset;
11110 h->ref_regular = 1;
11111 h->def_regular = 1;
11112 h->ref_regular_nonweak = 1;
11113 h->forced_local = 1;
11114 h->non_elf = 0;
11115 h->root.linker_def = 1;
11116 }
11117 }
11118
11119 return TRUE;
11120 }
11121
11122 /* As above, but don't actually build the stub. Just bump offset so
11123 we know stub section sizes, and select plt_branch stubs where
11124 long_branch stubs won't do. */
11125
11126 static bfd_boolean
11127 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11128 {
11129 struct ppc_stub_hash_entry *stub_entry;
11130 struct bfd_link_info *info;
11131 struct ppc_link_hash_table *htab;
11132 bfd_vma off;
11133 int size;
11134
11135 /* Massage our args to the form they really have. */
11136 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11137 info = in_arg;
11138
11139 htab = ppc_hash_table (info);
11140 if (htab == NULL)
11141 return FALSE;
11142
11143 if (stub_entry->h != NULL
11144 && stub_entry->h->save_res
11145 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11146 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11147 {
11148 /* Don't make stubs to out-of-line register save/restore
11149 functions. Instead, emit copies of the functions. */
11150 stub_entry->group->needs_save_res = 1;
11151 stub_entry->stub_type = ppc_stub_save_res;
11152 return TRUE;
11153 }
11154
11155 if (stub_entry->stub_type == ppc_stub_plt_call
11156 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11157 {
11158 asection *plt;
11159 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11160 if (off >= (bfd_vma) -2)
11161 abort ();
11162 plt = htab->elf.splt;
11163 if (!htab->elf.dynamic_sections_created
11164 || stub_entry->h == NULL
11165 || stub_entry->h->elf.dynindx == -1)
11166 plt = htab->elf.iplt;
11167 off += (plt->output_offset
11168 + plt->output_section->vma
11169 - elf_gp (plt->output_section->owner)
11170 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11171
11172 size = plt_stub_size (htab, stub_entry, off);
11173 if (htab->params->plt_stub_align)
11174 size += plt_stub_pad (htab, stub_entry, off);
11175 if (info->emitrelocations)
11176 {
11177 stub_entry->group->stub_sec->reloc_count
11178 += ((PPC_HA (off) != 0)
11179 + (htab->opd_abi
11180 ? 2 + (htab->params->plt_static_chain
11181 && PPC_HA (off + 16) == PPC_HA (off))
11182 : 1));
11183 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11184 }
11185 }
11186 else
11187 {
11188 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11189 variants. */
11190 bfd_vma r2off = 0;
11191 bfd_vma local_off = 0;
11192
11193 off = (stub_entry->target_value
11194 + stub_entry->target_section->output_offset
11195 + stub_entry->target_section->output_section->vma);
11196 off -= (stub_entry->group->stub_sec->size
11197 + stub_entry->group->stub_sec->output_offset
11198 + stub_entry->group->stub_sec->output_section->vma);
11199
11200 /* Reset the stub type from the plt variant in case we now
11201 can reach with a shorter stub. */
11202 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11203 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11204
11205 size = 4;
11206 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11207 {
11208 r2off = get_r2off (info, stub_entry);
11209 if (r2off == (bfd_vma) -1)
11210 {
11211 htab->stub_error = TRUE;
11212 return FALSE;
11213 }
11214 size = 8;
11215 if (PPC_HA (r2off) != 0)
11216 size += 4;
11217 if (PPC_LO (r2off) != 0)
11218 size += 4;
11219 off -= size - 4;
11220 }
11221
11222 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11223
11224 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11225 Do the same for -R objects without function descriptors. */
11226 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11227 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11228 && r2off == 0
11229 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11230 {
11231 struct ppc_branch_hash_entry *br_entry;
11232
11233 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11234 stub_entry->root.string + 9,
11235 TRUE, FALSE);
11236 if (br_entry == NULL)
11237 {
11238 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11239 stub_entry->root.string);
11240 htab->stub_error = TRUE;
11241 return FALSE;
11242 }
11243
11244 if (br_entry->iter != htab->stub_iteration)
11245 {
11246 br_entry->iter = htab->stub_iteration;
11247 br_entry->offset = htab->brlt->size;
11248 htab->brlt->size += 8;
11249
11250 if (htab->relbrlt != NULL)
11251 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11252 else if (info->emitrelocations)
11253 {
11254 htab->brlt->reloc_count += 1;
11255 htab->brlt->flags |= SEC_RELOC;
11256 }
11257 }
11258
11259 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11260 off = (br_entry->offset
11261 + htab->brlt->output_offset
11262 + htab->brlt->output_section->vma
11263 - elf_gp (htab->brlt->output_section->owner)
11264 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11265
11266 if (info->emitrelocations)
11267 {
11268 stub_entry->group->stub_sec->reloc_count
11269 += 1 + (PPC_HA (off) != 0);
11270 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11271 }
11272
11273 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11274 {
11275 size = 12;
11276 if (PPC_HA (off) != 0)
11277 size = 16;
11278 }
11279 else
11280 {
11281 size = 16;
11282 if (PPC_HA (off) != 0)
11283 size += 4;
11284
11285 if (PPC_HA (r2off) != 0)
11286 size += 4;
11287 if (PPC_LO (r2off) != 0)
11288 size += 4;
11289 }
11290 }
11291 else if (info->emitrelocations)
11292 {
11293 stub_entry->group->stub_sec->reloc_count += 1;
11294 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11295 }
11296 }
11297
11298 stub_entry->group->stub_sec->size += size;
11299 return TRUE;
11300 }
11301
11302 /* Set up various things so that we can make a list of input sections
11303 for each output section included in the link. Returns -1 on error,
11304 0 when no stubs will be needed, and 1 on success. */
11305
11306 int
11307 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11308 {
11309 unsigned int id;
11310 bfd_size_type amt;
11311 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11312
11313 if (htab == NULL)
11314 return -1;
11315
11316 htab->sec_info_arr_size = bfd_get_next_section_id ();
11317 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11318 htab->sec_info = bfd_zmalloc (amt);
11319 if (htab->sec_info == NULL)
11320 return -1;
11321
11322 /* Set toc_off for com, und, abs and ind sections. */
11323 for (id = 0; id < 3; id++)
11324 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11325
11326 return 1;
11327 }
11328
11329 /* Set up for first pass at multitoc partitioning. */
11330
11331 void
11332 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11333 {
11334 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11335
11336 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11337 htab->toc_bfd = NULL;
11338 htab->toc_first_sec = NULL;
11339 }
11340
11341 /* The linker repeatedly calls this function for each TOC input section
11342 and linker generated GOT section. Group input bfds such that the toc
11343 within a group is less than 64k in size. */
11344
11345 bfd_boolean
11346 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11347 {
11348 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11349 bfd_vma addr, off, limit;
11350
11351 if (htab == NULL)
11352 return FALSE;
11353
11354 if (!htab->second_toc_pass)
11355 {
11356 /* Keep track of the first .toc or .got section for this input bfd. */
11357 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11358
11359 if (new_bfd)
11360 {
11361 htab->toc_bfd = isec->owner;
11362 htab->toc_first_sec = isec;
11363 }
11364
11365 addr = isec->output_offset + isec->output_section->vma;
11366 off = addr - htab->toc_curr;
11367 limit = 0x80008000;
11368 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11369 limit = 0x10000;
11370 if (off + isec->size > limit)
11371 {
11372 addr = (htab->toc_first_sec->output_offset
11373 + htab->toc_first_sec->output_section->vma);
11374 htab->toc_curr = addr;
11375 htab->toc_curr &= -TOC_BASE_ALIGN;
11376 }
11377
11378 /* toc_curr is the base address of this toc group. Set elf_gp
11379 for the input section to be the offset relative to the
11380 output toc base plus 0x8000. Making the input elf_gp an
11381 offset allows us to move the toc as a whole without
11382 recalculating input elf_gp. */
11383 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11384 off += TOC_BASE_OFF;
11385
11386 /* Die if someone uses a linker script that doesn't keep input
11387 file .toc and .got together. */
11388 if (new_bfd
11389 && elf_gp (isec->owner) != 0
11390 && elf_gp (isec->owner) != off)
11391 return FALSE;
11392
11393 elf_gp (isec->owner) = off;
11394 return TRUE;
11395 }
11396
11397 /* During the second pass toc_first_sec points to the start of
11398 a toc group, and toc_curr is used to track the old elf_gp.
11399 We use toc_bfd to ensure we only look at each bfd once. */
11400 if (htab->toc_bfd == isec->owner)
11401 return TRUE;
11402 htab->toc_bfd = isec->owner;
11403
11404 if (htab->toc_first_sec == NULL
11405 || htab->toc_curr != elf_gp (isec->owner))
11406 {
11407 htab->toc_curr = elf_gp (isec->owner);
11408 htab->toc_first_sec = isec;
11409 }
11410 addr = (htab->toc_first_sec->output_offset
11411 + htab->toc_first_sec->output_section->vma);
11412 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11413 elf_gp (isec->owner) = off;
11414
11415 return TRUE;
11416 }
11417
11418 /* Called via elf_link_hash_traverse to merge GOT entries for global
11419 symbol H. */
11420
11421 static bfd_boolean
11422 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11423 {
11424 if (h->root.type == bfd_link_hash_indirect)
11425 return TRUE;
11426
11427 merge_got_entries (&h->got.glist);
11428
11429 return TRUE;
11430 }
11431
11432 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11433 symbol H. */
11434
11435 static bfd_boolean
11436 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11437 {
11438 struct got_entry *gent;
11439
11440 if (h->root.type == bfd_link_hash_indirect)
11441 return TRUE;
11442
11443 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11444 if (!gent->is_indirect)
11445 allocate_got (h, (struct bfd_link_info *) inf, gent);
11446 return TRUE;
11447 }
11448
11449 /* Called on the first multitoc pass after the last call to
11450 ppc64_elf_next_toc_section. This function removes duplicate GOT
11451 entries. */
11452
11453 bfd_boolean
11454 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11455 {
11456 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11457 struct bfd *ibfd, *ibfd2;
11458 bfd_boolean done_something;
11459
11460 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11461
11462 if (!htab->do_multi_toc)
11463 return FALSE;
11464
11465 /* Merge global sym got entries within a toc group. */
11466 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11467
11468 /* And tlsld_got. */
11469 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11470 {
11471 struct got_entry *ent, *ent2;
11472
11473 if (!is_ppc64_elf (ibfd))
11474 continue;
11475
11476 ent = ppc64_tlsld_got (ibfd);
11477 if (!ent->is_indirect
11478 && ent->got.offset != (bfd_vma) -1)
11479 {
11480 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11481 {
11482 if (!is_ppc64_elf (ibfd2))
11483 continue;
11484
11485 ent2 = ppc64_tlsld_got (ibfd2);
11486 if (!ent2->is_indirect
11487 && ent2->got.offset != (bfd_vma) -1
11488 && elf_gp (ibfd2) == elf_gp (ibfd))
11489 {
11490 ent2->is_indirect = TRUE;
11491 ent2->got.ent = ent;
11492 }
11493 }
11494 }
11495 }
11496
11497 /* Zap sizes of got sections. */
11498 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11499 htab->elf.irelplt->size -= htab->got_reli_size;
11500 htab->got_reli_size = 0;
11501
11502 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11503 {
11504 asection *got, *relgot;
11505
11506 if (!is_ppc64_elf (ibfd))
11507 continue;
11508
11509 got = ppc64_elf_tdata (ibfd)->got;
11510 if (got != NULL)
11511 {
11512 got->rawsize = got->size;
11513 got->size = 0;
11514 relgot = ppc64_elf_tdata (ibfd)->relgot;
11515 relgot->rawsize = relgot->size;
11516 relgot->size = 0;
11517 }
11518 }
11519
11520 /* Now reallocate the got, local syms first. We don't need to
11521 allocate section contents again since we never increase size. */
11522 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11523 {
11524 struct got_entry **lgot_ents;
11525 struct got_entry **end_lgot_ents;
11526 struct plt_entry **local_plt;
11527 struct plt_entry **end_local_plt;
11528 unsigned char *lgot_masks;
11529 bfd_size_type locsymcount;
11530 Elf_Internal_Shdr *symtab_hdr;
11531 asection *s;
11532
11533 if (!is_ppc64_elf (ibfd))
11534 continue;
11535
11536 lgot_ents = elf_local_got_ents (ibfd);
11537 if (!lgot_ents)
11538 continue;
11539
11540 symtab_hdr = &elf_symtab_hdr (ibfd);
11541 locsymcount = symtab_hdr->sh_info;
11542 end_lgot_ents = lgot_ents + locsymcount;
11543 local_plt = (struct plt_entry **) end_lgot_ents;
11544 end_local_plt = local_plt + locsymcount;
11545 lgot_masks = (unsigned char *) end_local_plt;
11546 s = ppc64_elf_tdata (ibfd)->got;
11547 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11548 {
11549 struct got_entry *ent;
11550
11551 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11552 {
11553 unsigned int ent_size = 8;
11554 unsigned int rel_size = sizeof (Elf64_External_Rela);
11555
11556 ent->got.offset = s->size;
11557 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11558 {
11559 ent_size *= 2;
11560 rel_size *= 2;
11561 }
11562 s->size += ent_size;
11563 if ((*lgot_masks & PLT_IFUNC) != 0)
11564 {
11565 htab->elf.irelplt->size += rel_size;
11566 htab->got_reli_size += rel_size;
11567 }
11568 else if (bfd_link_pic (info))
11569 {
11570 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11571 srel->size += rel_size;
11572 }
11573 }
11574 }
11575 }
11576
11577 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11578
11579 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11580 {
11581 struct got_entry *ent;
11582
11583 if (!is_ppc64_elf (ibfd))
11584 continue;
11585
11586 ent = ppc64_tlsld_got (ibfd);
11587 if (!ent->is_indirect
11588 && ent->got.offset != (bfd_vma) -1)
11589 {
11590 asection *s = ppc64_elf_tdata (ibfd)->got;
11591 ent->got.offset = s->size;
11592 s->size += 16;
11593 if (bfd_link_pic (info))
11594 {
11595 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11596 srel->size += sizeof (Elf64_External_Rela);
11597 }
11598 }
11599 }
11600
11601 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11602 if (!done_something)
11603 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11604 {
11605 asection *got;
11606
11607 if (!is_ppc64_elf (ibfd))
11608 continue;
11609
11610 got = ppc64_elf_tdata (ibfd)->got;
11611 if (got != NULL)
11612 {
11613 done_something = got->rawsize != got->size;
11614 if (done_something)
11615 break;
11616 }
11617 }
11618
11619 if (done_something)
11620 (*htab->params->layout_sections_again) ();
11621
11622 /* Set up for second pass over toc sections to recalculate elf_gp
11623 on input sections. */
11624 htab->toc_bfd = NULL;
11625 htab->toc_first_sec = NULL;
11626 htab->second_toc_pass = TRUE;
11627 return done_something;
11628 }
11629
11630 /* Called after second pass of multitoc partitioning. */
11631
11632 void
11633 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11634 {
11635 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11636
11637 /* After the second pass, toc_curr tracks the TOC offset used
11638 for code sections below in ppc64_elf_next_input_section. */
11639 htab->toc_curr = TOC_BASE_OFF;
11640 }
11641
11642 /* No toc references were found in ISEC. If the code in ISEC makes no
11643 calls, then there's no need to use toc adjusting stubs when branching
11644 into ISEC. Actually, indirect calls from ISEC are OK as they will
11645 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11646 needed, and 2 if a cyclical call-graph was found but no other reason
11647 for a stub was detected. If called from the top level, a return of
11648 2 means the same as a return of 0. */
11649
11650 static int
11651 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11652 {
11653 int ret;
11654
11655 /* Mark this section as checked. */
11656 isec->call_check_done = 1;
11657
11658 /* We know none of our code bearing sections will need toc stubs. */
11659 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11660 return 0;
11661
11662 if (isec->size == 0)
11663 return 0;
11664
11665 if (isec->output_section == NULL)
11666 return 0;
11667
11668 ret = 0;
11669 if (isec->reloc_count != 0)
11670 {
11671 Elf_Internal_Rela *relstart, *rel;
11672 Elf_Internal_Sym *local_syms;
11673 struct ppc_link_hash_table *htab;
11674
11675 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11676 info->keep_memory);
11677 if (relstart == NULL)
11678 return -1;
11679
11680 /* Look for branches to outside of this section. */
11681 local_syms = NULL;
11682 htab = ppc_hash_table (info);
11683 if (htab == NULL)
11684 return -1;
11685
11686 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11687 {
11688 enum elf_ppc64_reloc_type r_type;
11689 unsigned long r_symndx;
11690 struct elf_link_hash_entry *h;
11691 struct ppc_link_hash_entry *eh;
11692 Elf_Internal_Sym *sym;
11693 asection *sym_sec;
11694 struct _opd_sec_data *opd;
11695 bfd_vma sym_value;
11696 bfd_vma dest;
11697
11698 r_type = ELF64_R_TYPE (rel->r_info);
11699 if (r_type != R_PPC64_REL24
11700 && r_type != R_PPC64_REL14
11701 && r_type != R_PPC64_REL14_BRTAKEN
11702 && r_type != R_PPC64_REL14_BRNTAKEN)
11703 continue;
11704
11705 r_symndx = ELF64_R_SYM (rel->r_info);
11706 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11707 isec->owner))
11708 {
11709 ret = -1;
11710 break;
11711 }
11712
11713 /* Calls to dynamic lib functions go through a plt call stub
11714 that uses r2. */
11715 eh = (struct ppc_link_hash_entry *) h;
11716 if (eh != NULL
11717 && (eh->elf.plt.plist != NULL
11718 || (eh->oh != NULL
11719 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11720 {
11721 ret = 1;
11722 break;
11723 }
11724
11725 if (sym_sec == NULL)
11726 /* Ignore other undefined symbols. */
11727 continue;
11728
11729 /* Assume branches to other sections not included in the
11730 link need stubs too, to cover -R and absolute syms. */
11731 if (sym_sec->output_section == NULL)
11732 {
11733 ret = 1;
11734 break;
11735 }
11736
11737 if (h == NULL)
11738 sym_value = sym->st_value;
11739 else
11740 {
11741 if (h->root.type != bfd_link_hash_defined
11742 && h->root.type != bfd_link_hash_defweak)
11743 abort ();
11744 sym_value = h->root.u.def.value;
11745 }
11746 sym_value += rel->r_addend;
11747
11748 /* If this branch reloc uses an opd sym, find the code section. */
11749 opd = get_opd_info (sym_sec);
11750 if (opd != NULL)
11751 {
11752 if (h == NULL && opd->adjust != NULL)
11753 {
11754 long adjust;
11755
11756 adjust = opd->adjust[OPD_NDX (sym_value)];
11757 if (adjust == -1)
11758 /* Assume deleted functions won't ever be called. */
11759 continue;
11760 sym_value += adjust;
11761 }
11762
11763 dest = opd_entry_value (sym_sec, sym_value,
11764 &sym_sec, NULL, FALSE);
11765 if (dest == (bfd_vma) -1)
11766 continue;
11767 }
11768 else
11769 dest = (sym_value
11770 + sym_sec->output_offset
11771 + sym_sec->output_section->vma);
11772
11773 /* Ignore branch to self. */
11774 if (sym_sec == isec)
11775 continue;
11776
11777 /* If the called function uses the toc, we need a stub. */
11778 if (sym_sec->has_toc_reloc
11779 || sym_sec->makes_toc_func_call)
11780 {
11781 ret = 1;
11782 break;
11783 }
11784
11785 /* Assume any branch that needs a long branch stub might in fact
11786 need a plt_branch stub. A plt_branch stub uses r2. */
11787 else if (dest - (isec->output_offset
11788 + isec->output_section->vma
11789 + rel->r_offset) + (1 << 25)
11790 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11791 ? h->other
11792 : sym->st_other))
11793 {
11794 ret = 1;
11795 break;
11796 }
11797
11798 /* If calling back to a section in the process of being
11799 tested, we can't say for sure that no toc adjusting stubs
11800 are needed, so don't return zero. */
11801 else if (sym_sec->call_check_in_progress)
11802 ret = 2;
11803
11804 /* Branches to another section that itself doesn't have any TOC
11805 references are OK. Recursively call ourselves to check. */
11806 else if (!sym_sec->call_check_done)
11807 {
11808 int recur;
11809
11810 /* Mark current section as indeterminate, so that other
11811 sections that call back to current won't be marked as
11812 known. */
11813 isec->call_check_in_progress = 1;
11814 recur = toc_adjusting_stub_needed (info, sym_sec);
11815 isec->call_check_in_progress = 0;
11816
11817 if (recur != 0)
11818 {
11819 ret = recur;
11820 if (recur != 2)
11821 break;
11822 }
11823 }
11824 }
11825
11826 if (local_syms != NULL
11827 && (elf_symtab_hdr (isec->owner).contents
11828 != (unsigned char *) local_syms))
11829 free (local_syms);
11830 if (elf_section_data (isec)->relocs != relstart)
11831 free (relstart);
11832 }
11833
11834 if ((ret & 1) == 0
11835 && isec->map_head.s != NULL
11836 && (strcmp (isec->output_section->name, ".init") == 0
11837 || strcmp (isec->output_section->name, ".fini") == 0))
11838 {
11839 if (isec->map_head.s->has_toc_reloc
11840 || isec->map_head.s->makes_toc_func_call)
11841 ret = 1;
11842 else if (!isec->map_head.s->call_check_done)
11843 {
11844 int recur;
11845 isec->call_check_in_progress = 1;
11846 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11847 isec->call_check_in_progress = 0;
11848 if (recur != 0)
11849 ret = recur;
11850 }
11851 }
11852
11853 if (ret == 1)
11854 isec->makes_toc_func_call = 1;
11855
11856 return ret;
11857 }
11858
11859 /* The linker repeatedly calls this function for each input section,
11860 in the order that input sections are linked into output sections.
11861 Build lists of input sections to determine groupings between which
11862 we may insert linker stubs. */
11863
11864 bfd_boolean
11865 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11866 {
11867 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11868
11869 if (htab == NULL)
11870 return FALSE;
11871
11872 if ((isec->output_section->flags & SEC_CODE) != 0
11873 && isec->output_section->id < htab->sec_info_arr_size)
11874 {
11875 /* This happens to make the list in reverse order,
11876 which is what we want. */
11877 htab->sec_info[isec->id].u.list
11878 = htab->sec_info[isec->output_section->id].u.list;
11879 htab->sec_info[isec->output_section->id].u.list = isec;
11880 }
11881
11882 if (htab->multi_toc_needed)
11883 {
11884 /* Analyse sections that aren't already flagged as needing a
11885 valid toc pointer. Exclude .fixup for the linux kernel.
11886 .fixup contains branches, but only back to the function that
11887 hit an exception. */
11888 if (!(isec->has_toc_reloc
11889 || (isec->flags & SEC_CODE) == 0
11890 || strcmp (isec->name, ".fixup") == 0
11891 || isec->call_check_done))
11892 {
11893 if (toc_adjusting_stub_needed (info, isec) < 0)
11894 return FALSE;
11895 }
11896 /* Make all sections use the TOC assigned for this object file.
11897 This will be wrong for pasted sections; We fix that in
11898 check_pasted_section(). */
11899 if (elf_gp (isec->owner) != 0)
11900 htab->toc_curr = elf_gp (isec->owner);
11901 }
11902
11903 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11904 return TRUE;
11905 }
11906
11907 /* Check that all .init and .fini sections use the same toc, if they
11908 have toc relocs. */
11909
11910 static bfd_boolean
11911 check_pasted_section (struct bfd_link_info *info, const char *name)
11912 {
11913 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11914
11915 if (o != NULL)
11916 {
11917 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11918 bfd_vma toc_off = 0;
11919 asection *i;
11920
11921 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11922 if (i->has_toc_reloc)
11923 {
11924 if (toc_off == 0)
11925 toc_off = htab->sec_info[i->id].toc_off;
11926 else if (toc_off != htab->sec_info[i->id].toc_off)
11927 return FALSE;
11928 }
11929
11930 if (toc_off == 0)
11931 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11932 if (i->makes_toc_func_call)
11933 {
11934 toc_off = htab->sec_info[i->id].toc_off;
11935 break;
11936 }
11937
11938 /* Make sure the whole pasted function uses the same toc offset. */
11939 if (toc_off != 0)
11940 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11941 htab->sec_info[i->id].toc_off = toc_off;
11942 }
11943 return TRUE;
11944 }
11945
11946 bfd_boolean
11947 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11948 {
11949 return (check_pasted_section (info, ".init")
11950 & check_pasted_section (info, ".fini"));
11951 }
11952
11953 /* See whether we can group stub sections together. Grouping stub
11954 sections may result in fewer stubs. More importantly, we need to
11955 put all .init* and .fini* stubs at the beginning of the .init or
11956 .fini output sections respectively, because glibc splits the
11957 _init and _fini functions into multiple parts. Putting a stub in
11958 the middle of a function is not a good idea. */
11959
11960 static bfd_boolean
11961 group_sections (struct bfd_link_info *info,
11962 bfd_size_type stub_group_size,
11963 bfd_boolean stubs_always_before_branch)
11964 {
11965 struct ppc_link_hash_table *htab;
11966 asection *osec;
11967 bfd_size_type stub14_group_size;
11968 bfd_boolean suppress_size_errors;
11969
11970 htab = ppc_hash_table (info);
11971 if (htab == NULL)
11972 return FALSE;
11973
11974 suppress_size_errors = FALSE;
11975 stub14_group_size = stub_group_size >> 10;
11976 if (stub_group_size == 1)
11977 {
11978 /* Default values. */
11979 if (stubs_always_before_branch)
11980 {
11981 stub_group_size = 0x1e00000;
11982 stub14_group_size = 0x7800;
11983 }
11984 else
11985 {
11986 stub_group_size = 0x1c00000;
11987 stub14_group_size = 0x7000;
11988 }
11989 suppress_size_errors = TRUE;
11990 }
11991
11992 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11993 {
11994 asection *tail;
11995
11996 if (osec->id >= htab->sec_info_arr_size)
11997 continue;
11998
11999 tail = htab->sec_info[osec->id].u.list;
12000 while (tail != NULL)
12001 {
12002 asection *curr;
12003 asection *prev;
12004 bfd_size_type total;
12005 bfd_boolean big_sec;
12006 bfd_vma curr_toc;
12007 struct map_stub *group;
12008
12009 curr = tail;
12010 total = tail->size;
12011 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12012 && ppc64_elf_section_data (tail)->has_14bit_branch
12013 ? stub14_group_size : stub_group_size);
12014 if (big_sec && !suppress_size_errors)
12015 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12016 tail->owner, tail);
12017 curr_toc = htab->sec_info[tail->id].toc_off;
12018
12019 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12020 && ((total += curr->output_offset - prev->output_offset)
12021 < (ppc64_elf_section_data (prev) != NULL
12022 && ppc64_elf_section_data (prev)->has_14bit_branch
12023 ? stub14_group_size : stub_group_size))
12024 && htab->sec_info[prev->id].toc_off == curr_toc)
12025 curr = prev;
12026
12027 /* OK, the size from the start of CURR to the end is less
12028 than stub_group_size and thus can be handled by one stub
12029 section. (or the tail section is itself larger than
12030 stub_group_size, in which case we may be toast.) We
12031 should really be keeping track of the total size of stubs
12032 added here, as stubs contribute to the final output
12033 section size. That's a little tricky, and this way will
12034 only break if stubs added make the total size more than
12035 2^25, ie. for the default stub_group_size, if stubs total
12036 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12037 group = bfd_alloc (curr->owner, sizeof (*group));
12038 if (group == NULL)
12039 return FALSE;
12040 group->link_sec = curr;
12041 group->stub_sec = NULL;
12042 group->needs_save_res = 0;
12043 group->next = htab->group;
12044 htab->group = group;
12045 do
12046 {
12047 prev = htab->sec_info[tail->id].u.list;
12048 /* Set up this stub group. */
12049 htab->sec_info[tail->id].u.group = group;
12050 }
12051 while (tail != curr && (tail = prev) != NULL);
12052
12053 /* But wait, there's more! Input sections up to stub_group_size
12054 bytes before the stub section can be handled by it too.
12055 Don't do this if we have a really large section after the
12056 stubs, as adding more stubs increases the chance that
12057 branches may not reach into the stub section. */
12058 if (!stubs_always_before_branch && !big_sec)
12059 {
12060 total = 0;
12061 while (prev != NULL
12062 && ((total += tail->output_offset - prev->output_offset)
12063 < (ppc64_elf_section_data (prev) != NULL
12064 && ppc64_elf_section_data (prev)->has_14bit_branch
12065 ? stub14_group_size : stub_group_size))
12066 && htab->sec_info[prev->id].toc_off == curr_toc)
12067 {
12068 tail = prev;
12069 prev = htab->sec_info[tail->id].u.list;
12070 htab->sec_info[tail->id].u.group = group;
12071 }
12072 }
12073 tail = prev;
12074 }
12075 }
12076 return TRUE;
12077 }
12078
12079 static const unsigned char glink_eh_frame_cie[] =
12080 {
12081 0, 0, 0, 16, /* length. */
12082 0, 0, 0, 0, /* id. */
12083 1, /* CIE version. */
12084 'z', 'R', 0, /* Augmentation string. */
12085 4, /* Code alignment. */
12086 0x78, /* Data alignment. */
12087 65, /* RA reg. */
12088 1, /* Augmentation size. */
12089 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12090 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12091 0, 0, 0, 0
12092 };
12093
12094 /* Stripping output sections is normally done before dynamic section
12095 symbols have been allocated. This function is called later, and
12096 handles cases like htab->brlt which is mapped to its own output
12097 section. */
12098
12099 static void
12100 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12101 {
12102 if (isec->size == 0
12103 && isec->output_section->size == 0
12104 && !(isec->output_section->flags & SEC_KEEP)
12105 && !bfd_section_removed_from_list (info->output_bfd,
12106 isec->output_section)
12107 && elf_section_data (isec->output_section)->dynindx == 0)
12108 {
12109 isec->output_section->flags |= SEC_EXCLUDE;
12110 bfd_section_list_remove (info->output_bfd, isec->output_section);
12111 info->output_bfd->section_count--;
12112 }
12113 }
12114
12115 /* Determine and set the size of the stub section for a final link.
12116
12117 The basic idea here is to examine all the relocations looking for
12118 PC-relative calls to a target that is unreachable with a "bl"
12119 instruction. */
12120
12121 bfd_boolean
12122 ppc64_elf_size_stubs (struct bfd_link_info *info)
12123 {
12124 bfd_size_type stub_group_size;
12125 bfd_boolean stubs_always_before_branch;
12126 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12127
12128 if (htab == NULL)
12129 return FALSE;
12130
12131 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12132 htab->params->plt_thread_safe = 1;
12133 if (!htab->opd_abi)
12134 htab->params->plt_thread_safe = 0;
12135 else if (htab->params->plt_thread_safe == -1)
12136 {
12137 static const char *const thread_starter[] =
12138 {
12139 "pthread_create",
12140 /* libstdc++ */
12141 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12142 /* librt */
12143 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12144 "mq_notify", "create_timer",
12145 /* libanl */
12146 "getaddrinfo_a",
12147 /* libgomp */
12148 "GOMP_parallel",
12149 "GOMP_parallel_start",
12150 "GOMP_parallel_loop_static",
12151 "GOMP_parallel_loop_static_start",
12152 "GOMP_parallel_loop_dynamic",
12153 "GOMP_parallel_loop_dynamic_start",
12154 "GOMP_parallel_loop_guided",
12155 "GOMP_parallel_loop_guided_start",
12156 "GOMP_parallel_loop_runtime",
12157 "GOMP_parallel_loop_runtime_start",
12158 "GOMP_parallel_sections",
12159 "GOMP_parallel_sections_start",
12160 /* libgo */
12161 "__go_go",
12162 };
12163 unsigned i;
12164
12165 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12166 {
12167 struct elf_link_hash_entry *h;
12168 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12169 FALSE, FALSE, TRUE);
12170 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12171 if (htab->params->plt_thread_safe)
12172 break;
12173 }
12174 }
12175 stubs_always_before_branch = htab->params->group_size < 0;
12176 if (htab->params->group_size < 0)
12177 stub_group_size = -htab->params->group_size;
12178 else
12179 stub_group_size = htab->params->group_size;
12180
12181 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12182 return FALSE;
12183
12184 while (1)
12185 {
12186 bfd *input_bfd;
12187 unsigned int bfd_indx;
12188 struct map_stub *group;
12189 asection *stub_sec;
12190
12191 htab->stub_iteration += 1;
12192
12193 for (input_bfd = info->input_bfds, bfd_indx = 0;
12194 input_bfd != NULL;
12195 input_bfd = input_bfd->link.next, bfd_indx++)
12196 {
12197 Elf_Internal_Shdr *symtab_hdr;
12198 asection *section;
12199 Elf_Internal_Sym *local_syms = NULL;
12200
12201 if (!is_ppc64_elf (input_bfd))
12202 continue;
12203
12204 /* We'll need the symbol table in a second. */
12205 symtab_hdr = &elf_symtab_hdr (input_bfd);
12206 if (symtab_hdr->sh_info == 0)
12207 continue;
12208
12209 /* Walk over each section attached to the input bfd. */
12210 for (section = input_bfd->sections;
12211 section != NULL;
12212 section = section->next)
12213 {
12214 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12215
12216 /* If there aren't any relocs, then there's nothing more
12217 to do. */
12218 if ((section->flags & SEC_RELOC) == 0
12219 || (section->flags & SEC_ALLOC) == 0
12220 || (section->flags & SEC_LOAD) == 0
12221 || (section->flags & SEC_CODE) == 0
12222 || section->reloc_count == 0)
12223 continue;
12224
12225 /* If this section is a link-once section that will be
12226 discarded, then don't create any stubs. */
12227 if (section->output_section == NULL
12228 || section->output_section->owner != info->output_bfd)
12229 continue;
12230
12231 /* Get the relocs. */
12232 internal_relocs
12233 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12234 info->keep_memory);
12235 if (internal_relocs == NULL)
12236 goto error_ret_free_local;
12237
12238 /* Now examine each relocation. */
12239 irela = internal_relocs;
12240 irelaend = irela + section->reloc_count;
12241 for (; irela < irelaend; irela++)
12242 {
12243 enum elf_ppc64_reloc_type r_type;
12244 unsigned int r_indx;
12245 enum ppc_stub_type stub_type;
12246 struct ppc_stub_hash_entry *stub_entry;
12247 asection *sym_sec, *code_sec;
12248 bfd_vma sym_value, code_value;
12249 bfd_vma destination;
12250 unsigned long local_off;
12251 bfd_boolean ok_dest;
12252 struct ppc_link_hash_entry *hash;
12253 struct ppc_link_hash_entry *fdh;
12254 struct elf_link_hash_entry *h;
12255 Elf_Internal_Sym *sym;
12256 char *stub_name;
12257 const asection *id_sec;
12258 struct _opd_sec_data *opd;
12259 struct plt_entry *plt_ent;
12260
12261 r_type = ELF64_R_TYPE (irela->r_info);
12262 r_indx = ELF64_R_SYM (irela->r_info);
12263
12264 if (r_type >= R_PPC64_max)
12265 {
12266 bfd_set_error (bfd_error_bad_value);
12267 goto error_ret_free_internal;
12268 }
12269
12270 /* Only look for stubs on branch instructions. */
12271 if (r_type != R_PPC64_REL24
12272 && r_type != R_PPC64_REL14
12273 && r_type != R_PPC64_REL14_BRTAKEN
12274 && r_type != R_PPC64_REL14_BRNTAKEN)
12275 continue;
12276
12277 /* Now determine the call target, its name, value,
12278 section. */
12279 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12280 r_indx, input_bfd))
12281 goto error_ret_free_internal;
12282 hash = (struct ppc_link_hash_entry *) h;
12283
12284 ok_dest = FALSE;
12285 fdh = NULL;
12286 sym_value = 0;
12287 if (hash == NULL)
12288 {
12289 sym_value = sym->st_value;
12290 if (sym_sec != NULL
12291 && sym_sec->output_section != NULL)
12292 ok_dest = TRUE;
12293 }
12294 else if (hash->elf.root.type == bfd_link_hash_defined
12295 || hash->elf.root.type == bfd_link_hash_defweak)
12296 {
12297 sym_value = hash->elf.root.u.def.value;
12298 if (sym_sec->output_section != NULL)
12299 ok_dest = TRUE;
12300 }
12301 else if (hash->elf.root.type == bfd_link_hash_undefweak
12302 || hash->elf.root.type == bfd_link_hash_undefined)
12303 {
12304 /* Recognise an old ABI func code entry sym, and
12305 use the func descriptor sym instead if it is
12306 defined. */
12307 if (hash->elf.root.root.string[0] == '.'
12308 && (fdh = lookup_fdh (hash, htab)) != NULL)
12309 {
12310 if (fdh->elf.root.type == bfd_link_hash_defined
12311 || fdh->elf.root.type == bfd_link_hash_defweak)
12312 {
12313 sym_sec = fdh->elf.root.u.def.section;
12314 sym_value = fdh->elf.root.u.def.value;
12315 if (sym_sec->output_section != NULL)
12316 ok_dest = TRUE;
12317 }
12318 else
12319 fdh = NULL;
12320 }
12321 }
12322 else
12323 {
12324 bfd_set_error (bfd_error_bad_value);
12325 goto error_ret_free_internal;
12326 }
12327
12328 destination = 0;
12329 local_off = 0;
12330 if (ok_dest)
12331 {
12332 sym_value += irela->r_addend;
12333 destination = (sym_value
12334 + sym_sec->output_offset
12335 + sym_sec->output_section->vma);
12336 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12337 ? hash->elf.other
12338 : sym->st_other);
12339 }
12340
12341 code_sec = sym_sec;
12342 code_value = sym_value;
12343 opd = get_opd_info (sym_sec);
12344 if (opd != NULL)
12345 {
12346 bfd_vma dest;
12347
12348 if (hash == NULL && opd->adjust != NULL)
12349 {
12350 long adjust = opd->adjust[OPD_NDX (sym_value)];
12351 if (adjust == -1)
12352 continue;
12353 code_value += adjust;
12354 sym_value += adjust;
12355 }
12356 dest = opd_entry_value (sym_sec, sym_value,
12357 &code_sec, &code_value, FALSE);
12358 if (dest != (bfd_vma) -1)
12359 {
12360 destination = dest;
12361 if (fdh != NULL)
12362 {
12363 /* Fixup old ABI sym to point at code
12364 entry. */
12365 hash->elf.root.type = bfd_link_hash_defweak;
12366 hash->elf.root.u.def.section = code_sec;
12367 hash->elf.root.u.def.value = code_value;
12368 }
12369 }
12370 }
12371
12372 /* Determine what (if any) linker stub is needed. */
12373 plt_ent = NULL;
12374 stub_type = ppc_type_of_stub (section, irela, &hash,
12375 &plt_ent, destination,
12376 local_off);
12377
12378 if (stub_type != ppc_stub_plt_call)
12379 {
12380 /* Check whether we need a TOC adjusting stub.
12381 Since the linker pastes together pieces from
12382 different object files when creating the
12383 _init and _fini functions, it may be that a
12384 call to what looks like a local sym is in
12385 fact a call needing a TOC adjustment. */
12386 if (code_sec != NULL
12387 && code_sec->output_section != NULL
12388 && (htab->sec_info[code_sec->id].toc_off
12389 != htab->sec_info[section->id].toc_off)
12390 && (code_sec->has_toc_reloc
12391 || code_sec->makes_toc_func_call))
12392 stub_type = ppc_stub_long_branch_r2off;
12393 }
12394
12395 if (stub_type == ppc_stub_none)
12396 continue;
12397
12398 /* __tls_get_addr calls might be eliminated. */
12399 if (stub_type != ppc_stub_plt_call
12400 && hash != NULL
12401 && (hash == htab->tls_get_addr
12402 || hash == htab->tls_get_addr_fd)
12403 && section->has_tls_reloc
12404 && irela != internal_relocs)
12405 {
12406 /* Get tls info. */
12407 unsigned char *tls_mask;
12408
12409 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12410 irela - 1, input_bfd))
12411 goto error_ret_free_internal;
12412 if (*tls_mask != 0)
12413 continue;
12414 }
12415
12416 if (stub_type == ppc_stub_plt_call
12417 && irela + 1 < irelaend
12418 && irela[1].r_offset == irela->r_offset + 4
12419 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12420 {
12421 if (!tocsave_find (htab, INSERT,
12422 &local_syms, irela + 1, input_bfd))
12423 goto error_ret_free_internal;
12424 }
12425 else if (stub_type == ppc_stub_plt_call)
12426 stub_type = ppc_stub_plt_call_r2save;
12427
12428 /* Support for grouping stub sections. */
12429 id_sec = htab->sec_info[section->id].u.group->link_sec;
12430
12431 /* Get the name of this stub. */
12432 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12433 if (!stub_name)
12434 goto error_ret_free_internal;
12435
12436 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12437 stub_name, FALSE, FALSE);
12438 if (stub_entry != NULL)
12439 {
12440 /* The proper stub has already been created. */
12441 free (stub_name);
12442 if (stub_type == ppc_stub_plt_call_r2save)
12443 stub_entry->stub_type = stub_type;
12444 continue;
12445 }
12446
12447 stub_entry = ppc_add_stub (stub_name, section, info);
12448 if (stub_entry == NULL)
12449 {
12450 free (stub_name);
12451 error_ret_free_internal:
12452 if (elf_section_data (section)->relocs == NULL)
12453 free (internal_relocs);
12454 error_ret_free_local:
12455 if (local_syms != NULL
12456 && (symtab_hdr->contents
12457 != (unsigned char *) local_syms))
12458 free (local_syms);
12459 return FALSE;
12460 }
12461
12462 stub_entry->stub_type = stub_type;
12463 if (stub_type != ppc_stub_plt_call
12464 && stub_type != ppc_stub_plt_call_r2save)
12465 {
12466 stub_entry->target_value = code_value;
12467 stub_entry->target_section = code_sec;
12468 }
12469 else
12470 {
12471 stub_entry->target_value = sym_value;
12472 stub_entry->target_section = sym_sec;
12473 }
12474 stub_entry->h = hash;
12475 stub_entry->plt_ent = plt_ent;
12476 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12477
12478 if (stub_entry->h != NULL)
12479 htab->stub_globals += 1;
12480 }
12481
12482 /* We're done with the internal relocs, free them. */
12483 if (elf_section_data (section)->relocs != internal_relocs)
12484 free (internal_relocs);
12485 }
12486
12487 if (local_syms != NULL
12488 && symtab_hdr->contents != (unsigned char *) local_syms)
12489 {
12490 if (!info->keep_memory)
12491 free (local_syms);
12492 else
12493 symtab_hdr->contents = (unsigned char *) local_syms;
12494 }
12495 }
12496
12497 /* We may have added some stubs. Find out the new size of the
12498 stub sections. */
12499 for (stub_sec = htab->params->stub_bfd->sections;
12500 stub_sec != NULL;
12501 stub_sec = stub_sec->next)
12502 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12503 {
12504 stub_sec->rawsize = stub_sec->size;
12505 stub_sec->size = 0;
12506 stub_sec->reloc_count = 0;
12507 stub_sec->flags &= ~SEC_RELOC;
12508 }
12509
12510 htab->brlt->size = 0;
12511 htab->brlt->reloc_count = 0;
12512 htab->brlt->flags &= ~SEC_RELOC;
12513 if (htab->relbrlt != NULL)
12514 htab->relbrlt->size = 0;
12515
12516 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12517
12518 for (group = htab->group; group != NULL; group = group->next)
12519 if (group->needs_save_res)
12520 group->stub_sec->size += htab->sfpr->size;
12521
12522 if (info->emitrelocations
12523 && htab->glink != NULL && htab->glink->size != 0)
12524 {
12525 htab->glink->reloc_count = 1;
12526 htab->glink->flags |= SEC_RELOC;
12527 }
12528
12529 if (htab->glink_eh_frame != NULL
12530 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12531 && htab->glink_eh_frame->output_section->size != 0)
12532 {
12533 size_t size = 0, align;
12534
12535 for (stub_sec = htab->params->stub_bfd->sections;
12536 stub_sec != NULL;
12537 stub_sec = stub_sec->next)
12538 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12539 size += 24;
12540 if (htab->glink != NULL && htab->glink->size != 0)
12541 size += 24;
12542 if (size != 0)
12543 size += sizeof (glink_eh_frame_cie);
12544 align = 1;
12545 align <<= htab->glink_eh_frame->output_section->alignment_power;
12546 align -= 1;
12547 size = (size + align) & ~align;
12548 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12549 htab->glink_eh_frame->size = size;
12550 }
12551
12552 if (htab->params->plt_stub_align != 0)
12553 for (stub_sec = htab->params->stub_bfd->sections;
12554 stub_sec != NULL;
12555 stub_sec = stub_sec->next)
12556 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12557 stub_sec->size = ((stub_sec->size
12558 + (1 << htab->params->plt_stub_align) - 1)
12559 & -(1 << htab->params->plt_stub_align));
12560
12561 for (stub_sec = htab->params->stub_bfd->sections;
12562 stub_sec != NULL;
12563 stub_sec = stub_sec->next)
12564 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12565 && stub_sec->rawsize != stub_sec->size)
12566 break;
12567
12568 /* Exit from this loop when no stubs have been added, and no stubs
12569 have changed size. */
12570 if (stub_sec == NULL
12571 && (htab->glink_eh_frame == NULL
12572 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12573 break;
12574
12575 /* Ask the linker to do its stuff. */
12576 (*htab->params->layout_sections_again) ();
12577 }
12578
12579 if (htab->glink_eh_frame != NULL
12580 && htab->glink_eh_frame->size != 0)
12581 {
12582 bfd_vma val;
12583 bfd_byte *p, *last_fde;
12584 size_t last_fde_len, size, align, pad;
12585 asection *stub_sec;
12586
12587 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12588 if (p == NULL)
12589 return FALSE;
12590 htab->glink_eh_frame->contents = p;
12591 last_fde = p;
12592
12593 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12594 /* CIE length (rewrite in case little-endian). */
12595 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12596 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12597 p += sizeof (glink_eh_frame_cie);
12598
12599 for (stub_sec = htab->params->stub_bfd->sections;
12600 stub_sec != NULL;
12601 stub_sec = stub_sec->next)
12602 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12603 {
12604 last_fde = p;
12605 last_fde_len = 20;
12606 /* FDE length. */
12607 bfd_put_32 (htab->elf.dynobj, 20, p);
12608 p += 4;
12609 /* CIE pointer. */
12610 val = p - htab->glink_eh_frame->contents;
12611 bfd_put_32 (htab->elf.dynobj, val, p);
12612 p += 4;
12613 /* Offset to stub section, written later. */
12614 p += 4;
12615 /* stub section size. */
12616 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12617 p += 4;
12618 /* Augmentation. */
12619 p += 1;
12620 /* Pad. */
12621 p += 7;
12622 }
12623 if (htab->glink != NULL && htab->glink->size != 0)
12624 {
12625 last_fde = p;
12626 last_fde_len = 20;
12627 /* FDE length. */
12628 bfd_put_32 (htab->elf.dynobj, 20, p);
12629 p += 4;
12630 /* CIE pointer. */
12631 val = p - htab->glink_eh_frame->contents;
12632 bfd_put_32 (htab->elf.dynobj, val, p);
12633 p += 4;
12634 /* Offset to .glink, written later. */
12635 p += 4;
12636 /* .glink size. */
12637 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12638 p += 4;
12639 /* Augmentation. */
12640 p += 1;
12641
12642 *p++ = DW_CFA_advance_loc + 1;
12643 *p++ = DW_CFA_register;
12644 *p++ = 65;
12645 *p++ = htab->opd_abi ? 12 : 0;
12646 *p++ = DW_CFA_advance_loc + 4;
12647 *p++ = DW_CFA_restore_extended;
12648 *p++ = 65;
12649 }
12650 /* Subsume any padding into the last FDE if user .eh_frame
12651 sections are aligned more than glink_eh_frame. Otherwise any
12652 zero padding will be seen as a terminator. */
12653 size = p - htab->glink_eh_frame->contents;
12654 align = 1;
12655 align <<= htab->glink_eh_frame->output_section->alignment_power;
12656 align -= 1;
12657 pad = ((size + align) & ~align) - size;
12658 htab->glink_eh_frame->size = size + pad;
12659 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12660 }
12661
12662 maybe_strip_output (info, htab->brlt);
12663 if (htab->glink_eh_frame != NULL)
12664 maybe_strip_output (info, htab->glink_eh_frame);
12665
12666 return TRUE;
12667 }
12668
12669 /* Called after we have determined section placement. If sections
12670 move, we'll be called again. Provide a value for TOCstart. */
12671
12672 bfd_vma
12673 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12674 {
12675 asection *s;
12676 bfd_vma TOCstart, adjust;
12677
12678 if (info != NULL)
12679 {
12680 struct elf_link_hash_entry *h;
12681 struct elf_link_hash_table *htab = elf_hash_table (info);
12682
12683 if (is_elf_hash_table (htab)
12684 && htab->hgot != NULL)
12685 h = htab->hgot;
12686 else
12687 {
12688 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12689 if (is_elf_hash_table (htab))
12690 htab->hgot = h;
12691 }
12692 if (h != NULL
12693 && h->root.type == bfd_link_hash_defined
12694 && !h->root.linker_def
12695 && (!is_elf_hash_table (htab)
12696 || h->def_regular))
12697 {
12698 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12699 + h->root.u.def.section->output_offset
12700 + h->root.u.def.section->output_section->vma);
12701 _bfd_set_gp_value (obfd, TOCstart);
12702 return TOCstart;
12703 }
12704 }
12705
12706 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12707 order. The TOC starts where the first of these sections starts. */
12708 s = bfd_get_section_by_name (obfd, ".got");
12709 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12710 s = bfd_get_section_by_name (obfd, ".toc");
12711 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12712 s = bfd_get_section_by_name (obfd, ".tocbss");
12713 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12714 s = bfd_get_section_by_name (obfd, ".plt");
12715 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12716 {
12717 /* This may happen for
12718 o references to TOC base (SYM@toc / TOC[tc0]) without a
12719 .toc directive
12720 o bad linker script
12721 o --gc-sections and empty TOC sections
12722
12723 FIXME: Warn user? */
12724
12725 /* Look for a likely section. We probably won't even be
12726 using TOCstart. */
12727 for (s = obfd->sections; s != NULL; s = s->next)
12728 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12729 | SEC_EXCLUDE))
12730 == (SEC_ALLOC | SEC_SMALL_DATA))
12731 break;
12732 if (s == NULL)
12733 for (s = obfd->sections; s != NULL; s = s->next)
12734 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12735 == (SEC_ALLOC | SEC_SMALL_DATA))
12736 break;
12737 if (s == NULL)
12738 for (s = obfd->sections; s != NULL; s = s->next)
12739 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12740 == SEC_ALLOC)
12741 break;
12742 if (s == NULL)
12743 for (s = obfd->sections; s != NULL; s = s->next)
12744 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12745 break;
12746 }
12747
12748 TOCstart = 0;
12749 if (s != NULL)
12750 TOCstart = s->output_section->vma + s->output_offset;
12751
12752 /* Force alignment. */
12753 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12754 TOCstart -= adjust;
12755 _bfd_set_gp_value (obfd, TOCstart);
12756
12757 if (info != NULL && s != NULL)
12758 {
12759 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12760
12761 if (htab != NULL)
12762 {
12763 if (htab->elf.hgot != NULL)
12764 {
12765 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12766 htab->elf.hgot->root.u.def.section = s;
12767 }
12768 }
12769 else
12770 {
12771 struct bfd_link_hash_entry *bh = NULL;
12772 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12773 s, TOC_BASE_OFF - adjust,
12774 NULL, FALSE, FALSE, &bh);
12775 }
12776 }
12777 return TOCstart;
12778 }
12779
12780 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12781 write out any global entry stubs. */
12782
12783 static bfd_boolean
12784 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12785 {
12786 struct bfd_link_info *info;
12787 struct ppc_link_hash_table *htab;
12788 struct plt_entry *pent;
12789 asection *s;
12790
12791 if (h->root.type == bfd_link_hash_indirect)
12792 return TRUE;
12793
12794 if (!h->pointer_equality_needed)
12795 return TRUE;
12796
12797 if (h->def_regular)
12798 return TRUE;
12799
12800 info = inf;
12801 htab = ppc_hash_table (info);
12802 if (htab == NULL)
12803 return FALSE;
12804
12805 s = htab->glink;
12806 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12807 if (pent->plt.offset != (bfd_vma) -1
12808 && pent->addend == 0)
12809 {
12810 bfd_byte *p;
12811 asection *plt;
12812 bfd_vma off;
12813
12814 p = s->contents + h->root.u.def.value;
12815 plt = htab->elf.splt;
12816 if (!htab->elf.dynamic_sections_created
12817 || h->dynindx == -1)
12818 plt = htab->elf.iplt;
12819 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12820 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12821
12822 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12823 {
12824 info->callbacks->einfo
12825 (_("%P: linkage table error against `%T'\n"),
12826 h->root.root.string);
12827 bfd_set_error (bfd_error_bad_value);
12828 htab->stub_error = TRUE;
12829 }
12830
12831 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12832 if (htab->params->emit_stub_syms)
12833 {
12834 size_t len = strlen (h->root.root.string);
12835 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12836
12837 if (name == NULL)
12838 return FALSE;
12839
12840 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12841 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12842 if (h == NULL)
12843 return FALSE;
12844 if (h->root.type == bfd_link_hash_new)
12845 {
12846 h->root.type = bfd_link_hash_defined;
12847 h->root.u.def.section = s;
12848 h->root.u.def.value = p - s->contents;
12849 h->ref_regular = 1;
12850 h->def_regular = 1;
12851 h->ref_regular_nonweak = 1;
12852 h->forced_local = 1;
12853 h->non_elf = 0;
12854 h->root.linker_def = 1;
12855 }
12856 }
12857
12858 if (PPC_HA (off) != 0)
12859 {
12860 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12861 p += 4;
12862 }
12863 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12864 p += 4;
12865 bfd_put_32 (s->owner, MTCTR_R12, p);
12866 p += 4;
12867 bfd_put_32 (s->owner, BCTR, p);
12868 break;
12869 }
12870 return TRUE;
12871 }
12872
12873 /* Build all the stubs associated with the current output file.
12874 The stubs are kept in a hash table attached to the main linker
12875 hash table. This function is called via gldelf64ppc_finish. */
12876
12877 bfd_boolean
12878 ppc64_elf_build_stubs (struct bfd_link_info *info,
12879 char **stats)
12880 {
12881 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12882 struct map_stub *group;
12883 asection *stub_sec;
12884 bfd_byte *p;
12885 int stub_sec_count = 0;
12886
12887 if (htab == NULL)
12888 return FALSE;
12889
12890 /* Allocate memory to hold the linker stubs. */
12891 for (stub_sec = htab->params->stub_bfd->sections;
12892 stub_sec != NULL;
12893 stub_sec = stub_sec->next)
12894 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12895 && stub_sec->size != 0)
12896 {
12897 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12898 if (stub_sec->contents == NULL)
12899 return FALSE;
12900 /* We want to check that built size is the same as calculated
12901 size. rawsize is a convenient location to use. */
12902 stub_sec->rawsize = stub_sec->size;
12903 stub_sec->size = 0;
12904 }
12905
12906 if (htab->glink != NULL && htab->glink->size != 0)
12907 {
12908 unsigned int indx;
12909 bfd_vma plt0;
12910
12911 /* Build the .glink plt call stub. */
12912 if (htab->params->emit_stub_syms)
12913 {
12914 struct elf_link_hash_entry *h;
12915 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12916 TRUE, FALSE, FALSE);
12917 if (h == NULL)
12918 return FALSE;
12919 if (h->root.type == bfd_link_hash_new)
12920 {
12921 h->root.type = bfd_link_hash_defined;
12922 h->root.u.def.section = htab->glink;
12923 h->root.u.def.value = 8;
12924 h->ref_regular = 1;
12925 h->def_regular = 1;
12926 h->ref_regular_nonweak = 1;
12927 h->forced_local = 1;
12928 h->non_elf = 0;
12929 h->root.linker_def = 1;
12930 }
12931 }
12932 plt0 = (htab->elf.splt->output_section->vma
12933 + htab->elf.splt->output_offset
12934 - 16);
12935 if (info->emitrelocations)
12936 {
12937 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12938 if (r == NULL)
12939 return FALSE;
12940 r->r_offset = (htab->glink->output_offset
12941 + htab->glink->output_section->vma);
12942 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12943 r->r_addend = plt0;
12944 }
12945 p = htab->glink->contents;
12946 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12947 bfd_put_64 (htab->glink->owner, plt0, p);
12948 p += 8;
12949 if (htab->opd_abi)
12950 {
12951 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12952 p += 4;
12953 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12954 p += 4;
12955 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12956 p += 4;
12957 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12958 p += 4;
12959 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12960 p += 4;
12961 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12962 p += 4;
12963 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12964 p += 4;
12965 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12966 p += 4;
12967 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12968 p += 4;
12969 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12970 p += 4;
12971 }
12972 else
12973 {
12974 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12975 p += 4;
12976 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12977 p += 4;
12978 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12979 p += 4;
12980 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12981 p += 4;
12982 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12983 p += 4;
12984 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12985 p += 4;
12986 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12987 p += 4;
12988 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12989 p += 4;
12990 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12991 p += 4;
12992 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12993 p += 4;
12994 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12995 p += 4;
12996 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12997 p += 4;
12998 }
12999 bfd_put_32 (htab->glink->owner, BCTR, p);
13000 p += 4;
13001 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13002 {
13003 bfd_put_32 (htab->glink->owner, NOP, p);
13004 p += 4;
13005 }
13006
13007 /* Build the .glink lazy link call stubs. */
13008 indx = 0;
13009 while (p < htab->glink->contents + htab->glink->rawsize)
13010 {
13011 if (htab->opd_abi)
13012 {
13013 if (indx < 0x8000)
13014 {
13015 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13016 p += 4;
13017 }
13018 else
13019 {
13020 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13021 p += 4;
13022 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13023 p);
13024 p += 4;
13025 }
13026 }
13027 bfd_put_32 (htab->glink->owner,
13028 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13029 indx++;
13030 p += 4;
13031 }
13032
13033 /* Build .glink global entry stubs. */
13034 if (htab->glink->size > htab->glink->rawsize)
13035 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13036 }
13037
13038 if (htab->brlt != NULL && htab->brlt->size != 0)
13039 {
13040 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13041 htab->brlt->size);
13042 if (htab->brlt->contents == NULL)
13043 return FALSE;
13044 }
13045 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13046 {
13047 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13048 htab->relbrlt->size);
13049 if (htab->relbrlt->contents == NULL)
13050 return FALSE;
13051 }
13052
13053 /* Build the stubs as directed by the stub hash table. */
13054 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13055
13056 for (group = htab->group; group != NULL; group = group->next)
13057 if (group->needs_save_res)
13058 {
13059 stub_sec = group->stub_sec;
13060 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13061 htab->sfpr->size);
13062 if (htab->params->emit_stub_syms)
13063 {
13064 unsigned int i;
13065
13066 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13067 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13068 return FALSE;
13069 }
13070 stub_sec->size += htab->sfpr->size;
13071 }
13072
13073 if (htab->relbrlt != NULL)
13074 htab->relbrlt->reloc_count = 0;
13075
13076 if (htab->params->plt_stub_align != 0)
13077 for (stub_sec = htab->params->stub_bfd->sections;
13078 stub_sec != NULL;
13079 stub_sec = stub_sec->next)
13080 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13081 stub_sec->size = ((stub_sec->size
13082 + (1 << htab->params->plt_stub_align) - 1)
13083 & -(1 << htab->params->plt_stub_align));
13084
13085 for (stub_sec = htab->params->stub_bfd->sections;
13086 stub_sec != NULL;
13087 stub_sec = stub_sec->next)
13088 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13089 {
13090 stub_sec_count += 1;
13091 if (stub_sec->rawsize != stub_sec->size)
13092 break;
13093 }
13094
13095 /* Note that the glink_eh_frame check here is not only testing that
13096 the generated size matched the calculated size but also that
13097 bfd_elf_discard_info didn't make any changes to the section. */
13098 if (stub_sec != NULL
13099 || (htab->glink_eh_frame != NULL
13100 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13101 {
13102 htab->stub_error = TRUE;
13103 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13104 }
13105
13106 if (htab->stub_error)
13107 return FALSE;
13108
13109 if (stats != NULL)
13110 {
13111 *stats = bfd_malloc (500);
13112 if (*stats == NULL)
13113 return FALSE;
13114
13115 sprintf (*stats, _("linker stubs in %u group%s\n"
13116 " branch %lu\n"
13117 " toc adjust %lu\n"
13118 " long branch %lu\n"
13119 " long toc adj %lu\n"
13120 " plt call %lu\n"
13121 " plt call toc %lu\n"
13122 " global entry %lu"),
13123 stub_sec_count,
13124 stub_sec_count == 1 ? "" : "s",
13125 htab->stub_count[ppc_stub_long_branch - 1],
13126 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13127 htab->stub_count[ppc_stub_plt_branch - 1],
13128 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13129 htab->stub_count[ppc_stub_plt_call - 1],
13130 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13131 htab->stub_count[ppc_stub_global_entry - 1]);
13132 }
13133 return TRUE;
13134 }
13135
13136 /* This function undoes the changes made by add_symbol_adjust. */
13137
13138 static bfd_boolean
13139 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13140 {
13141 struct ppc_link_hash_entry *eh;
13142
13143 if (h->root.type == bfd_link_hash_indirect)
13144 return TRUE;
13145
13146 eh = (struct ppc_link_hash_entry *) h;
13147 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13148 return TRUE;
13149
13150 eh->elf.root.type = bfd_link_hash_undefined;
13151 return TRUE;
13152 }
13153
13154 void
13155 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13156 {
13157 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13158
13159 if (htab != NULL)
13160 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13161 }
13162
13163 /* What to do when ld finds relocations against symbols defined in
13164 discarded sections. */
13165
13166 static unsigned int
13167 ppc64_elf_action_discarded (asection *sec)
13168 {
13169 if (strcmp (".opd", sec->name) == 0)
13170 return 0;
13171
13172 if (strcmp (".toc", sec->name) == 0)
13173 return 0;
13174
13175 if (strcmp (".toc1", sec->name) == 0)
13176 return 0;
13177
13178 return _bfd_elf_default_action_discarded (sec);
13179 }
13180
13181 /* The RELOCATE_SECTION function is called by the ELF backend linker
13182 to handle the relocations for a section.
13183
13184 The relocs are always passed as Rela structures; if the section
13185 actually uses Rel structures, the r_addend field will always be
13186 zero.
13187
13188 This function is responsible for adjust the section contents as
13189 necessary, and (if using Rela relocs and generating a
13190 relocatable output file) adjusting the reloc addend as
13191 necessary.
13192
13193 This function does not have to worry about setting the reloc
13194 address or the reloc symbol index.
13195
13196 LOCAL_SYMS is a pointer to the swapped in local symbols.
13197
13198 LOCAL_SECTIONS is an array giving the section in the input file
13199 corresponding to the st_shndx field of each local symbol.
13200
13201 The global hash table entry for the global symbols can be found
13202 via elf_sym_hashes (input_bfd).
13203
13204 When generating relocatable output, this function must handle
13205 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13206 going to be the section symbol corresponding to the output
13207 section, which means that the addend must be adjusted
13208 accordingly. */
13209
13210 static bfd_boolean
13211 ppc64_elf_relocate_section (bfd *output_bfd,
13212 struct bfd_link_info *info,
13213 bfd *input_bfd,
13214 asection *input_section,
13215 bfd_byte *contents,
13216 Elf_Internal_Rela *relocs,
13217 Elf_Internal_Sym *local_syms,
13218 asection **local_sections)
13219 {
13220 struct ppc_link_hash_table *htab;
13221 Elf_Internal_Shdr *symtab_hdr;
13222 struct elf_link_hash_entry **sym_hashes;
13223 Elf_Internal_Rela *rel;
13224 Elf_Internal_Rela *wrel;
13225 Elf_Internal_Rela *relend;
13226 Elf_Internal_Rela outrel;
13227 bfd_byte *loc;
13228 struct got_entry **local_got_ents;
13229 bfd_vma TOCstart;
13230 bfd_boolean ret = TRUE;
13231 bfd_boolean is_opd;
13232 /* Assume 'at' branch hints. */
13233 bfd_boolean is_isa_v2 = TRUE;
13234 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13235
13236 /* Initialize howto table if needed. */
13237 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13238 ppc_howto_init ();
13239
13240 htab = ppc_hash_table (info);
13241 if (htab == NULL)
13242 return FALSE;
13243
13244 /* Don't relocate stub sections. */
13245 if (input_section->owner == htab->params->stub_bfd)
13246 return TRUE;
13247
13248 BFD_ASSERT (is_ppc64_elf (input_bfd));
13249
13250 local_got_ents = elf_local_got_ents (input_bfd);
13251 TOCstart = elf_gp (output_bfd);
13252 symtab_hdr = &elf_symtab_hdr (input_bfd);
13253 sym_hashes = elf_sym_hashes (input_bfd);
13254 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13255
13256 rel = wrel = relocs;
13257 relend = relocs + input_section->reloc_count;
13258 for (; rel < relend; wrel++, rel++)
13259 {
13260 enum elf_ppc64_reloc_type r_type;
13261 bfd_vma addend;
13262 bfd_reloc_status_type r;
13263 Elf_Internal_Sym *sym;
13264 asection *sec;
13265 struct elf_link_hash_entry *h_elf;
13266 struct ppc_link_hash_entry *h;
13267 struct ppc_link_hash_entry *fdh;
13268 const char *sym_name;
13269 unsigned long r_symndx, toc_symndx;
13270 bfd_vma toc_addend;
13271 unsigned char tls_mask, tls_gd, tls_type;
13272 unsigned char sym_type;
13273 bfd_vma relocation;
13274 bfd_boolean unresolved_reloc;
13275 bfd_boolean warned;
13276 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13277 unsigned int insn;
13278 unsigned int mask;
13279 struct ppc_stub_hash_entry *stub_entry;
13280 bfd_vma max_br_offset;
13281 bfd_vma from;
13282 Elf_Internal_Rela orig_rel;
13283 reloc_howto_type *howto;
13284 struct reloc_howto_struct alt_howto;
13285
13286 again:
13287 orig_rel = *rel;
13288
13289 r_type = ELF64_R_TYPE (rel->r_info);
13290 r_symndx = ELF64_R_SYM (rel->r_info);
13291
13292 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13293 symbol of the previous ADDR64 reloc. The symbol gives us the
13294 proper TOC base to use. */
13295 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13296 && wrel != relocs
13297 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13298 && is_opd)
13299 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13300
13301 sym = NULL;
13302 sec = NULL;
13303 h_elf = NULL;
13304 sym_name = NULL;
13305 unresolved_reloc = FALSE;
13306 warned = FALSE;
13307
13308 if (r_symndx < symtab_hdr->sh_info)
13309 {
13310 /* It's a local symbol. */
13311 struct _opd_sec_data *opd;
13312
13313 sym = local_syms + r_symndx;
13314 sec = local_sections[r_symndx];
13315 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13316 sym_type = ELF64_ST_TYPE (sym->st_info);
13317 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13318 opd = get_opd_info (sec);
13319 if (opd != NULL && opd->adjust != NULL)
13320 {
13321 long adjust = opd->adjust[OPD_NDX (sym->st_value
13322 + rel->r_addend)];
13323 if (adjust == -1)
13324 relocation = 0;
13325 else
13326 {
13327 /* If this is a relocation against the opd section sym
13328 and we have edited .opd, adjust the reloc addend so
13329 that ld -r and ld --emit-relocs output is correct.
13330 If it is a reloc against some other .opd symbol,
13331 then the symbol value will be adjusted later. */
13332 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13333 rel->r_addend += adjust;
13334 else
13335 relocation += adjust;
13336 }
13337 }
13338 }
13339 else
13340 {
13341 bfd_boolean ignored;
13342
13343 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13344 r_symndx, symtab_hdr, sym_hashes,
13345 h_elf, sec, relocation,
13346 unresolved_reloc, warned, ignored);
13347 sym_name = h_elf->root.root.string;
13348 sym_type = h_elf->type;
13349 if (sec != NULL
13350 && sec->owner == output_bfd
13351 && strcmp (sec->name, ".opd") == 0)
13352 {
13353 /* This is a symbol defined in a linker script. All
13354 such are defined in output sections, even those
13355 defined by simple assignment from a symbol defined in
13356 an input section. Transfer the symbol to an
13357 appropriate input .opd section, so that a branch to
13358 this symbol will be mapped to the location specified
13359 by the opd entry. */
13360 struct bfd_link_order *lo;
13361 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13362 if (lo->type == bfd_indirect_link_order)
13363 {
13364 asection *isec = lo->u.indirect.section;
13365 if (h_elf->root.u.def.value >= isec->output_offset
13366 && h_elf->root.u.def.value < (isec->output_offset
13367 + isec->size))
13368 {
13369 h_elf->root.u.def.value -= isec->output_offset;
13370 h_elf->root.u.def.section = isec;
13371 sec = isec;
13372 break;
13373 }
13374 }
13375 }
13376 }
13377 h = (struct ppc_link_hash_entry *) h_elf;
13378
13379 if (sec != NULL && discarded_section (sec))
13380 {
13381 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13382 input_bfd, input_section,
13383 contents + rel->r_offset);
13384 wrel->r_offset = rel->r_offset;
13385 wrel->r_info = 0;
13386 wrel->r_addend = 0;
13387
13388 /* For ld -r, remove relocations in debug sections against
13389 sections defined in discarded sections. Not done for
13390 non-debug to preserve relocs in .eh_frame which the
13391 eh_frame editing code expects to be present. */
13392 if (bfd_link_relocatable (info)
13393 && (input_section->flags & SEC_DEBUGGING))
13394 wrel--;
13395
13396 continue;
13397 }
13398
13399 if (bfd_link_relocatable (info))
13400 goto copy_reloc;
13401
13402 if (h != NULL && &h->elf == htab->elf.hgot)
13403 {
13404 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13405 sec = bfd_abs_section_ptr;
13406 unresolved_reloc = FALSE;
13407 }
13408
13409 /* TLS optimizations. Replace instruction sequences and relocs
13410 based on information we collected in tls_optimize. We edit
13411 RELOCS so that --emit-relocs will output something sensible
13412 for the final instruction stream. */
13413 tls_mask = 0;
13414 tls_gd = 0;
13415 toc_symndx = 0;
13416 if (h != NULL)
13417 tls_mask = h->tls_mask;
13418 else if (local_got_ents != NULL)
13419 {
13420 struct plt_entry **local_plt = (struct plt_entry **)
13421 (local_got_ents + symtab_hdr->sh_info);
13422 unsigned char *lgot_masks = (unsigned char *)
13423 (local_plt + symtab_hdr->sh_info);
13424 tls_mask = lgot_masks[r_symndx];
13425 }
13426 if (tls_mask == 0
13427 && (r_type == R_PPC64_TLS
13428 || r_type == R_PPC64_TLSGD
13429 || r_type == R_PPC64_TLSLD))
13430 {
13431 /* Check for toc tls entries. */
13432 unsigned char *toc_tls;
13433
13434 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13435 &local_syms, rel, input_bfd))
13436 return FALSE;
13437
13438 if (toc_tls)
13439 tls_mask = *toc_tls;
13440 }
13441
13442 /* Check that tls relocs are used with tls syms, and non-tls
13443 relocs are used with non-tls syms. */
13444 if (r_symndx != STN_UNDEF
13445 && r_type != R_PPC64_NONE
13446 && (h == NULL
13447 || h->elf.root.type == bfd_link_hash_defined
13448 || h->elf.root.type == bfd_link_hash_defweak)
13449 && (IS_PPC64_TLS_RELOC (r_type)
13450 != (sym_type == STT_TLS
13451 || (sym_type == STT_SECTION
13452 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13453 {
13454 if (tls_mask != 0
13455 && (r_type == R_PPC64_TLS
13456 || r_type == R_PPC64_TLSGD
13457 || r_type == R_PPC64_TLSLD))
13458 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13459 ;
13460 else
13461 info->callbacks->einfo
13462 (!IS_PPC64_TLS_RELOC (r_type)
13463 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13464 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13465 input_bfd, input_section, rel->r_offset,
13466 ppc64_elf_howto_table[r_type]->name,
13467 sym_name);
13468 }
13469
13470 /* Ensure reloc mapping code below stays sane. */
13471 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13472 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13473 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13474 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13475 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13476 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13477 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13478 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13479 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13480 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13481 abort ();
13482
13483 switch (r_type)
13484 {
13485 default:
13486 break;
13487
13488 case R_PPC64_LO_DS_OPT:
13489 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13490 if ((insn & (0x3f << 26)) != 58u << 26)
13491 abort ();
13492 insn += (14u << 26) - (58u << 26);
13493 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13494 r_type = R_PPC64_TOC16_LO;
13495 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13496 break;
13497
13498 case R_PPC64_TOC16:
13499 case R_PPC64_TOC16_LO:
13500 case R_PPC64_TOC16_DS:
13501 case R_PPC64_TOC16_LO_DS:
13502 {
13503 /* Check for toc tls entries. */
13504 unsigned char *toc_tls;
13505 int retval;
13506
13507 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13508 &local_syms, rel, input_bfd);
13509 if (retval == 0)
13510 return FALSE;
13511
13512 if (toc_tls)
13513 {
13514 tls_mask = *toc_tls;
13515 if (r_type == R_PPC64_TOC16_DS
13516 || r_type == R_PPC64_TOC16_LO_DS)
13517 {
13518 if (tls_mask != 0
13519 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13520 goto toctprel;
13521 }
13522 else
13523 {
13524 /* If we found a GD reloc pair, then we might be
13525 doing a GD->IE transition. */
13526 if (retval == 2)
13527 {
13528 tls_gd = TLS_TPRELGD;
13529 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13530 goto tls_ldgd_opt;
13531 }
13532 else if (retval == 3)
13533 {
13534 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13535 goto tls_ldgd_opt;
13536 }
13537 }
13538 }
13539 }
13540 break;
13541
13542 case R_PPC64_GOT_TPREL16_HI:
13543 case R_PPC64_GOT_TPREL16_HA:
13544 if (tls_mask != 0
13545 && (tls_mask & TLS_TPREL) == 0)
13546 {
13547 rel->r_offset -= d_offset;
13548 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13549 r_type = R_PPC64_NONE;
13550 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13551 }
13552 break;
13553
13554 case R_PPC64_GOT_TPREL16_DS:
13555 case R_PPC64_GOT_TPREL16_LO_DS:
13556 if (tls_mask != 0
13557 && (tls_mask & TLS_TPREL) == 0)
13558 {
13559 toctprel:
13560 insn = bfd_get_32 (output_bfd,
13561 contents + rel->r_offset - d_offset);
13562 insn &= 31 << 21;
13563 insn |= 0x3c0d0000; /* addis 0,13,0 */
13564 bfd_put_32 (output_bfd, insn,
13565 contents + rel->r_offset - d_offset);
13566 r_type = R_PPC64_TPREL16_HA;
13567 if (toc_symndx != 0)
13568 {
13569 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13570 rel->r_addend = toc_addend;
13571 /* We changed the symbol. Start over in order to
13572 get h, sym, sec etc. right. */
13573 goto again;
13574 }
13575 else
13576 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13577 }
13578 break;
13579
13580 case R_PPC64_TLS:
13581 if (tls_mask != 0
13582 && (tls_mask & TLS_TPREL) == 0)
13583 {
13584 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13585 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13586 if (insn == 0)
13587 abort ();
13588 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13589 /* Was PPC64_TLS which sits on insn boundary, now
13590 PPC64_TPREL16_LO which is at low-order half-word. */
13591 rel->r_offset += d_offset;
13592 r_type = R_PPC64_TPREL16_LO;
13593 if (toc_symndx != 0)
13594 {
13595 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13596 rel->r_addend = toc_addend;
13597 /* We changed the symbol. Start over in order to
13598 get h, sym, sec etc. right. */
13599 goto again;
13600 }
13601 else
13602 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13603 }
13604 break;
13605
13606 case R_PPC64_GOT_TLSGD16_HI:
13607 case R_PPC64_GOT_TLSGD16_HA:
13608 tls_gd = TLS_TPRELGD;
13609 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13610 goto tls_gdld_hi;
13611 break;
13612
13613 case R_PPC64_GOT_TLSLD16_HI:
13614 case R_PPC64_GOT_TLSLD16_HA:
13615 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13616 {
13617 tls_gdld_hi:
13618 if ((tls_mask & tls_gd) != 0)
13619 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13620 + R_PPC64_GOT_TPREL16_DS);
13621 else
13622 {
13623 rel->r_offset -= d_offset;
13624 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13625 r_type = R_PPC64_NONE;
13626 }
13627 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13628 }
13629 break;
13630
13631 case R_PPC64_GOT_TLSGD16:
13632 case R_PPC64_GOT_TLSGD16_LO:
13633 tls_gd = TLS_TPRELGD;
13634 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13635 goto tls_ldgd_opt;
13636 break;
13637
13638 case R_PPC64_GOT_TLSLD16:
13639 case R_PPC64_GOT_TLSLD16_LO:
13640 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13641 {
13642 unsigned int insn1, insn2, insn3;
13643 bfd_vma offset;
13644
13645 tls_ldgd_opt:
13646 offset = (bfd_vma) -1;
13647 /* If not using the newer R_PPC64_TLSGD/LD to mark
13648 __tls_get_addr calls, we must trust that the call
13649 stays with its arg setup insns, ie. that the next
13650 reloc is the __tls_get_addr call associated with
13651 the current reloc. Edit both insns. */
13652 if (input_section->has_tls_get_addr_call
13653 && rel + 1 < relend
13654 && branch_reloc_hash_match (input_bfd, rel + 1,
13655 htab->tls_get_addr,
13656 htab->tls_get_addr_fd))
13657 offset = rel[1].r_offset;
13658 /* We read the low GOT_TLS (or TOC16) insn because we
13659 need to keep the destination reg. It may be
13660 something other than the usual r3, and moved to r3
13661 before the call by intervening code. */
13662 insn1 = bfd_get_32 (output_bfd,
13663 contents + rel->r_offset - d_offset);
13664 if ((tls_mask & tls_gd) != 0)
13665 {
13666 /* IE */
13667 insn1 &= (0x1f << 21) | (0x1f << 16);
13668 insn1 |= 58 << 26; /* ld */
13669 insn2 = 0x7c636a14; /* add 3,3,13 */
13670 if (offset != (bfd_vma) -1)
13671 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13672 if ((tls_mask & TLS_EXPLICIT) == 0)
13673 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13674 + R_PPC64_GOT_TPREL16_DS);
13675 else
13676 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13677 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13678 }
13679 else
13680 {
13681 /* LE */
13682 insn1 &= 0x1f << 21;
13683 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13684 insn2 = 0x38630000; /* addi 3,3,0 */
13685 if (tls_gd == 0)
13686 {
13687 /* Was an LD reloc. */
13688 if (toc_symndx)
13689 sec = local_sections[toc_symndx];
13690 for (r_symndx = 0;
13691 r_symndx < symtab_hdr->sh_info;
13692 r_symndx++)
13693 if (local_sections[r_symndx] == sec)
13694 break;
13695 if (r_symndx >= symtab_hdr->sh_info)
13696 r_symndx = STN_UNDEF;
13697 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13698 if (r_symndx != STN_UNDEF)
13699 rel->r_addend -= (local_syms[r_symndx].st_value
13700 + sec->output_offset
13701 + sec->output_section->vma);
13702 }
13703 else if (toc_symndx != 0)
13704 {
13705 r_symndx = toc_symndx;
13706 rel->r_addend = toc_addend;
13707 }
13708 r_type = R_PPC64_TPREL16_HA;
13709 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13710 if (offset != (bfd_vma) -1)
13711 {
13712 rel[1].r_info = ELF64_R_INFO (r_symndx,
13713 R_PPC64_TPREL16_LO);
13714 rel[1].r_offset = offset + d_offset;
13715 rel[1].r_addend = rel->r_addend;
13716 }
13717 }
13718 bfd_put_32 (output_bfd, insn1,
13719 contents + rel->r_offset - d_offset);
13720 if (offset != (bfd_vma) -1)
13721 {
13722 insn3 = bfd_get_32 (output_bfd,
13723 contents + offset + 4);
13724 if (insn3 == NOP
13725 || insn3 == CROR_151515 || insn3 == CROR_313131)
13726 {
13727 rel[1].r_offset += 4;
13728 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13729 insn2 = NOP;
13730 }
13731 bfd_put_32 (output_bfd, insn2, contents + offset);
13732 }
13733 if ((tls_mask & tls_gd) == 0
13734 && (tls_gd == 0 || toc_symndx != 0))
13735 {
13736 /* We changed the symbol. Start over in order
13737 to get h, sym, sec etc. right. */
13738 goto again;
13739 }
13740 }
13741 break;
13742
13743 case R_PPC64_TLSGD:
13744 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13745 {
13746 unsigned int insn2, insn3;
13747 bfd_vma offset = rel->r_offset;
13748
13749 if ((tls_mask & TLS_TPRELGD) != 0)
13750 {
13751 /* IE */
13752 r_type = R_PPC64_NONE;
13753 insn2 = 0x7c636a14; /* add 3,3,13 */
13754 }
13755 else
13756 {
13757 /* LE */
13758 if (toc_symndx != 0)
13759 {
13760 r_symndx = toc_symndx;
13761 rel->r_addend = toc_addend;
13762 }
13763 r_type = R_PPC64_TPREL16_LO;
13764 rel->r_offset = offset + d_offset;
13765 insn2 = 0x38630000; /* addi 3,3,0 */
13766 }
13767 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13768 /* Zap the reloc on the _tls_get_addr call too. */
13769 BFD_ASSERT (offset == rel[1].r_offset);
13770 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13771 insn3 = bfd_get_32 (output_bfd,
13772 contents + offset + 4);
13773 if (insn3 == NOP
13774 || insn3 == CROR_151515 || insn3 == CROR_313131)
13775 {
13776 rel->r_offset += 4;
13777 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13778 insn2 = NOP;
13779 }
13780 bfd_put_32 (output_bfd, insn2, contents + offset);
13781 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13782 goto again;
13783 }
13784 break;
13785
13786 case R_PPC64_TLSLD:
13787 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13788 {
13789 unsigned int insn2, insn3;
13790 bfd_vma offset = rel->r_offset;
13791
13792 if (toc_symndx)
13793 sec = local_sections[toc_symndx];
13794 for (r_symndx = 0;
13795 r_symndx < symtab_hdr->sh_info;
13796 r_symndx++)
13797 if (local_sections[r_symndx] == sec)
13798 break;
13799 if (r_symndx >= symtab_hdr->sh_info)
13800 r_symndx = STN_UNDEF;
13801 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13802 if (r_symndx != STN_UNDEF)
13803 rel->r_addend -= (local_syms[r_symndx].st_value
13804 + sec->output_offset
13805 + sec->output_section->vma);
13806
13807 r_type = R_PPC64_TPREL16_LO;
13808 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13809 rel->r_offset = offset + d_offset;
13810 /* Zap the reloc on the _tls_get_addr call too. */
13811 BFD_ASSERT (offset == rel[1].r_offset);
13812 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13813 insn2 = 0x38630000; /* addi 3,3,0 */
13814 insn3 = bfd_get_32 (output_bfd,
13815 contents + offset + 4);
13816 if (insn3 == NOP
13817 || insn3 == CROR_151515 || insn3 == CROR_313131)
13818 {
13819 rel->r_offset += 4;
13820 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13821 insn2 = NOP;
13822 }
13823 bfd_put_32 (output_bfd, insn2, contents + offset);
13824 goto again;
13825 }
13826 break;
13827
13828 case R_PPC64_DTPMOD64:
13829 if (rel + 1 < relend
13830 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13831 && rel[1].r_offset == rel->r_offset + 8)
13832 {
13833 if ((tls_mask & TLS_GD) == 0)
13834 {
13835 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13836 if ((tls_mask & TLS_TPRELGD) != 0)
13837 r_type = R_PPC64_TPREL64;
13838 else
13839 {
13840 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13841 r_type = R_PPC64_NONE;
13842 }
13843 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13844 }
13845 }
13846 else
13847 {
13848 if ((tls_mask & TLS_LD) == 0)
13849 {
13850 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13851 r_type = R_PPC64_NONE;
13852 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13853 }
13854 }
13855 break;
13856
13857 case R_PPC64_TPREL64:
13858 if ((tls_mask & TLS_TPREL) == 0)
13859 {
13860 r_type = R_PPC64_NONE;
13861 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13862 }
13863 break;
13864
13865 case R_PPC64_ENTRY:
13866 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13867 if (!bfd_link_pic (info)
13868 && !info->traditional_format
13869 && relocation + 0x80008000 <= 0xffffffff)
13870 {
13871 unsigned int insn1, insn2;
13872
13873 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13874 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13875 if ((insn1 & ~0xfffc) == LD_R2_0R12
13876 && insn2 == ADD_R2_R2_R12)
13877 {
13878 bfd_put_32 (output_bfd,
13879 LIS_R2 + PPC_HA (relocation),
13880 contents + rel->r_offset);
13881 bfd_put_32 (output_bfd,
13882 ADDI_R2_R2 + PPC_LO (relocation),
13883 contents + rel->r_offset + 4);
13884 }
13885 }
13886 else
13887 {
13888 relocation -= (rel->r_offset
13889 + input_section->output_offset
13890 + input_section->output_section->vma);
13891 if (relocation + 0x80008000 <= 0xffffffff)
13892 {
13893 unsigned int insn1, insn2;
13894
13895 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13896 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13897 if ((insn1 & ~0xfffc) == LD_R2_0R12
13898 && insn2 == ADD_R2_R2_R12)
13899 {
13900 bfd_put_32 (output_bfd,
13901 ADDIS_R2_R12 + PPC_HA (relocation),
13902 contents + rel->r_offset);
13903 bfd_put_32 (output_bfd,
13904 ADDI_R2_R2 + PPC_LO (relocation),
13905 contents + rel->r_offset + 4);
13906 }
13907 }
13908 }
13909 break;
13910
13911 case R_PPC64_REL16_HA:
13912 /* If we are generating a non-PIC executable, edit
13913 . 0: addis 2,12,.TOC.-0b@ha
13914 . addi 2,2,.TOC.-0b@l
13915 used by ELFv2 global entry points to set up r2, to
13916 . lis 2,.TOC.@ha
13917 . addi 2,2,.TOC.@l
13918 if .TOC. is in range. */
13919 if (!bfd_link_pic (info)
13920 && !info->traditional_format
13921 && !htab->opd_abi
13922 && rel->r_addend == d_offset
13923 && h != NULL && &h->elf == htab->elf.hgot
13924 && rel + 1 < relend
13925 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13926 && rel[1].r_offset == rel->r_offset + 4
13927 && rel[1].r_addend == rel->r_addend + 4
13928 && relocation + 0x80008000 <= 0xffffffff)
13929 {
13930 unsigned int insn1, insn2;
13931 bfd_vma offset = rel->r_offset - d_offset;
13932 insn1 = bfd_get_32 (output_bfd, contents + offset);
13933 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13934 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13935 && (insn2 & 0xffff0000) == ADDI_R2_R2)
13936 {
13937 r_type = R_PPC64_ADDR16_HA;
13938 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13939 rel->r_addend -= d_offset;
13940 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13941 rel[1].r_addend -= d_offset + 4;
13942 bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13943 }
13944 }
13945 break;
13946 }
13947
13948 /* Handle other relocations that tweak non-addend part of insn. */
13949 insn = 0;
13950 max_br_offset = 1 << 25;
13951 addend = rel->r_addend;
13952 reloc_dest = DEST_NORMAL;
13953 switch (r_type)
13954 {
13955 default:
13956 break;
13957
13958 case R_PPC64_TOCSAVE:
13959 if (relocation + addend == (rel->r_offset
13960 + input_section->output_offset
13961 + input_section->output_section->vma)
13962 && tocsave_find (htab, NO_INSERT,
13963 &local_syms, rel, input_bfd))
13964 {
13965 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13966 if (insn == NOP
13967 || insn == CROR_151515 || insn == CROR_313131)
13968 bfd_put_32 (input_bfd,
13969 STD_R2_0R1 + STK_TOC (htab),
13970 contents + rel->r_offset);
13971 }
13972 break;
13973
13974 /* Branch taken prediction relocations. */
13975 case R_PPC64_ADDR14_BRTAKEN:
13976 case R_PPC64_REL14_BRTAKEN:
13977 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13978 /* Fall thru. */
13979
13980 /* Branch not taken prediction relocations. */
13981 case R_PPC64_ADDR14_BRNTAKEN:
13982 case R_PPC64_REL14_BRNTAKEN:
13983 insn |= bfd_get_32 (output_bfd,
13984 contents + rel->r_offset) & ~(0x01 << 21);
13985 /* Fall thru. */
13986
13987 case R_PPC64_REL14:
13988 max_br_offset = 1 << 15;
13989 /* Fall thru. */
13990
13991 case R_PPC64_REL24:
13992 /* Calls to functions with a different TOC, such as calls to
13993 shared objects, need to alter the TOC pointer. This is
13994 done using a linkage stub. A REL24 branching to these
13995 linkage stubs needs to be followed by a nop, as the nop
13996 will be replaced with an instruction to restore the TOC
13997 base pointer. */
13998 fdh = h;
13999 if (h != NULL
14000 && h->oh != NULL
14001 && h->oh->is_func_descriptor)
14002 fdh = ppc_follow_link (h->oh);
14003 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14004 htab);
14005 if (stub_entry != NULL
14006 && (stub_entry->stub_type == ppc_stub_plt_call
14007 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14008 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14009 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14010 {
14011 bfd_boolean can_plt_call = FALSE;
14012
14013 /* All of these stubs will modify r2, so there must be a
14014 branch and link followed by a nop. The nop is
14015 replaced by an insn to restore r2. */
14016 if (rel->r_offset + 8 <= input_section->size)
14017 {
14018 unsigned long br;
14019
14020 br = bfd_get_32 (input_bfd,
14021 contents + rel->r_offset);
14022 if ((br & 1) != 0)
14023 {
14024 unsigned long nop;
14025
14026 nop = bfd_get_32 (input_bfd,
14027 contents + rel->r_offset + 4);
14028 if (nop == NOP
14029 || nop == CROR_151515 || nop == CROR_313131)
14030 {
14031 if (h != NULL
14032 && (h == htab->tls_get_addr_fd
14033 || h == htab->tls_get_addr)
14034 && htab->params->tls_get_addr_opt)
14035 {
14036 /* Special stub used, leave nop alone. */
14037 }
14038 else
14039 bfd_put_32 (input_bfd,
14040 LD_R2_0R1 + STK_TOC (htab),
14041 contents + rel->r_offset + 4);
14042 can_plt_call = TRUE;
14043 }
14044 }
14045 }
14046
14047 if (!can_plt_call && h != NULL)
14048 {
14049 const char *name = h->elf.root.root.string;
14050
14051 if (*name == '.')
14052 ++name;
14053
14054 if (strncmp (name, "__libc_start_main", 17) == 0
14055 && (name[17] == 0 || name[17] == '@'))
14056 {
14057 /* Allow crt1 branch to go via a toc adjusting
14058 stub. Other calls that never return could do
14059 the same, if we could detect such. */
14060 can_plt_call = TRUE;
14061 }
14062 }
14063
14064 if (!can_plt_call)
14065 {
14066 /* g++ as of 20130507 emits self-calls without a
14067 following nop. This is arguably wrong since we
14068 have conflicting information. On the one hand a
14069 global symbol and on the other a local call
14070 sequence, but don't error for this special case.
14071 It isn't possible to cheaply verify we have
14072 exactly such a call. Allow all calls to the same
14073 section. */
14074 asection *code_sec = sec;
14075
14076 if (get_opd_info (sec) != NULL)
14077 {
14078 bfd_vma off = (relocation + addend
14079 - sec->output_section->vma
14080 - sec->output_offset);
14081
14082 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14083 }
14084 if (code_sec == input_section)
14085 can_plt_call = TRUE;
14086 }
14087
14088 if (!can_plt_call)
14089 {
14090 if (stub_entry->stub_type == ppc_stub_plt_call
14091 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14092 info->callbacks->einfo
14093 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14094 "recompile with -fPIC\n"),
14095 input_bfd, input_section, rel->r_offset, sym_name);
14096 else
14097 info->callbacks->einfo
14098 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14099 "(-mcmodel=small toc adjust stub)\n"),
14100 input_bfd, input_section, rel->r_offset, sym_name);
14101
14102 bfd_set_error (bfd_error_bad_value);
14103 ret = FALSE;
14104 }
14105
14106 if (can_plt_call
14107 && (stub_entry->stub_type == ppc_stub_plt_call
14108 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14109 unresolved_reloc = FALSE;
14110 }
14111
14112 if ((stub_entry == NULL
14113 || stub_entry->stub_type == ppc_stub_long_branch
14114 || stub_entry->stub_type == ppc_stub_plt_branch)
14115 && get_opd_info (sec) != NULL)
14116 {
14117 /* The branch destination is the value of the opd entry. */
14118 bfd_vma off = (relocation + addend
14119 - sec->output_section->vma
14120 - sec->output_offset);
14121 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14122 if (dest != (bfd_vma) -1)
14123 {
14124 relocation = dest;
14125 addend = 0;
14126 reloc_dest = DEST_OPD;
14127 }
14128 }
14129
14130 /* If the branch is out of reach we ought to have a long
14131 branch stub. */
14132 from = (rel->r_offset
14133 + input_section->output_offset
14134 + input_section->output_section->vma);
14135
14136 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14137 ? fdh->elf.other
14138 : sym->st_other);
14139
14140 if (stub_entry != NULL
14141 && (stub_entry->stub_type == ppc_stub_long_branch
14142 || stub_entry->stub_type == ppc_stub_plt_branch)
14143 && (r_type == R_PPC64_ADDR14_BRTAKEN
14144 || r_type == R_PPC64_ADDR14_BRNTAKEN
14145 || (relocation + addend - from + max_br_offset
14146 < 2 * max_br_offset)))
14147 /* Don't use the stub if this branch is in range. */
14148 stub_entry = NULL;
14149
14150 if (stub_entry != NULL)
14151 {
14152 /* Munge up the value and addend so that we call the stub
14153 rather than the procedure directly. */
14154 asection *stub_sec = stub_entry->group->stub_sec;
14155
14156 if (stub_entry->stub_type == ppc_stub_save_res)
14157 relocation += (stub_sec->output_offset
14158 + stub_sec->output_section->vma
14159 + stub_sec->size - htab->sfpr->size
14160 - htab->sfpr->output_offset
14161 - htab->sfpr->output_section->vma);
14162 else
14163 relocation = (stub_entry->stub_offset
14164 + stub_sec->output_offset
14165 + stub_sec->output_section->vma);
14166 addend = 0;
14167 reloc_dest = DEST_STUB;
14168
14169 if ((stub_entry->stub_type == ppc_stub_plt_call
14170 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14171 && (ALWAYS_EMIT_R2SAVE
14172 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14173 && rel + 1 < relend
14174 && rel[1].r_offset == rel->r_offset + 4
14175 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14176 relocation += 4;
14177 }
14178
14179 if (insn != 0)
14180 {
14181 if (is_isa_v2)
14182 {
14183 /* Set 'a' bit. This is 0b00010 in BO field for branch
14184 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14185 for branch on CTR insns (BO == 1a00t or 1a01t). */
14186 if ((insn & (0x14 << 21)) == (0x04 << 21))
14187 insn |= 0x02 << 21;
14188 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14189 insn |= 0x08 << 21;
14190 else
14191 break;
14192 }
14193 else
14194 {
14195 /* Invert 'y' bit if not the default. */
14196 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14197 insn ^= 0x01 << 21;
14198 }
14199
14200 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14201 }
14202
14203 /* NOP out calls to undefined weak functions.
14204 We can thus call a weak function without first
14205 checking whether the function is defined. */
14206 else if (h != NULL
14207 && h->elf.root.type == bfd_link_hash_undefweak
14208 && h->elf.dynindx == -1
14209 && r_type == R_PPC64_REL24
14210 && relocation == 0
14211 && addend == 0)
14212 {
14213 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14214 goto copy_reloc;
14215 }
14216 break;
14217 }
14218
14219 /* Set `addend'. */
14220 tls_type = 0;
14221 switch (r_type)
14222 {
14223 default:
14224 info->callbacks->einfo
14225 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14226 input_bfd, (int) r_type, sym_name);
14227
14228 bfd_set_error (bfd_error_bad_value);
14229 ret = FALSE;
14230 goto copy_reloc;
14231
14232 case R_PPC64_NONE:
14233 case R_PPC64_TLS:
14234 case R_PPC64_TLSGD:
14235 case R_PPC64_TLSLD:
14236 case R_PPC64_TOCSAVE:
14237 case R_PPC64_GNU_VTINHERIT:
14238 case R_PPC64_GNU_VTENTRY:
14239 case R_PPC64_ENTRY:
14240 goto copy_reloc;
14241
14242 /* GOT16 relocations. Like an ADDR16 using the symbol's
14243 address in the GOT as relocation value instead of the
14244 symbol's value itself. Also, create a GOT entry for the
14245 symbol and put the symbol value there. */
14246 case R_PPC64_GOT_TLSGD16:
14247 case R_PPC64_GOT_TLSGD16_LO:
14248 case R_PPC64_GOT_TLSGD16_HI:
14249 case R_PPC64_GOT_TLSGD16_HA:
14250 tls_type = TLS_TLS | TLS_GD;
14251 goto dogot;
14252
14253 case R_PPC64_GOT_TLSLD16:
14254 case R_PPC64_GOT_TLSLD16_LO:
14255 case R_PPC64_GOT_TLSLD16_HI:
14256 case R_PPC64_GOT_TLSLD16_HA:
14257 tls_type = TLS_TLS | TLS_LD;
14258 goto dogot;
14259
14260 case R_PPC64_GOT_TPREL16_DS:
14261 case R_PPC64_GOT_TPREL16_LO_DS:
14262 case R_PPC64_GOT_TPREL16_HI:
14263 case R_PPC64_GOT_TPREL16_HA:
14264 tls_type = TLS_TLS | TLS_TPREL;
14265 goto dogot;
14266
14267 case R_PPC64_GOT_DTPREL16_DS:
14268 case R_PPC64_GOT_DTPREL16_LO_DS:
14269 case R_PPC64_GOT_DTPREL16_HI:
14270 case R_PPC64_GOT_DTPREL16_HA:
14271 tls_type = TLS_TLS | TLS_DTPREL;
14272 goto dogot;
14273
14274 case R_PPC64_GOT16:
14275 case R_PPC64_GOT16_LO:
14276 case R_PPC64_GOT16_HI:
14277 case R_PPC64_GOT16_HA:
14278 case R_PPC64_GOT16_DS:
14279 case R_PPC64_GOT16_LO_DS:
14280 dogot:
14281 {
14282 /* Relocation is to the entry for this symbol in the global
14283 offset table. */
14284 asection *got;
14285 bfd_vma *offp;
14286 bfd_vma off;
14287 unsigned long indx = 0;
14288 struct got_entry *ent;
14289
14290 if (tls_type == (TLS_TLS | TLS_LD)
14291 && (h == NULL
14292 || !h->elf.def_dynamic))
14293 ent = ppc64_tlsld_got (input_bfd);
14294 else
14295 {
14296
14297 if (h != NULL)
14298 {
14299 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14300 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14301 &h->elf)
14302 || (bfd_link_pic (info)
14303 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14304 /* This is actually a static link, or it is a
14305 -Bsymbolic link and the symbol is defined
14306 locally, or the symbol was forced to be local
14307 because of a version file. */
14308 ;
14309 else
14310 {
14311 BFD_ASSERT (h->elf.dynindx != -1);
14312 indx = h->elf.dynindx;
14313 unresolved_reloc = FALSE;
14314 }
14315 ent = h->elf.got.glist;
14316 }
14317 else
14318 {
14319 if (local_got_ents == NULL)
14320 abort ();
14321 ent = local_got_ents[r_symndx];
14322 }
14323
14324 for (; ent != NULL; ent = ent->next)
14325 if (ent->addend == orig_rel.r_addend
14326 && ent->owner == input_bfd
14327 && ent->tls_type == tls_type)
14328 break;
14329 }
14330
14331 if (ent == NULL)
14332 abort ();
14333 if (ent->is_indirect)
14334 ent = ent->got.ent;
14335 offp = &ent->got.offset;
14336 got = ppc64_elf_tdata (ent->owner)->got;
14337 if (got == NULL)
14338 abort ();
14339
14340 /* The offset must always be a multiple of 8. We use the
14341 least significant bit to record whether we have already
14342 processed this entry. */
14343 off = *offp;
14344 if ((off & 1) != 0)
14345 off &= ~1;
14346 else
14347 {
14348 /* Generate relocs for the dynamic linker, except in
14349 the case of TLSLD where we'll use one entry per
14350 module. */
14351 asection *relgot;
14352 bfd_boolean ifunc;
14353
14354 *offp = off | 1;
14355 relgot = NULL;
14356 ifunc = (h != NULL
14357 ? h->elf.type == STT_GNU_IFUNC
14358 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14359 if (ifunc)
14360 relgot = htab->elf.irelplt;
14361 else if ((bfd_link_pic (info) || indx != 0)
14362 && (h == NULL
14363 || (tls_type == (TLS_TLS | TLS_LD)
14364 && !h->elf.def_dynamic)
14365 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14366 || h->elf.root.type != bfd_link_hash_undefweak))
14367 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14368 if (relgot != NULL)
14369 {
14370 outrel.r_offset = (got->output_section->vma
14371 + got->output_offset
14372 + off);
14373 outrel.r_addend = addend;
14374 if (tls_type & (TLS_LD | TLS_GD))
14375 {
14376 outrel.r_addend = 0;
14377 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14378 if (tls_type == (TLS_TLS | TLS_GD))
14379 {
14380 loc = relgot->contents;
14381 loc += (relgot->reloc_count++
14382 * sizeof (Elf64_External_Rela));
14383 bfd_elf64_swap_reloca_out (output_bfd,
14384 &outrel, loc);
14385 outrel.r_offset += 8;
14386 outrel.r_addend = addend;
14387 outrel.r_info
14388 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14389 }
14390 }
14391 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14392 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14393 else if (tls_type == (TLS_TLS | TLS_TPREL))
14394 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14395 else if (indx != 0)
14396 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14397 else
14398 {
14399 if (ifunc)
14400 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14401 else
14402 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14403
14404 /* Write the .got section contents for the sake
14405 of prelink. */
14406 loc = got->contents + off;
14407 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14408 loc);
14409 }
14410
14411 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14412 {
14413 outrel.r_addend += relocation;
14414 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14415 {
14416 if (htab->elf.tls_sec == NULL)
14417 outrel.r_addend = 0;
14418 else
14419 outrel.r_addend -= htab->elf.tls_sec->vma;
14420 }
14421 }
14422 loc = relgot->contents;
14423 loc += (relgot->reloc_count++
14424 * sizeof (Elf64_External_Rela));
14425 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14426 }
14427
14428 /* Init the .got section contents here if we're not
14429 emitting a reloc. */
14430 else
14431 {
14432 relocation += addend;
14433 if (tls_type == (TLS_TLS | TLS_LD))
14434 relocation = 1;
14435 else if (tls_type != 0)
14436 {
14437 if (htab->elf.tls_sec == NULL)
14438 relocation = 0;
14439 else
14440 {
14441 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14442 if (tls_type == (TLS_TLS | TLS_TPREL))
14443 relocation += DTP_OFFSET - TP_OFFSET;
14444 }
14445
14446 if (tls_type == (TLS_TLS | TLS_GD))
14447 {
14448 bfd_put_64 (output_bfd, relocation,
14449 got->contents + off + 8);
14450 relocation = 1;
14451 }
14452 }
14453
14454 bfd_put_64 (output_bfd, relocation,
14455 got->contents + off);
14456 }
14457 }
14458
14459 if (off >= (bfd_vma) -2)
14460 abort ();
14461
14462 relocation = got->output_section->vma + got->output_offset + off;
14463 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14464 }
14465 break;
14466
14467 case R_PPC64_PLT16_HA:
14468 case R_PPC64_PLT16_HI:
14469 case R_PPC64_PLT16_LO:
14470 case R_PPC64_PLT32:
14471 case R_PPC64_PLT64:
14472 /* Relocation is to the entry for this symbol in the
14473 procedure linkage table. */
14474 {
14475 struct plt_entry **plt_list = NULL;
14476 if (h != NULL)
14477 plt_list = &h->elf.plt.plist;
14478 else if (local_got_ents != NULL)
14479 {
14480 struct plt_entry **local_plt = (struct plt_entry **)
14481 (local_got_ents + symtab_hdr->sh_info);
14482 unsigned char *local_got_tls_masks = (unsigned char *)
14483 (local_plt + symtab_hdr->sh_info);
14484 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14485 plt_list = local_plt + r_symndx;
14486 }
14487 if (plt_list)
14488 {
14489 struct plt_entry *ent;
14490
14491 for (ent = *plt_list; ent != NULL; ent = ent->next)
14492 if (ent->plt.offset != (bfd_vma) -1
14493 && ent->addend == orig_rel.r_addend)
14494 {
14495 asection *plt;
14496
14497 plt = htab->elf.splt;
14498 if (!htab->elf.dynamic_sections_created
14499 || h == NULL
14500 || h->elf.dynindx == -1)
14501 plt = htab->elf.iplt;
14502 relocation = (plt->output_section->vma
14503 + plt->output_offset
14504 + ent->plt.offset);
14505 addend = 0;
14506 unresolved_reloc = FALSE;
14507 break;
14508 }
14509 }
14510 }
14511 break;
14512
14513 case R_PPC64_TOC:
14514 /* Relocation value is TOC base. */
14515 relocation = TOCstart;
14516 if (r_symndx == STN_UNDEF)
14517 relocation += htab->sec_info[input_section->id].toc_off;
14518 else if (unresolved_reloc)
14519 ;
14520 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14521 relocation += htab->sec_info[sec->id].toc_off;
14522 else
14523 unresolved_reloc = TRUE;
14524 goto dodyn;
14525
14526 /* TOC16 relocs. We want the offset relative to the TOC base,
14527 which is the address of the start of the TOC plus 0x8000.
14528 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14529 in this order. */
14530 case R_PPC64_TOC16:
14531 case R_PPC64_TOC16_LO:
14532 case R_PPC64_TOC16_HI:
14533 case R_PPC64_TOC16_DS:
14534 case R_PPC64_TOC16_LO_DS:
14535 case R_PPC64_TOC16_HA:
14536 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14537 break;
14538
14539 /* Relocate against the beginning of the section. */
14540 case R_PPC64_SECTOFF:
14541 case R_PPC64_SECTOFF_LO:
14542 case R_PPC64_SECTOFF_HI:
14543 case R_PPC64_SECTOFF_DS:
14544 case R_PPC64_SECTOFF_LO_DS:
14545 case R_PPC64_SECTOFF_HA:
14546 if (sec != NULL)
14547 addend -= sec->output_section->vma;
14548 break;
14549
14550 case R_PPC64_REL16:
14551 case R_PPC64_REL16_LO:
14552 case R_PPC64_REL16_HI:
14553 case R_PPC64_REL16_HA:
14554 case R_PPC64_REL16DX_HA:
14555 break;
14556
14557 case R_PPC64_REL14:
14558 case R_PPC64_REL14_BRNTAKEN:
14559 case R_PPC64_REL14_BRTAKEN:
14560 case R_PPC64_REL24:
14561 break;
14562
14563 case R_PPC64_TPREL16:
14564 case R_PPC64_TPREL16_LO:
14565 case R_PPC64_TPREL16_HI:
14566 case R_PPC64_TPREL16_HA:
14567 case R_PPC64_TPREL16_DS:
14568 case R_PPC64_TPREL16_LO_DS:
14569 case R_PPC64_TPREL16_HIGH:
14570 case R_PPC64_TPREL16_HIGHA:
14571 case R_PPC64_TPREL16_HIGHER:
14572 case R_PPC64_TPREL16_HIGHERA:
14573 case R_PPC64_TPREL16_HIGHEST:
14574 case R_PPC64_TPREL16_HIGHESTA:
14575 if (h != NULL
14576 && h->elf.root.type == bfd_link_hash_undefweak
14577 && h->elf.dynindx == -1)
14578 {
14579 /* Make this relocation against an undefined weak symbol
14580 resolve to zero. This is really just a tweak, since
14581 code using weak externs ought to check that they are
14582 defined before using them. */
14583 bfd_byte *p = contents + rel->r_offset - d_offset;
14584
14585 insn = bfd_get_32 (output_bfd, p);
14586 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14587 if (insn != 0)
14588 bfd_put_32 (output_bfd, insn, p);
14589 break;
14590 }
14591 if (htab->elf.tls_sec != NULL)
14592 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14593 if (bfd_link_pic (info))
14594 /* The TPREL16 relocs shouldn't really be used in shared
14595 libs as they will result in DT_TEXTREL being set, but
14596 support them anyway. */
14597 goto dodyn;
14598 break;
14599
14600 case R_PPC64_DTPREL16:
14601 case R_PPC64_DTPREL16_LO:
14602 case R_PPC64_DTPREL16_HI:
14603 case R_PPC64_DTPREL16_HA:
14604 case R_PPC64_DTPREL16_DS:
14605 case R_PPC64_DTPREL16_LO_DS:
14606 case R_PPC64_DTPREL16_HIGH:
14607 case R_PPC64_DTPREL16_HIGHA:
14608 case R_PPC64_DTPREL16_HIGHER:
14609 case R_PPC64_DTPREL16_HIGHERA:
14610 case R_PPC64_DTPREL16_HIGHEST:
14611 case R_PPC64_DTPREL16_HIGHESTA:
14612 if (htab->elf.tls_sec != NULL)
14613 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14614 break;
14615
14616 case R_PPC64_ADDR64_LOCAL:
14617 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14618 ? h->elf.other
14619 : sym->st_other);
14620 break;
14621
14622 case R_PPC64_DTPMOD64:
14623 relocation = 1;
14624 addend = 0;
14625 goto dodyn;
14626
14627 case R_PPC64_TPREL64:
14628 if (htab->elf.tls_sec != NULL)
14629 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14630 goto dodyn;
14631
14632 case R_PPC64_DTPREL64:
14633 if (htab->elf.tls_sec != NULL)
14634 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14635 /* Fall thru */
14636
14637 /* Relocations that may need to be propagated if this is a
14638 dynamic object. */
14639 case R_PPC64_REL30:
14640 case R_PPC64_REL32:
14641 case R_PPC64_REL64:
14642 case R_PPC64_ADDR14:
14643 case R_PPC64_ADDR14_BRNTAKEN:
14644 case R_PPC64_ADDR14_BRTAKEN:
14645 case R_PPC64_ADDR16:
14646 case R_PPC64_ADDR16_DS:
14647 case R_PPC64_ADDR16_HA:
14648 case R_PPC64_ADDR16_HI:
14649 case R_PPC64_ADDR16_HIGH:
14650 case R_PPC64_ADDR16_HIGHA:
14651 case R_PPC64_ADDR16_HIGHER:
14652 case R_PPC64_ADDR16_HIGHERA:
14653 case R_PPC64_ADDR16_HIGHEST:
14654 case R_PPC64_ADDR16_HIGHESTA:
14655 case R_PPC64_ADDR16_LO:
14656 case R_PPC64_ADDR16_LO_DS:
14657 case R_PPC64_ADDR24:
14658 case R_PPC64_ADDR32:
14659 case R_PPC64_ADDR64:
14660 case R_PPC64_UADDR16:
14661 case R_PPC64_UADDR32:
14662 case R_PPC64_UADDR64:
14663 dodyn:
14664 if ((input_section->flags & SEC_ALLOC) == 0)
14665 break;
14666
14667 if (NO_OPD_RELOCS && is_opd)
14668 break;
14669
14670 if ((bfd_link_pic (info)
14671 && (h == NULL
14672 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14673 || h->elf.root.type != bfd_link_hash_undefweak)
14674 && (must_be_dyn_reloc (info, r_type)
14675 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14676 || (ELIMINATE_COPY_RELOCS
14677 && !bfd_link_pic (info)
14678 && h != NULL
14679 && h->elf.dynindx != -1
14680 && !h->elf.non_got_ref
14681 && !h->elf.def_regular)
14682 || (!bfd_link_pic (info)
14683 && (h != NULL
14684 ? h->elf.type == STT_GNU_IFUNC
14685 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14686 {
14687 bfd_boolean skip, relocate;
14688 asection *sreloc;
14689 bfd_vma out_off;
14690
14691 /* When generating a dynamic object, these relocations
14692 are copied into the output file to be resolved at run
14693 time. */
14694
14695 skip = FALSE;
14696 relocate = FALSE;
14697
14698 out_off = _bfd_elf_section_offset (output_bfd, info,
14699 input_section, rel->r_offset);
14700 if (out_off == (bfd_vma) -1)
14701 skip = TRUE;
14702 else if (out_off == (bfd_vma) -2)
14703 skip = TRUE, relocate = TRUE;
14704 out_off += (input_section->output_section->vma
14705 + input_section->output_offset);
14706 outrel.r_offset = out_off;
14707 outrel.r_addend = rel->r_addend;
14708
14709 /* Optimize unaligned reloc use. */
14710 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14711 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14712 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14713 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14714 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14715 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14716 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14717 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14718 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14719
14720 if (skip)
14721 memset (&outrel, 0, sizeof outrel);
14722 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14723 && !is_opd
14724 && r_type != R_PPC64_TOC)
14725 {
14726 BFD_ASSERT (h->elf.dynindx != -1);
14727 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14728 }
14729 else
14730 {
14731 /* This symbol is local, or marked to become local,
14732 or this is an opd section reloc which must point
14733 at a local function. */
14734 outrel.r_addend += relocation;
14735 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14736 {
14737 if (is_opd && h != NULL)
14738 {
14739 /* Lie about opd entries. This case occurs
14740 when building shared libraries and we
14741 reference a function in another shared
14742 lib. The same thing happens for a weak
14743 definition in an application that's
14744 overridden by a strong definition in a
14745 shared lib. (I believe this is a generic
14746 bug in binutils handling of weak syms.)
14747 In these cases we won't use the opd
14748 entry in this lib. */
14749 unresolved_reloc = FALSE;
14750 }
14751 if (!is_opd
14752 && r_type == R_PPC64_ADDR64
14753 && (h != NULL
14754 ? h->elf.type == STT_GNU_IFUNC
14755 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14756 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14757 else
14758 {
14759 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14760
14761 /* We need to relocate .opd contents for ld.so.
14762 Prelink also wants simple and consistent rules
14763 for relocs. This make all RELATIVE relocs have
14764 *r_offset equal to r_addend. */
14765 relocate = TRUE;
14766 }
14767 }
14768 else
14769 {
14770 long indx = 0;
14771
14772 if (h != NULL
14773 ? h->elf.type == STT_GNU_IFUNC
14774 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14775 {
14776 info->callbacks->einfo
14777 (_("%P: %H: %s for indirect "
14778 "function `%T' unsupported\n"),
14779 input_bfd, input_section, rel->r_offset,
14780 ppc64_elf_howto_table[r_type]->name,
14781 sym_name);
14782 ret = FALSE;
14783 }
14784 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14785 ;
14786 else if (sec == NULL || sec->owner == NULL)
14787 {
14788 bfd_set_error (bfd_error_bad_value);
14789 return FALSE;
14790 }
14791 else
14792 {
14793 asection *osec;
14794
14795 osec = sec->output_section;
14796 indx = elf_section_data (osec)->dynindx;
14797
14798 if (indx == 0)
14799 {
14800 if ((osec->flags & SEC_READONLY) == 0
14801 && htab->elf.data_index_section != NULL)
14802 osec = htab->elf.data_index_section;
14803 else
14804 osec = htab->elf.text_index_section;
14805 indx = elf_section_data (osec)->dynindx;
14806 }
14807 BFD_ASSERT (indx != 0);
14808
14809 /* We are turning this relocation into one
14810 against a section symbol, so subtract out
14811 the output section's address but not the
14812 offset of the input section in the output
14813 section. */
14814 outrel.r_addend -= osec->vma;
14815 }
14816
14817 outrel.r_info = ELF64_R_INFO (indx, r_type);
14818 }
14819 }
14820
14821 sreloc = elf_section_data (input_section)->sreloc;
14822 if (h != NULL
14823 ? h->elf.type == STT_GNU_IFUNC
14824 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14825 sreloc = htab->elf.irelplt;
14826 if (sreloc == NULL)
14827 abort ();
14828
14829 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14830 >= sreloc->size)
14831 abort ();
14832 loc = sreloc->contents;
14833 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14834 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14835
14836 /* If this reloc is against an external symbol, it will
14837 be computed at runtime, so there's no need to do
14838 anything now. However, for the sake of prelink ensure
14839 that the section contents are a known value. */
14840 if (! relocate)
14841 {
14842 unresolved_reloc = FALSE;
14843 /* The value chosen here is quite arbitrary as ld.so
14844 ignores section contents except for the special
14845 case of .opd where the contents might be accessed
14846 before relocation. Choose zero, as that won't
14847 cause reloc overflow. */
14848 relocation = 0;
14849 addend = 0;
14850 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14851 to improve backward compatibility with older
14852 versions of ld. */
14853 if (r_type == R_PPC64_ADDR64)
14854 addend = outrel.r_addend;
14855 /* Adjust pc_relative relocs to have zero in *r_offset. */
14856 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14857 addend = (input_section->output_section->vma
14858 + input_section->output_offset
14859 + rel->r_offset);
14860 }
14861 }
14862 break;
14863
14864 case R_PPC64_COPY:
14865 case R_PPC64_GLOB_DAT:
14866 case R_PPC64_JMP_SLOT:
14867 case R_PPC64_JMP_IREL:
14868 case R_PPC64_RELATIVE:
14869 /* We shouldn't ever see these dynamic relocs in relocatable
14870 files. */
14871 /* Fall through. */
14872
14873 case R_PPC64_PLTGOT16:
14874 case R_PPC64_PLTGOT16_DS:
14875 case R_PPC64_PLTGOT16_HA:
14876 case R_PPC64_PLTGOT16_HI:
14877 case R_PPC64_PLTGOT16_LO:
14878 case R_PPC64_PLTGOT16_LO_DS:
14879 case R_PPC64_PLTREL32:
14880 case R_PPC64_PLTREL64:
14881 /* These ones haven't been implemented yet. */
14882
14883 info->callbacks->einfo
14884 (_("%P: %B: %s is not supported for `%T'\n"),
14885 input_bfd,
14886 ppc64_elf_howto_table[r_type]->name, sym_name);
14887
14888 bfd_set_error (bfd_error_invalid_operation);
14889 ret = FALSE;
14890 goto copy_reloc;
14891 }
14892
14893 /* Multi-instruction sequences that access the TOC can be
14894 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14895 to nop; addi rb,r2,x; */
14896 switch (r_type)
14897 {
14898 default:
14899 break;
14900
14901 case R_PPC64_GOT_TLSLD16_HI:
14902 case R_PPC64_GOT_TLSGD16_HI:
14903 case R_PPC64_GOT_TPREL16_HI:
14904 case R_PPC64_GOT_DTPREL16_HI:
14905 case R_PPC64_GOT16_HI:
14906 case R_PPC64_TOC16_HI:
14907 /* These relocs would only be useful if building up an
14908 offset to later add to r2, perhaps in an indexed
14909 addressing mode instruction. Don't try to optimize.
14910 Unfortunately, the possibility of someone building up an
14911 offset like this or even with the HA relocs, means that
14912 we need to check the high insn when optimizing the low
14913 insn. */
14914 break;
14915
14916 case R_PPC64_GOT_TLSLD16_HA:
14917 case R_PPC64_GOT_TLSGD16_HA:
14918 case R_PPC64_GOT_TPREL16_HA:
14919 case R_PPC64_GOT_DTPREL16_HA:
14920 case R_PPC64_GOT16_HA:
14921 case R_PPC64_TOC16_HA:
14922 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14923 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14924 {
14925 bfd_byte *p = contents + (rel->r_offset & ~3);
14926 bfd_put_32 (input_bfd, NOP, p);
14927 }
14928 break;
14929
14930 case R_PPC64_GOT_TLSLD16_LO:
14931 case R_PPC64_GOT_TLSGD16_LO:
14932 case R_PPC64_GOT_TPREL16_LO_DS:
14933 case R_PPC64_GOT_DTPREL16_LO_DS:
14934 case R_PPC64_GOT16_LO:
14935 case R_PPC64_GOT16_LO_DS:
14936 case R_PPC64_TOC16_LO:
14937 case R_PPC64_TOC16_LO_DS:
14938 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14939 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14940 {
14941 bfd_byte *p = contents + (rel->r_offset & ~3);
14942 insn = bfd_get_32 (input_bfd, p);
14943 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14944 {
14945 /* Transform addic to addi when we change reg. */
14946 insn &= ~((0x3f << 26) | (0x1f << 16));
14947 insn |= (14u << 26) | (2 << 16);
14948 }
14949 else
14950 {
14951 insn &= ~(0x1f << 16);
14952 insn |= 2 << 16;
14953 }
14954 bfd_put_32 (input_bfd, insn, p);
14955 }
14956 break;
14957 }
14958
14959 /* Do any further special processing. */
14960 howto = ppc64_elf_howto_table[(int) r_type];
14961 switch (r_type)
14962 {
14963 default:
14964 break;
14965
14966 case R_PPC64_REL16_HA:
14967 case R_PPC64_REL16DX_HA:
14968 case R_PPC64_ADDR16_HA:
14969 case R_PPC64_ADDR16_HIGHA:
14970 case R_PPC64_ADDR16_HIGHERA:
14971 case R_PPC64_ADDR16_HIGHESTA:
14972 case R_PPC64_TOC16_HA:
14973 case R_PPC64_SECTOFF_HA:
14974 case R_PPC64_TPREL16_HA:
14975 case R_PPC64_TPREL16_HIGHA:
14976 case R_PPC64_TPREL16_HIGHERA:
14977 case R_PPC64_TPREL16_HIGHESTA:
14978 case R_PPC64_DTPREL16_HA:
14979 case R_PPC64_DTPREL16_HIGHA:
14980 case R_PPC64_DTPREL16_HIGHERA:
14981 case R_PPC64_DTPREL16_HIGHESTA:
14982 /* It's just possible that this symbol is a weak symbol
14983 that's not actually defined anywhere. In that case,
14984 'sec' would be NULL, and we should leave the symbol
14985 alone (it will be set to zero elsewhere in the link). */
14986 if (sec == NULL)
14987 break;
14988 /* Fall thru */
14989
14990 case R_PPC64_GOT16_HA:
14991 case R_PPC64_PLTGOT16_HA:
14992 case R_PPC64_PLT16_HA:
14993 case R_PPC64_GOT_TLSGD16_HA:
14994 case R_PPC64_GOT_TLSLD16_HA:
14995 case R_PPC64_GOT_TPREL16_HA:
14996 case R_PPC64_GOT_DTPREL16_HA:
14997 /* Add 0x10000 if sign bit in 0:15 is set.
14998 Bits 0:15 are not used. */
14999 addend += 0x8000;
15000 break;
15001
15002 case R_PPC64_ADDR16_DS:
15003 case R_PPC64_ADDR16_LO_DS:
15004 case R_PPC64_GOT16_DS:
15005 case R_PPC64_GOT16_LO_DS:
15006 case R_PPC64_PLT16_LO_DS:
15007 case R_PPC64_SECTOFF_DS:
15008 case R_PPC64_SECTOFF_LO_DS:
15009 case R_PPC64_TOC16_DS:
15010 case R_PPC64_TOC16_LO_DS:
15011 case R_PPC64_PLTGOT16_DS:
15012 case R_PPC64_PLTGOT16_LO_DS:
15013 case R_PPC64_GOT_TPREL16_DS:
15014 case R_PPC64_GOT_TPREL16_LO_DS:
15015 case R_PPC64_GOT_DTPREL16_DS:
15016 case R_PPC64_GOT_DTPREL16_LO_DS:
15017 case R_PPC64_TPREL16_DS:
15018 case R_PPC64_TPREL16_LO_DS:
15019 case R_PPC64_DTPREL16_DS:
15020 case R_PPC64_DTPREL16_LO_DS:
15021 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15022 mask = 3;
15023 /* If this reloc is against an lq, lxv, or stxv insn, then
15024 the value must be a multiple of 16. This is somewhat of
15025 a hack, but the "correct" way to do this by defining _DQ
15026 forms of all the _DS relocs bloats all reloc switches in
15027 this file. It doesn't make much sense to use these
15028 relocs in data, so testing the insn should be safe. */
15029 if ((insn & (0x3f << 26)) == (56u << 26)
15030 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15031 mask = 15;
15032 relocation += addend;
15033 addend = insn & (mask ^ 3);
15034 if ((relocation & mask) != 0)
15035 {
15036 relocation ^= relocation & mask;
15037 info->callbacks->einfo
15038 (_("%P: %H: error: %s not a multiple of %u\n"),
15039 input_bfd, input_section, rel->r_offset,
15040 howto->name,
15041 mask + 1);
15042 bfd_set_error (bfd_error_bad_value);
15043 ret = FALSE;
15044 goto copy_reloc;
15045 }
15046 break;
15047 }
15048
15049 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15050 because such sections are not SEC_ALLOC and thus ld.so will
15051 not process them. */
15052 if (unresolved_reloc
15053 && !((input_section->flags & SEC_DEBUGGING) != 0
15054 && h->elf.def_dynamic)
15055 && _bfd_elf_section_offset (output_bfd, info, input_section,
15056 rel->r_offset) != (bfd_vma) -1)
15057 {
15058 info->callbacks->einfo
15059 (_("%P: %H: unresolvable %s against `%T'\n"),
15060 input_bfd, input_section, rel->r_offset,
15061 howto->name,
15062 h->elf.root.root.string);
15063 ret = FALSE;
15064 }
15065
15066 /* 16-bit fields in insns mostly have signed values, but a
15067 few insns have 16-bit unsigned values. Really, we should
15068 have different reloc types. */
15069 if (howto->complain_on_overflow != complain_overflow_dont
15070 && howto->dst_mask == 0xffff
15071 && (input_section->flags & SEC_CODE) != 0)
15072 {
15073 enum complain_overflow complain = complain_overflow_signed;
15074
15075 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15076 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15077 complain = complain_overflow_bitfield;
15078 else if (howto->rightshift == 0
15079 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15080 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15081 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15082 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15083 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15084 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15085 complain = complain_overflow_unsigned;
15086 if (howto->complain_on_overflow != complain)
15087 {
15088 alt_howto = *howto;
15089 alt_howto.complain_on_overflow = complain;
15090 howto = &alt_howto;
15091 }
15092 }
15093
15094 if (r_type == R_PPC64_REL16DX_HA)
15095 {
15096 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15097 if (rel->r_offset + 4 > input_section->size)
15098 r = bfd_reloc_outofrange;
15099 else
15100 {
15101 relocation += addend;
15102 relocation -= (rel->r_offset
15103 + input_section->output_offset
15104 + input_section->output_section->vma);
15105 relocation = (bfd_signed_vma) relocation >> 16;
15106 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15107 insn &= ~0x1fffc1;
15108 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15109 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15110 r = bfd_reloc_ok;
15111 if (relocation + 0x8000 > 0xffff)
15112 r = bfd_reloc_overflow;
15113 }
15114 }
15115 else
15116 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15117 rel->r_offset, relocation, addend);
15118
15119 if (r != bfd_reloc_ok)
15120 {
15121 char *more_info = NULL;
15122 const char *reloc_name = howto->name;
15123
15124 if (reloc_dest != DEST_NORMAL)
15125 {
15126 more_info = bfd_malloc (strlen (reloc_name) + 8);
15127 if (more_info != NULL)
15128 {
15129 strcpy (more_info, reloc_name);
15130 strcat (more_info, (reloc_dest == DEST_OPD
15131 ? " (OPD)" : " (stub)"));
15132 reloc_name = more_info;
15133 }
15134 }
15135
15136 if (r == bfd_reloc_overflow)
15137 {
15138 /* On code like "if (foo) foo();" don't report overflow
15139 on a branch to zero when foo is undefined. */
15140 if (!warned
15141 && (reloc_dest == DEST_STUB
15142 || !(h != NULL
15143 && (h->elf.root.type == bfd_link_hash_undefweak
15144 || h->elf.root.type == bfd_link_hash_undefined)
15145 && is_branch_reloc (r_type))))
15146 {
15147 if (!((*info->callbacks->reloc_overflow)
15148 (info, &h->elf.root, sym_name,
15149 reloc_name, orig_rel.r_addend,
15150 input_bfd, input_section, rel->r_offset)))
15151 return FALSE;
15152 }
15153 }
15154 else
15155 {
15156 info->callbacks->einfo
15157 (_("%P: %H: %s against `%T': error %d\n"),
15158 input_bfd, input_section, rel->r_offset,
15159 reloc_name, sym_name, (int) r);
15160 ret = FALSE;
15161 }
15162 if (more_info != NULL)
15163 free (more_info);
15164 }
15165 copy_reloc:
15166 if (wrel != rel)
15167 *wrel = *rel;
15168 }
15169
15170 if (wrel != rel)
15171 {
15172 Elf_Internal_Shdr *rel_hdr;
15173 size_t deleted = rel - wrel;
15174
15175 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15176 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15177 if (rel_hdr->sh_size == 0)
15178 {
15179 /* It is too late to remove an empty reloc section. Leave
15180 one NONE reloc.
15181 ??? What is wrong with an empty section??? */
15182 rel_hdr->sh_size = rel_hdr->sh_entsize;
15183 deleted -= 1;
15184 }
15185 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15186 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15187 input_section->reloc_count -= deleted;
15188 }
15189
15190 /* If we're emitting relocations, then shortly after this function
15191 returns, reloc offsets and addends for this section will be
15192 adjusted. Worse, reloc symbol indices will be for the output
15193 file rather than the input. Save a copy of the relocs for
15194 opd_entry_value. */
15195 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15196 {
15197 bfd_size_type amt;
15198 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15199 rel = bfd_alloc (input_bfd, amt);
15200 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15201 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15202 if (rel == NULL)
15203 return FALSE;
15204 memcpy (rel, relocs, amt);
15205 }
15206 return ret;
15207 }
15208
15209 /* Adjust the value of any local symbols in opd sections. */
15210
15211 static int
15212 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15213 const char *name ATTRIBUTE_UNUSED,
15214 Elf_Internal_Sym *elfsym,
15215 asection *input_sec,
15216 struct elf_link_hash_entry *h)
15217 {
15218 struct _opd_sec_data *opd;
15219 long adjust;
15220 bfd_vma value;
15221
15222 if (h != NULL)
15223 return 1;
15224
15225 opd = get_opd_info (input_sec);
15226 if (opd == NULL || opd->adjust == NULL)
15227 return 1;
15228
15229 value = elfsym->st_value - input_sec->output_offset;
15230 if (!bfd_link_relocatable (info))
15231 value -= input_sec->output_section->vma;
15232
15233 adjust = opd->adjust[OPD_NDX (value)];
15234 if (adjust == -1)
15235 return 2;
15236
15237 elfsym->st_value += adjust;
15238 return 1;
15239 }
15240
15241 /* Finish up dynamic symbol handling. We set the contents of various
15242 dynamic sections here. */
15243
15244 static bfd_boolean
15245 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15246 struct bfd_link_info *info,
15247 struct elf_link_hash_entry *h,
15248 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15249 {
15250 struct ppc_link_hash_table *htab;
15251 struct plt_entry *ent;
15252 Elf_Internal_Rela rela;
15253 bfd_byte *loc;
15254
15255 htab = ppc_hash_table (info);
15256 if (htab == NULL)
15257 return FALSE;
15258
15259 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15260 if (ent->plt.offset != (bfd_vma) -1)
15261 {
15262 /* This symbol has an entry in the procedure linkage
15263 table. Set it up. */
15264 if (!htab->elf.dynamic_sections_created
15265 || h->dynindx == -1)
15266 {
15267 BFD_ASSERT (h->type == STT_GNU_IFUNC
15268 && h->def_regular
15269 && (h->root.type == bfd_link_hash_defined
15270 || h->root.type == bfd_link_hash_defweak));
15271 rela.r_offset = (htab->elf.iplt->output_section->vma
15272 + htab->elf.iplt->output_offset
15273 + ent->plt.offset);
15274 if (htab->opd_abi)
15275 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15276 else
15277 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15278 rela.r_addend = (h->root.u.def.value
15279 + h->root.u.def.section->output_offset
15280 + h->root.u.def.section->output_section->vma
15281 + ent->addend);
15282 loc = (htab->elf.irelplt->contents
15283 + (htab->elf.irelplt->reloc_count++
15284 * sizeof (Elf64_External_Rela)));
15285 }
15286 else
15287 {
15288 rela.r_offset = (htab->elf.splt->output_section->vma
15289 + htab->elf.splt->output_offset
15290 + ent->plt.offset);
15291 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15292 rela.r_addend = ent->addend;
15293 loc = (htab->elf.srelplt->contents
15294 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15295 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15296 }
15297 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15298
15299 if (!htab->opd_abi)
15300 {
15301 if (!h->def_regular)
15302 {
15303 /* Mark the symbol as undefined, rather than as
15304 defined in glink. Leave the value if there were
15305 any relocations where pointer equality matters
15306 (this is a clue for the dynamic linker, to make
15307 function pointer comparisons work between an
15308 application and shared library), otherwise set it
15309 to zero. */
15310 sym->st_shndx = SHN_UNDEF;
15311 if (!h->pointer_equality_needed)
15312 sym->st_value = 0;
15313 else if (!h->ref_regular_nonweak)
15314 {
15315 /* This breaks function pointer comparisons, but
15316 that is better than breaking tests for a NULL
15317 function pointer. */
15318 sym->st_value = 0;
15319 }
15320 }
15321 }
15322 }
15323
15324 if (h->needs_copy)
15325 {
15326 /* This symbol needs a copy reloc. Set it up. */
15327
15328 if (h->dynindx == -1
15329 || (h->root.type != bfd_link_hash_defined
15330 && h->root.type != bfd_link_hash_defweak)
15331 || htab->relbss == NULL)
15332 abort ();
15333
15334 rela.r_offset = (h->root.u.def.value
15335 + h->root.u.def.section->output_section->vma
15336 + h->root.u.def.section->output_offset);
15337 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15338 rela.r_addend = 0;
15339 loc = htab->relbss->contents;
15340 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15341 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15342 }
15343
15344 return TRUE;
15345 }
15346
15347 /* Used to decide how to sort relocs in an optimal manner for the
15348 dynamic linker, before writing them out. */
15349
15350 static enum elf_reloc_type_class
15351 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15352 const asection *rel_sec,
15353 const Elf_Internal_Rela *rela)
15354 {
15355 enum elf_ppc64_reloc_type r_type;
15356 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15357
15358 if (rel_sec == htab->elf.irelplt)
15359 return reloc_class_ifunc;
15360
15361 r_type = ELF64_R_TYPE (rela->r_info);
15362 switch (r_type)
15363 {
15364 case R_PPC64_RELATIVE:
15365 return reloc_class_relative;
15366 case R_PPC64_JMP_SLOT:
15367 return reloc_class_plt;
15368 case R_PPC64_COPY:
15369 return reloc_class_copy;
15370 default:
15371 return reloc_class_normal;
15372 }
15373 }
15374
15375 /* Finish up the dynamic sections. */
15376
15377 static bfd_boolean
15378 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15379 struct bfd_link_info *info)
15380 {
15381 struct ppc_link_hash_table *htab;
15382 bfd *dynobj;
15383 asection *sdyn;
15384
15385 htab = ppc_hash_table (info);
15386 if (htab == NULL)
15387 return FALSE;
15388
15389 dynobj = htab->elf.dynobj;
15390 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15391
15392 if (htab->elf.dynamic_sections_created)
15393 {
15394 Elf64_External_Dyn *dyncon, *dynconend;
15395
15396 if (sdyn == NULL || htab->elf.sgot == NULL)
15397 abort ();
15398
15399 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15400 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15401 for (; dyncon < dynconend; dyncon++)
15402 {
15403 Elf_Internal_Dyn dyn;
15404 asection *s;
15405
15406 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15407
15408 switch (dyn.d_tag)
15409 {
15410 default:
15411 continue;
15412
15413 case DT_PPC64_GLINK:
15414 s = htab->glink;
15415 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15416 /* We stupidly defined DT_PPC64_GLINK to be the start
15417 of glink rather than the first entry point, which is
15418 what ld.so needs, and now have a bigger stub to
15419 support automatic multiple TOCs. */
15420 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15421 break;
15422
15423 case DT_PPC64_OPD:
15424 s = bfd_get_section_by_name (output_bfd, ".opd");
15425 if (s == NULL)
15426 continue;
15427 dyn.d_un.d_ptr = s->vma;
15428 break;
15429
15430 case DT_PPC64_OPT:
15431 if (htab->do_multi_toc && htab->multi_toc_needed)
15432 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15433 break;
15434
15435 case DT_PPC64_OPDSZ:
15436 s = bfd_get_section_by_name (output_bfd, ".opd");
15437 if (s == NULL)
15438 continue;
15439 dyn.d_un.d_val = s->size;
15440 break;
15441
15442 case DT_PLTGOT:
15443 s = htab->elf.splt;
15444 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15445 break;
15446
15447 case DT_JMPREL:
15448 s = htab->elf.srelplt;
15449 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15450 break;
15451
15452 case DT_PLTRELSZ:
15453 dyn.d_un.d_val = htab->elf.srelplt->size;
15454 break;
15455
15456 case DT_RELASZ:
15457 /* Don't count procedure linkage table relocs in the
15458 overall reloc count. */
15459 s = htab->elf.srelplt;
15460 if (s == NULL)
15461 continue;
15462 dyn.d_un.d_val -= s->size;
15463 break;
15464
15465 case DT_RELA:
15466 /* We may not be using the standard ELF linker script.
15467 If .rela.plt is the first .rela section, we adjust
15468 DT_RELA to not include it. */
15469 s = htab->elf.srelplt;
15470 if (s == NULL)
15471 continue;
15472 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15473 continue;
15474 dyn.d_un.d_ptr += s->size;
15475 break;
15476 }
15477
15478 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15479 }
15480 }
15481
15482 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15483 {
15484 /* Fill in the first entry in the global offset table.
15485 We use it to hold the link-time TOCbase. */
15486 bfd_put_64 (output_bfd,
15487 elf_gp (output_bfd) + TOC_BASE_OFF,
15488 htab->elf.sgot->contents);
15489
15490 /* Set .got entry size. */
15491 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15492 }
15493
15494 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15495 {
15496 /* Set .plt entry size. */
15497 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15498 = PLT_ENTRY_SIZE (htab);
15499 }
15500
15501 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15502 brlt ourselves if emitrelocations. */
15503 if (htab->brlt != NULL
15504 && htab->brlt->reloc_count != 0
15505 && !_bfd_elf_link_output_relocs (output_bfd,
15506 htab->brlt,
15507 elf_section_data (htab->brlt)->rela.hdr,
15508 elf_section_data (htab->brlt)->relocs,
15509 NULL))
15510 return FALSE;
15511
15512 if (htab->glink != NULL
15513 && htab->glink->reloc_count != 0
15514 && !_bfd_elf_link_output_relocs (output_bfd,
15515 htab->glink,
15516 elf_section_data (htab->glink)->rela.hdr,
15517 elf_section_data (htab->glink)->relocs,
15518 NULL))
15519 return FALSE;
15520
15521 if (htab->glink_eh_frame != NULL
15522 && htab->glink_eh_frame->size != 0)
15523 {
15524 bfd_vma val;
15525 bfd_byte *p;
15526 asection *stub_sec;
15527
15528 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15529 for (stub_sec = htab->params->stub_bfd->sections;
15530 stub_sec != NULL;
15531 stub_sec = stub_sec->next)
15532 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15533 {
15534 /* FDE length. */
15535 p += 4;
15536 /* CIE pointer. */
15537 p += 4;
15538 /* Offset to stub section. */
15539 val = (stub_sec->output_section->vma
15540 + stub_sec->output_offset);
15541 val -= (htab->glink_eh_frame->output_section->vma
15542 + htab->glink_eh_frame->output_offset
15543 + (p - htab->glink_eh_frame->contents));
15544 if (val + 0x80000000 > 0xffffffff)
15545 {
15546 info->callbacks->einfo
15547 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15548 stub_sec->name);
15549 return FALSE;
15550 }
15551 bfd_put_32 (dynobj, val, p);
15552 p += 4;
15553 /* stub section size. */
15554 p += 4;
15555 /* Augmentation. */
15556 p += 1;
15557 /* Pad. */
15558 p += 7;
15559 }
15560 if (htab->glink != NULL && htab->glink->size != 0)
15561 {
15562 /* FDE length. */
15563 p += 4;
15564 /* CIE pointer. */
15565 p += 4;
15566 /* Offset to .glink. */
15567 val = (htab->glink->output_section->vma
15568 + htab->glink->output_offset
15569 + 8);
15570 val -= (htab->glink_eh_frame->output_section->vma
15571 + htab->glink_eh_frame->output_offset
15572 + (p - htab->glink_eh_frame->contents));
15573 if (val + 0x80000000 > 0xffffffff)
15574 {
15575 info->callbacks->einfo
15576 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15577 htab->glink->name);
15578 return FALSE;
15579 }
15580 bfd_put_32 (dynobj, val, p);
15581 p += 4;
15582 /* .glink size. */
15583 p += 4;
15584 /* Augmentation. */
15585 p += 1;
15586 /* Ops. */
15587 p += 7;
15588 }
15589
15590 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15591 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15592 htab->glink_eh_frame,
15593 htab->glink_eh_frame->contents))
15594 return FALSE;
15595 }
15596
15597 /* We need to handle writing out multiple GOT sections ourselves,
15598 since we didn't add them to DYNOBJ. We know dynobj is the first
15599 bfd. */
15600 while ((dynobj = dynobj->link.next) != NULL)
15601 {
15602 asection *s;
15603
15604 if (!is_ppc64_elf (dynobj))
15605 continue;
15606
15607 s = ppc64_elf_tdata (dynobj)->got;
15608 if (s != NULL
15609 && s->size != 0
15610 && s->output_section != bfd_abs_section_ptr
15611 && !bfd_set_section_contents (output_bfd, s->output_section,
15612 s->contents, s->output_offset,
15613 s->size))
15614 return FALSE;
15615 s = ppc64_elf_tdata (dynobj)->relgot;
15616 if (s != NULL
15617 && s->size != 0
15618 && s->output_section != bfd_abs_section_ptr
15619 && !bfd_set_section_contents (output_bfd, s->output_section,
15620 s->contents, s->output_offset,
15621 s->size))
15622 return FALSE;
15623 }
15624
15625 return TRUE;
15626 }
15627
15628 #include "elf64-target.h"
15629
15630 /* FreeBSD support */
15631
15632 #undef TARGET_LITTLE_SYM
15633 #undef TARGET_LITTLE_NAME
15634
15635 #undef TARGET_BIG_SYM
15636 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15637 #undef TARGET_BIG_NAME
15638 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15639
15640 #undef ELF_OSABI
15641 #define ELF_OSABI ELFOSABI_FREEBSD
15642
15643 #undef elf64_bed
15644 #define elf64_bed elf64_powerpc_fbsd_bed
15645
15646 #include "elf64-target.h"
15647
A mirror of the official binutils-gdb repository