]> 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 powerpc64 -r --save-restore-funcs
[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 && abiversion (symbol->section->owner) >= 2)
2574 {
2575 unsigned int i;
2576
2577 for (i = 0; i < symbol->section->owner->symcount; ++i)
2578 {
2579 asymbol *symdef = symbol->section->owner->outsymbols[i];
2580
2581 if (strcmp (symdef->name, symbol->name) == 0)
2582 {
2583 elfsym = (elf_symbol_type *) symdef;
2584 break;
2585 }
2586 }
2587 }
2588 reloc_entry->addend
2589 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2590 }
2591 return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596 void *data, asection *input_section,
2597 bfd *output_bfd, char **error_message)
2598 {
2599 long insn;
2600 enum elf_ppc64_reloc_type r_type;
2601 bfd_size_type octets;
2602 /* Assume 'at' branch hints. */
2603 bfd_boolean is_isa_v2 = TRUE;
2604
2605 /* If this is a relocatable link (output_bfd test tells us), just
2606 call the generic function. Any adjustment will be done at final
2607 link time. */
2608 if (output_bfd != NULL)
2609 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2610 input_section, output_bfd, error_message);
2611
2612 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2613 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2614 insn &= ~(0x01 << 21);
2615 r_type = reloc_entry->howto->type;
2616 if (r_type == R_PPC64_ADDR14_BRTAKEN
2617 || r_type == R_PPC64_REL14_BRTAKEN)
2618 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2619
2620 if (is_isa_v2)
2621 {
2622 /* Set 'a' bit. This is 0b00010 in BO field for branch
2623 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2624 for branch on CTR insns (BO == 1a00t or 1a01t). */
2625 if ((insn & (0x14 << 21)) == (0x04 << 21))
2626 insn |= 0x02 << 21;
2627 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2628 insn |= 0x08 << 21;
2629 else
2630 goto out;
2631 }
2632 else
2633 {
2634 bfd_vma target = 0;
2635 bfd_vma from;
2636
2637 if (!bfd_is_com_section (symbol->section))
2638 target = symbol->value;
2639 target += symbol->section->output_section->vma;
2640 target += symbol->section->output_offset;
2641 target += reloc_entry->addend;
2642
2643 from = (reloc_entry->address
2644 + input_section->output_offset
2645 + input_section->output_section->vma);
2646
2647 /* Invert 'y' bit if not the default. */
2648 if ((bfd_signed_vma) (target - from) < 0)
2649 insn ^= 0x01 << 21;
2650 }
2651 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2652 out:
2653 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2654 input_section, output_bfd, error_message);
2655 }
2656
2657 static bfd_reloc_status_type
2658 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2659 void *data, asection *input_section,
2660 bfd *output_bfd, char **error_message)
2661 {
2662 /* If this is a relocatable link (output_bfd test tells us), just
2663 call the generic function. Any adjustment will be done at final
2664 link time. */
2665 if (output_bfd != NULL)
2666 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2667 input_section, output_bfd, error_message);
2668
2669 /* Subtract the symbol section base address. */
2670 reloc_entry->addend -= symbol->section->output_section->vma;
2671 return bfd_reloc_continue;
2672 }
2673
2674 static bfd_reloc_status_type
2675 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2676 void *data, asection *input_section,
2677 bfd *output_bfd, char **error_message)
2678 {
2679 /* If this is a relocatable link (output_bfd test tells us), just
2680 call the generic function. Any adjustment will be done at final
2681 link time. */
2682 if (output_bfd != NULL)
2683 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2684 input_section, output_bfd, error_message);
2685
2686 /* Subtract the symbol section base address. */
2687 reloc_entry->addend -= symbol->section->output_section->vma;
2688
2689 /* Adjust the addend for sign extension of the low 16 bits. */
2690 reloc_entry->addend += 0x8000;
2691 return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696 void *data, asection *input_section,
2697 bfd *output_bfd, char **error_message)
2698 {
2699 bfd_vma TOCstart;
2700
2701 /* If this is a relocatable link (output_bfd test tells us), just
2702 call the generic function. Any adjustment will be done at final
2703 link time. */
2704 if (output_bfd != NULL)
2705 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2706 input_section, output_bfd, error_message);
2707
2708 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2709 if (TOCstart == 0)
2710 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2711
2712 /* Subtract the TOC base address. */
2713 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2714 return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719 void *data, asection *input_section,
2720 bfd *output_bfd, char **error_message)
2721 {
2722 bfd_vma TOCstart;
2723
2724 /* If this is a relocatable link (output_bfd test tells us), just
2725 call the generic function. Any adjustment will be done at final
2726 link time. */
2727 if (output_bfd != NULL)
2728 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729 input_section, output_bfd, error_message);
2730
2731 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732 if (TOCstart == 0)
2733 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735 /* Subtract the TOC base address. */
2736 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737
2738 /* Adjust the addend for sign extension of the low 16 bits. */
2739 reloc_entry->addend += 0x8000;
2740 return bfd_reloc_continue;
2741 }
2742
2743 static bfd_reloc_status_type
2744 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2745 void *data, asection *input_section,
2746 bfd *output_bfd, char **error_message)
2747 {
2748 bfd_vma TOCstart;
2749 bfd_size_type octets;
2750
2751 /* If this is a relocatable link (output_bfd test tells us), just
2752 call the generic function. Any adjustment will be done at final
2753 link time. */
2754 if (output_bfd != NULL)
2755 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756 input_section, output_bfd, error_message);
2757
2758 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2759 if (TOCstart == 0)
2760 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2761
2762 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2763 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2764 return bfd_reloc_ok;
2765 }
2766
2767 static bfd_reloc_status_type
2768 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769 void *data, asection *input_section,
2770 bfd *output_bfd, char **error_message)
2771 {
2772 /* If this is a relocatable link (output_bfd test tells us), just
2773 call the generic function. Any adjustment will be done at final
2774 link time. */
2775 if (output_bfd != NULL)
2776 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2777 input_section, output_bfd, error_message);
2778
2779 if (error_message != NULL)
2780 {
2781 static char buf[60];
2782 sprintf (buf, "generic linker can't handle %s",
2783 reloc_entry->howto->name);
2784 *error_message = buf;
2785 }
2786 return bfd_reloc_dangerous;
2787 }
2788
2789 /* Track GOT entries needed for a given symbol. We might need more
2790 than one got entry per symbol. */
2791 struct got_entry
2792 {
2793 struct got_entry *next;
2794
2795 /* The symbol addend that we'll be placing in the GOT. */
2796 bfd_vma addend;
2797
2798 /* Unlike other ELF targets, we use separate GOT entries for the same
2799 symbol referenced from different input files. This is to support
2800 automatic multiple TOC/GOT sections, where the TOC base can vary
2801 from one input file to another. After partitioning into TOC groups
2802 we merge entries within the group.
2803
2804 Point to the BFD owning this GOT entry. */
2805 bfd *owner;
2806
2807 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2808 TLS_TPREL or TLS_DTPREL for tls entries. */
2809 unsigned char tls_type;
2810
2811 /* Non-zero if got.ent points to real entry. */
2812 unsigned char is_indirect;
2813
2814 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2815 union
2816 {
2817 bfd_signed_vma refcount;
2818 bfd_vma offset;
2819 struct got_entry *ent;
2820 } got;
2821 };
2822
2823 /* The same for PLT. */
2824 struct plt_entry
2825 {
2826 struct plt_entry *next;
2827
2828 bfd_vma addend;
2829
2830 union
2831 {
2832 bfd_signed_vma refcount;
2833 bfd_vma offset;
2834 } plt;
2835 };
2836
2837 struct ppc64_elf_obj_tdata
2838 {
2839 struct elf_obj_tdata elf;
2840
2841 /* Shortcuts to dynamic linker sections. */
2842 asection *got;
2843 asection *relgot;
2844
2845 /* Used during garbage collection. We attach global symbols defined
2846 on removed .opd entries to this section so that the sym is removed. */
2847 asection *deleted_section;
2848
2849 /* TLS local dynamic got entry handling. Support for multiple GOT
2850 sections means we potentially need one of these for each input bfd. */
2851 struct got_entry tlsld_got;
2852
2853 union {
2854 /* A copy of relocs before they are modified for --emit-relocs. */
2855 Elf_Internal_Rela *relocs;
2856
2857 /* Section contents. */
2858 bfd_byte *contents;
2859 } opd;
2860
2861 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2862 the reloc to be in the range -32768 to 32767. */
2863 unsigned int has_small_toc_reloc : 1;
2864
2865 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2866 instruction not one we handle. */
2867 unsigned int unexpected_toc_insn : 1;
2868 };
2869
2870 #define ppc64_elf_tdata(bfd) \
2871 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2872
2873 #define ppc64_tlsld_got(bfd) \
2874 (&ppc64_elf_tdata (bfd)->tlsld_got)
2875
2876 #define is_ppc64_elf(bfd) \
2877 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2878 && elf_object_id (bfd) == PPC64_ELF_DATA)
2879
2880 /* Override the generic function because we store some extras. */
2881
2882 static bfd_boolean
2883 ppc64_elf_mkobject (bfd *abfd)
2884 {
2885 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2886 PPC64_ELF_DATA);
2887 }
2888
2889 /* Fix bad default arch selected for a 64 bit input bfd when the
2890 default is 32 bit. */
2891
2892 static bfd_boolean
2893 ppc64_elf_object_p (bfd *abfd)
2894 {
2895 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2896 {
2897 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2898
2899 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2900 {
2901 /* Relies on arch after 32 bit default being 64 bit default. */
2902 abfd->arch_info = abfd->arch_info->next;
2903 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2904 }
2905 }
2906 return TRUE;
2907 }
2908
2909 /* Support for core dump NOTE sections. */
2910
2911 static bfd_boolean
2912 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2913 {
2914 size_t offset, size;
2915
2916 if (note->descsz != 504)
2917 return FALSE;
2918
2919 /* pr_cursig */
2920 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2921
2922 /* pr_pid */
2923 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2924
2925 /* pr_reg */
2926 offset = 112;
2927 size = 384;
2928
2929 /* Make a ".reg/999" section. */
2930 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2931 size, note->descpos + offset);
2932 }
2933
2934 static bfd_boolean
2935 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2936 {
2937 if (note->descsz != 136)
2938 return FALSE;
2939
2940 elf_tdata (abfd)->core->pid
2941 = bfd_get_32 (abfd, note->descdata + 24);
2942 elf_tdata (abfd)->core->program
2943 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2944 elf_tdata (abfd)->core->command
2945 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2946
2947 return TRUE;
2948 }
2949
2950 static char *
2951 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2952 ...)
2953 {
2954 switch (note_type)
2955 {
2956 default:
2957 return NULL;
2958
2959 case NT_PRPSINFO:
2960 {
2961 char data[136];
2962 va_list ap;
2963
2964 va_start (ap, note_type);
2965 memset (data, 0, sizeof (data));
2966 strncpy (data + 40, va_arg (ap, const char *), 16);
2967 strncpy (data + 56, va_arg (ap, const char *), 80);
2968 va_end (ap);
2969 return elfcore_write_note (abfd, buf, bufsiz,
2970 "CORE", note_type, data, sizeof (data));
2971 }
2972
2973 case NT_PRSTATUS:
2974 {
2975 char data[504];
2976 va_list ap;
2977 long pid;
2978 int cursig;
2979 const void *greg;
2980
2981 va_start (ap, note_type);
2982 memset (data, 0, 112);
2983 pid = va_arg (ap, long);
2984 bfd_put_32 (abfd, pid, data + 32);
2985 cursig = va_arg (ap, int);
2986 bfd_put_16 (abfd, cursig, data + 12);
2987 greg = va_arg (ap, const void *);
2988 memcpy (data + 112, greg, 384);
2989 memset (data + 496, 0, 8);
2990 va_end (ap);
2991 return elfcore_write_note (abfd, buf, bufsiz,
2992 "CORE", note_type, data, sizeof (data));
2993 }
2994 }
2995 }
2996
2997 /* Add extra PPC sections. */
2998
2999 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3000 {
3001 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3002 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3003 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3004 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3007 { NULL, 0, 0, 0, 0 }
3008 };
3009
3010 enum _ppc64_sec_type {
3011 sec_normal = 0,
3012 sec_opd = 1,
3013 sec_toc = 2
3014 };
3015
3016 struct _ppc64_elf_section_data
3017 {
3018 struct bfd_elf_section_data elf;
3019
3020 union
3021 {
3022 /* An array with one entry for each opd function descriptor,
3023 and some spares since opd entries may be either 16 or 24 bytes. */
3024 #define OPD_NDX(OFF) ((OFF) >> 4)
3025 struct _opd_sec_data
3026 {
3027 /* Points to the function code section for local opd entries. */
3028 asection **func_sec;
3029
3030 /* After editing .opd, adjust references to opd local syms. */
3031 long *adjust;
3032 } opd;
3033
3034 /* An array for toc sections, indexed by offset/8. */
3035 struct _toc_sec_data
3036 {
3037 /* Specifies the relocation symbol index used at a given toc offset. */
3038 unsigned *symndx;
3039
3040 /* And the relocation addend. */
3041 bfd_vma *add;
3042 } toc;
3043 } u;
3044
3045 enum _ppc64_sec_type sec_type:2;
3046
3047 /* Flag set when small branches are detected. Used to
3048 select suitable defaults for the stub group size. */
3049 unsigned int has_14bit_branch:1;
3050 };
3051
3052 #define ppc64_elf_section_data(sec) \
3053 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3054
3055 static bfd_boolean
3056 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3057 {
3058 if (!sec->used_by_bfd)
3059 {
3060 struct _ppc64_elf_section_data *sdata;
3061 bfd_size_type amt = sizeof (*sdata);
3062
3063 sdata = bfd_zalloc (abfd, amt);
3064 if (sdata == NULL)
3065 return FALSE;
3066 sec->used_by_bfd = sdata;
3067 }
3068
3069 return _bfd_elf_new_section_hook (abfd, sec);
3070 }
3071
3072 static struct _opd_sec_data *
3073 get_opd_info (asection * sec)
3074 {
3075 if (sec != NULL
3076 && ppc64_elf_section_data (sec) != NULL
3077 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3078 return &ppc64_elf_section_data (sec)->u.opd;
3079 return NULL;
3080 }
3081 \f
3082 /* Parameters for the qsort hook. */
3083 static bfd_boolean synthetic_relocatable;
3084
3085 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3086
3087 static int
3088 compare_symbols (const void *ap, const void *bp)
3089 {
3090 const asymbol *a = * (const asymbol **) ap;
3091 const asymbol *b = * (const asymbol **) bp;
3092
3093 /* Section symbols first. */
3094 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3095 return -1;
3096 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3097 return 1;
3098
3099 /* then .opd symbols. */
3100 if (strcmp (a->section->name, ".opd") == 0
3101 && strcmp (b->section->name, ".opd") != 0)
3102 return -1;
3103 if (strcmp (a->section->name, ".opd") != 0
3104 && strcmp (b->section->name, ".opd") == 0)
3105 return 1;
3106
3107 /* then other code symbols. */
3108 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3109 == (SEC_CODE | SEC_ALLOC)
3110 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3111 != (SEC_CODE | SEC_ALLOC))
3112 return -1;
3113
3114 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3115 != (SEC_CODE | SEC_ALLOC)
3116 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117 == (SEC_CODE | SEC_ALLOC))
3118 return 1;
3119
3120 if (synthetic_relocatable)
3121 {
3122 if (a->section->id < b->section->id)
3123 return -1;
3124
3125 if (a->section->id > b->section->id)
3126 return 1;
3127 }
3128
3129 if (a->value + a->section->vma < b->value + b->section->vma)
3130 return -1;
3131
3132 if (a->value + a->section->vma > b->value + b->section->vma)
3133 return 1;
3134
3135 /* For syms with the same value, prefer strong dynamic global function
3136 syms over other syms. */
3137 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3138 return -1;
3139
3140 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3141 return 1;
3142
3143 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3144 return -1;
3145
3146 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3147 return 1;
3148
3149 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3150 return -1;
3151
3152 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3153 return 1;
3154
3155 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3156 return -1;
3157
3158 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3159 return 1;
3160
3161 return 0;
3162 }
3163
3164 /* Search SYMS for a symbol of the given VALUE. */
3165
3166 static asymbol *
3167 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3168 {
3169 long mid;
3170
3171 if (id == (unsigned) -1)
3172 {
3173 while (lo < hi)
3174 {
3175 mid = (lo + hi) >> 1;
3176 if (syms[mid]->value + syms[mid]->section->vma < value)
3177 lo = mid + 1;
3178 else if (syms[mid]->value + syms[mid]->section->vma > value)
3179 hi = mid;
3180 else
3181 return syms[mid];
3182 }
3183 }
3184 else
3185 {
3186 while (lo < hi)
3187 {
3188 mid = (lo + hi) >> 1;
3189 if (syms[mid]->section->id < id)
3190 lo = mid + 1;
3191 else if (syms[mid]->section->id > id)
3192 hi = mid;
3193 else if (syms[mid]->value < value)
3194 lo = mid + 1;
3195 else if (syms[mid]->value > value)
3196 hi = mid;
3197 else
3198 return syms[mid];
3199 }
3200 }
3201 return NULL;
3202 }
3203
3204 static bfd_boolean
3205 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3206 {
3207 bfd_vma vma = *(bfd_vma *) ptr;
3208 return ((section->flags & SEC_ALLOC) != 0
3209 && section->vma <= vma
3210 && vma < section->vma + section->size);
3211 }
3212
3213 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3214 entry syms. Also generate @plt symbols for the glink branch table.
3215 Returns count of synthetic symbols in RET or -1 on error. */
3216
3217 static long
3218 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3219 long static_count, asymbol **static_syms,
3220 long dyn_count, asymbol **dyn_syms,
3221 asymbol **ret)
3222 {
3223 asymbol *s;
3224 long i;
3225 long count;
3226 char *names;
3227 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3228 asection *opd = NULL;
3229 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3230 asymbol **syms;
3231 int abi = abiversion (abfd);
3232
3233 *ret = NULL;
3234
3235 if (abi < 2)
3236 {
3237 opd = bfd_get_section_by_name (abfd, ".opd");
3238 if (opd == NULL && abi == 1)
3239 return 0;
3240 }
3241
3242 symcount = static_count;
3243 if (!relocatable)
3244 symcount += dyn_count;
3245 if (symcount == 0)
3246 return 0;
3247
3248 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3249 if (syms == NULL)
3250 return -1;
3251
3252 if (!relocatable && static_count != 0 && dyn_count != 0)
3253 {
3254 /* Use both symbol tables. */
3255 memcpy (syms, static_syms, static_count * sizeof (*syms));
3256 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3257 }
3258 else if (!relocatable && static_count == 0)
3259 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3260 else
3261 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3262
3263 synthetic_relocatable = relocatable;
3264 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3265
3266 if (!relocatable && symcount > 1)
3267 {
3268 long j;
3269 /* Trim duplicate syms, since we may have merged the normal and
3270 dynamic symbols. Actually, we only care about syms that have
3271 different values, so trim any with the same value. */
3272 for (i = 1, j = 1; i < symcount; ++i)
3273 if (syms[i - 1]->value + syms[i - 1]->section->vma
3274 != syms[i]->value + syms[i]->section->vma)
3275 syms[j++] = syms[i];
3276 symcount = j;
3277 }
3278
3279 i = 0;
3280 if (strcmp (syms[i]->section->name, ".opd") == 0)
3281 ++i;
3282 codesecsym = i;
3283
3284 for (; i < symcount; ++i)
3285 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3286 != (SEC_CODE | SEC_ALLOC))
3287 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3288 break;
3289 codesecsymend = i;
3290
3291 for (; i < symcount; ++i)
3292 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3293 break;
3294 secsymend = i;
3295
3296 for (; i < symcount; ++i)
3297 if (strcmp (syms[i]->section->name, ".opd") != 0)
3298 break;
3299 opdsymend = i;
3300
3301 for (; i < symcount; ++i)
3302 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303 != (SEC_CODE | SEC_ALLOC))
3304 break;
3305 symcount = i;
3306
3307 count = 0;
3308
3309 if (relocatable)
3310 {
3311 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3312 arelent *r;
3313 size_t size;
3314 long relcount;
3315
3316 if (opdsymend == secsymend)
3317 goto done;
3318
3319 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3320 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3321 if (relcount == 0)
3322 goto done;
3323
3324 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3325 {
3326 count = -1;
3327 goto done;
3328 }
3329
3330 size = 0;
3331 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3332 {
3333 asymbol *sym;
3334
3335 while (r < opd->relocation + relcount
3336 && r->address < syms[i]->value + opd->vma)
3337 ++r;
3338
3339 if (r == opd->relocation + relcount)
3340 break;
3341
3342 if (r->address != syms[i]->value + opd->vma)
3343 continue;
3344
3345 if (r->howto->type != R_PPC64_ADDR64)
3346 continue;
3347
3348 sym = *r->sym_ptr_ptr;
3349 if (!sym_exists_at (syms, opdsymend, symcount,
3350 sym->section->id, sym->value + r->addend))
3351 {
3352 ++count;
3353 size += sizeof (asymbol);
3354 size += strlen (syms[i]->name) + 2;
3355 }
3356 }
3357
3358 if (size == 0)
3359 goto done;
3360 s = *ret = bfd_malloc (size);
3361 if (s == NULL)
3362 {
3363 count = -1;
3364 goto done;
3365 }
3366
3367 names = (char *) (s + count);
3368
3369 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3370 {
3371 asymbol *sym;
3372
3373 while (r < opd->relocation + relcount
3374 && r->address < syms[i]->value + opd->vma)
3375 ++r;
3376
3377 if (r == opd->relocation + relcount)
3378 break;
3379
3380 if (r->address != syms[i]->value + opd->vma)
3381 continue;
3382
3383 if (r->howto->type != R_PPC64_ADDR64)
3384 continue;
3385
3386 sym = *r->sym_ptr_ptr;
3387 if (!sym_exists_at (syms, opdsymend, symcount,
3388 sym->section->id, sym->value + r->addend))
3389 {
3390 size_t len;
3391
3392 *s = *syms[i];
3393 s->flags |= BSF_SYNTHETIC;
3394 s->section = sym->section;
3395 s->value = sym->value + r->addend;
3396 s->name = names;
3397 *names++ = '.';
3398 len = strlen (syms[i]->name);
3399 memcpy (names, syms[i]->name, len + 1);
3400 names += len + 1;
3401 /* Have udata.p point back to the original symbol this
3402 synthetic symbol was derived from. */
3403 s->udata.p = syms[i];
3404 s++;
3405 }
3406 }
3407 }
3408 else
3409 {
3410 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3411 bfd_byte *contents = NULL;
3412 size_t size;
3413 long plt_count = 0;
3414 bfd_vma glink_vma = 0, resolv_vma = 0;
3415 asection *dynamic, *glink = NULL, *relplt = NULL;
3416 arelent *p;
3417
3418 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3419 {
3420 free_contents_and_exit_err:
3421 count = -1;
3422 free_contents_and_exit:
3423 if (contents)
3424 free (contents);
3425 goto done;
3426 }
3427
3428 size = 0;
3429 for (i = secsymend; i < opdsymend; ++i)
3430 {
3431 bfd_vma ent;
3432
3433 /* Ignore bogus symbols. */
3434 if (syms[i]->value > opd->size - 8)
3435 continue;
3436
3437 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3439 {
3440 ++count;
3441 size += sizeof (asymbol);
3442 size += strlen (syms[i]->name) + 2;
3443 }
3444 }
3445
3446 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3447 if (dyn_count != 0
3448 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3449 {
3450 bfd_byte *dynbuf, *extdyn, *extdynend;
3451 size_t extdynsize;
3452 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3453
3454 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3455 goto free_contents_and_exit_err;
3456
3457 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3458 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3459
3460 extdyn = dynbuf;
3461 extdynend = extdyn + dynamic->size;
3462 for (; extdyn < extdynend; extdyn += extdynsize)
3463 {
3464 Elf_Internal_Dyn dyn;
3465 (*swap_dyn_in) (abfd, extdyn, &dyn);
3466
3467 if (dyn.d_tag == DT_NULL)
3468 break;
3469
3470 if (dyn.d_tag == DT_PPC64_GLINK)
3471 {
3472 /* The first glink stub starts at offset 32; see
3473 comment in ppc64_elf_finish_dynamic_sections. */
3474 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3475 /* The .glink section usually does not survive the final
3476 link; search for the section (usually .text) where the
3477 glink stubs now reside. */
3478 glink = bfd_sections_find_if (abfd, section_covers_vma,
3479 &glink_vma);
3480 break;
3481 }
3482 }
3483
3484 free (dynbuf);
3485 }
3486
3487 if (glink != NULL)
3488 {
3489 /* Determine __glink trampoline by reading the relative branch
3490 from the first glink stub. */
3491 bfd_byte buf[4];
3492 unsigned int off = 0;
3493
3494 while (bfd_get_section_contents (abfd, glink, buf,
3495 glink_vma + off - glink->vma, 4))
3496 {
3497 unsigned int insn = bfd_get_32 (abfd, buf);
3498 insn ^= B_DOT;
3499 if ((insn & ~0x3fffffc) == 0)
3500 {
3501 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3502 break;
3503 }
3504 off += 4;
3505 if (off > 4)
3506 break;
3507 }
3508
3509 if (resolv_vma)
3510 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3511
3512 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3513 if (relplt != NULL)
3514 {
3515 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3516 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3517 goto free_contents_and_exit_err;
3518
3519 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3520 size += plt_count * sizeof (asymbol);
3521
3522 p = relplt->relocation;
3523 for (i = 0; i < plt_count; i++, p++)
3524 {
3525 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3526 if (p->addend != 0)
3527 size += sizeof ("+0x") - 1 + 16;
3528 }
3529 }
3530 }
3531
3532 if (size == 0)
3533 goto free_contents_and_exit;
3534 s = *ret = bfd_malloc (size);
3535 if (s == NULL)
3536 goto free_contents_and_exit_err;
3537
3538 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3539
3540 for (i = secsymend; i < opdsymend; ++i)
3541 {
3542 bfd_vma ent;
3543
3544 if (syms[i]->value > opd->size - 8)
3545 continue;
3546
3547 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3548 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3549 {
3550 long lo, hi;
3551 size_t len;
3552 asection *sec = abfd->sections;
3553
3554 *s = *syms[i];
3555 lo = codesecsym;
3556 hi = codesecsymend;
3557 while (lo < hi)
3558 {
3559 long mid = (lo + hi) >> 1;
3560 if (syms[mid]->section->vma < ent)
3561 lo = mid + 1;
3562 else if (syms[mid]->section->vma > ent)
3563 hi = mid;
3564 else
3565 {
3566 sec = syms[mid]->section;
3567 break;
3568 }
3569 }
3570
3571 if (lo >= hi && lo > codesecsym)
3572 sec = syms[lo - 1]->section;
3573
3574 for (; sec != NULL; sec = sec->next)
3575 {
3576 if (sec->vma > ent)
3577 break;
3578 /* SEC_LOAD may not be set if SEC is from a separate debug
3579 info file. */
3580 if ((sec->flags & SEC_ALLOC) == 0)
3581 break;
3582 if ((sec->flags & SEC_CODE) != 0)
3583 s->section = sec;
3584 }
3585 s->flags |= BSF_SYNTHETIC;
3586 s->value = ent - s->section->vma;
3587 s->name = names;
3588 *names++ = '.';
3589 len = strlen (syms[i]->name);
3590 memcpy (names, syms[i]->name, len + 1);
3591 names += len + 1;
3592 /* Have udata.p point back to the original symbol this
3593 synthetic symbol was derived from. */
3594 s->udata.p = syms[i];
3595 s++;
3596 }
3597 }
3598 free (contents);
3599
3600 if (glink != NULL && relplt != NULL)
3601 {
3602 if (resolv_vma)
3603 {
3604 /* Add a symbol for the main glink trampoline. */
3605 memset (s, 0, sizeof *s);
3606 s->the_bfd = abfd;
3607 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3608 s->section = glink;
3609 s->value = resolv_vma - glink->vma;
3610 s->name = names;
3611 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3612 names += sizeof ("__glink_PLTresolve");
3613 s++;
3614 count++;
3615 }
3616
3617 /* FIXME: It would be very much nicer to put sym@plt on the
3618 stub rather than on the glink branch table entry. The
3619 objdump disassembler would then use a sensible symbol
3620 name on plt calls. The difficulty in doing so is
3621 a) finding the stubs, and,
3622 b) matching stubs against plt entries, and,
3623 c) there can be multiple stubs for a given plt entry.
3624
3625 Solving (a) could be done by code scanning, but older
3626 ppc64 binaries used different stubs to current code.
3627 (b) is the tricky one since you need to known the toc
3628 pointer for at least one function that uses a pic stub to
3629 be able to calculate the plt address referenced.
3630 (c) means gdb would need to set multiple breakpoints (or
3631 find the glink branch itself) when setting breakpoints
3632 for pending shared library loads. */
3633 p = relplt->relocation;
3634 for (i = 0; i < plt_count; i++, p++)
3635 {
3636 size_t len;
3637
3638 *s = **p->sym_ptr_ptr;
3639 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3640 we are defining a symbol, ensure one of them is set. */
3641 if ((s->flags & BSF_LOCAL) == 0)
3642 s->flags |= BSF_GLOBAL;
3643 s->flags |= BSF_SYNTHETIC;
3644 s->section = glink;
3645 s->value = glink_vma - glink->vma;
3646 s->name = names;
3647 s->udata.p = NULL;
3648 len = strlen ((*p->sym_ptr_ptr)->name);
3649 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3650 names += len;
3651 if (p->addend != 0)
3652 {
3653 memcpy (names, "+0x", sizeof ("+0x") - 1);
3654 names += sizeof ("+0x") - 1;
3655 bfd_sprintf_vma (abfd, names, p->addend);
3656 names += strlen (names);
3657 }
3658 memcpy (names, "@plt", sizeof ("@plt"));
3659 names += sizeof ("@plt");
3660 s++;
3661 if (abi < 2)
3662 {
3663 glink_vma += 8;
3664 if (i >= 0x8000)
3665 glink_vma += 4;
3666 }
3667 else
3668 glink_vma += 4;
3669 }
3670 count += plt_count;
3671 }
3672 }
3673
3674 done:
3675 free (syms);
3676 return count;
3677 }
3678 \f
3679 /* The following functions are specific to the ELF linker, while
3680 functions above are used generally. Those named ppc64_elf_* are
3681 called by the main ELF linker code. They appear in this file more
3682 or less in the order in which they are called. eg.
3683 ppc64_elf_check_relocs is called early in the link process,
3684 ppc64_elf_finish_dynamic_sections is one of the last functions
3685 called.
3686
3687 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3688 functions have both a function code symbol and a function descriptor
3689 symbol. A call to foo in a relocatable object file looks like:
3690
3691 . .text
3692 . x:
3693 . bl .foo
3694 . nop
3695
3696 The function definition in another object file might be:
3697
3698 . .section .opd
3699 . foo: .quad .foo
3700 . .quad .TOC.@tocbase
3701 . .quad 0
3702 .
3703 . .text
3704 . .foo: blr
3705
3706 When the linker resolves the call during a static link, the branch
3707 unsurprisingly just goes to .foo and the .opd information is unused.
3708 If the function definition is in a shared library, things are a little
3709 different: The call goes via a plt call stub, the opd information gets
3710 copied to the plt, and the linker patches the nop.
3711
3712 . x:
3713 . bl .foo_stub
3714 . ld 2,40(1)
3715 .
3716 .
3717 . .foo_stub:
3718 . std 2,40(1) # in practice, the call stub
3719 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3720 . addi 11,11,Lfoo@toc@l # this is the general idea
3721 . ld 12,0(11)
3722 . ld 2,8(11)
3723 . mtctr 12
3724 . ld 11,16(11)
3725 . bctr
3726 .
3727 . .section .plt
3728 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3729
3730 The "reloc ()" notation is supposed to indicate that the linker emits
3731 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3732 copying.
3733
3734 What are the difficulties here? Well, firstly, the relocations
3735 examined by the linker in check_relocs are against the function code
3736 sym .foo, while the dynamic relocation in the plt is emitted against
3737 the function descriptor symbol, foo. Somewhere along the line, we need
3738 to carefully copy dynamic link information from one symbol to the other.
3739 Secondly, the generic part of the elf linker will make .foo a dynamic
3740 symbol as is normal for most other backends. We need foo dynamic
3741 instead, at least for an application final link. However, when
3742 creating a shared library containing foo, we need to have both symbols
3743 dynamic so that references to .foo are satisfied during the early
3744 stages of linking. Otherwise the linker might decide to pull in a
3745 definition from some other object, eg. a static library.
3746
3747 Update: As of August 2004, we support a new convention. Function
3748 calls may use the function descriptor symbol, ie. "bl foo". This
3749 behaves exactly as "bl .foo". */
3750
3751 /* Of those relocs that might be copied as dynamic relocs, this function
3752 selects those that must be copied when linking a shared library,
3753 even when the symbol is local. */
3754
3755 static int
3756 must_be_dyn_reloc (struct bfd_link_info *info,
3757 enum elf_ppc64_reloc_type r_type)
3758 {
3759 switch (r_type)
3760 {
3761 default:
3762 return 1;
3763
3764 case R_PPC64_REL32:
3765 case R_PPC64_REL64:
3766 case R_PPC64_REL30:
3767 return 0;
3768
3769 case R_PPC64_TPREL16:
3770 case R_PPC64_TPREL16_LO:
3771 case R_PPC64_TPREL16_HI:
3772 case R_PPC64_TPREL16_HA:
3773 case R_PPC64_TPREL16_DS:
3774 case R_PPC64_TPREL16_LO_DS:
3775 case R_PPC64_TPREL16_HIGH:
3776 case R_PPC64_TPREL16_HIGHA:
3777 case R_PPC64_TPREL16_HIGHER:
3778 case R_PPC64_TPREL16_HIGHERA:
3779 case R_PPC64_TPREL16_HIGHEST:
3780 case R_PPC64_TPREL16_HIGHESTA:
3781 case R_PPC64_TPREL64:
3782 return !bfd_link_executable (info);
3783 }
3784 }
3785
3786 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3787 copying dynamic variables from a shared lib into an app's dynbss
3788 section, and instead use a dynamic relocation to point into the
3789 shared lib. With code that gcc generates, it's vital that this be
3790 enabled; In the PowerPC64 ABI, the address of a function is actually
3791 the address of a function descriptor, which resides in the .opd
3792 section. gcc uses the descriptor directly rather than going via the
3793 GOT as some other ABI's do, which means that initialized function
3794 pointers must reference the descriptor. Thus, a function pointer
3795 initialized to the address of a function in a shared library will
3796 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3797 redefines the function descriptor symbol to point to the copy. This
3798 presents a problem as a plt entry for that function is also
3799 initialized from the function descriptor symbol and the copy reloc
3800 may not be initialized first. */
3801 #define ELIMINATE_COPY_RELOCS 1
3802
3803 /* Section name for stubs is the associated section name plus this
3804 string. */
3805 #define STUB_SUFFIX ".stub"
3806
3807 /* Linker stubs.
3808 ppc_stub_long_branch:
3809 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3810 destination, but a 24 bit branch in a stub section will reach.
3811 . b dest
3812
3813 ppc_stub_plt_branch:
3814 Similar to the above, but a 24 bit branch in the stub section won't
3815 reach its destination.
3816 . addis %r11,%r2,xxx@toc@ha
3817 . ld %r12,xxx@toc@l(%r11)
3818 . mtctr %r12
3819 . bctr
3820
3821 ppc_stub_plt_call:
3822 Used to call a function in a shared library. If it so happens that
3823 the plt entry referenced crosses a 64k boundary, then an extra
3824 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3825 . std %r2,40(%r1)
3826 . addis %r11,%r2,xxx@toc@ha
3827 . ld %r12,xxx+0@toc@l(%r11)
3828 . mtctr %r12
3829 . ld %r2,xxx+8@toc@l(%r11)
3830 . ld %r11,xxx+16@toc@l(%r11)
3831 . bctr
3832
3833 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3834 code to adjust the value and save r2 to support multiple toc sections.
3835 A ppc_stub_long_branch with an r2 offset looks like:
3836 . std %r2,40(%r1)
3837 . addis %r2,%r2,off@ha
3838 . addi %r2,%r2,off@l
3839 . b dest
3840
3841 A ppc_stub_plt_branch with an r2 offset looks like:
3842 . std %r2,40(%r1)
3843 . addis %r11,%r2,xxx@toc@ha
3844 . ld %r12,xxx@toc@l(%r11)
3845 . addis %r2,%r2,off@ha
3846 . addi %r2,%r2,off@l
3847 . mtctr %r12
3848 . bctr
3849
3850 In cases where the "addis" instruction would add zero, the "addis" is
3851 omitted and following instructions modified slightly in some cases.
3852 */
3853
3854 enum ppc_stub_type {
3855 ppc_stub_none,
3856 ppc_stub_long_branch,
3857 ppc_stub_long_branch_r2off,
3858 ppc_stub_plt_branch,
3859 ppc_stub_plt_branch_r2off,
3860 ppc_stub_plt_call,
3861 ppc_stub_plt_call_r2save,
3862 ppc_stub_global_entry,
3863 ppc_stub_save_res
3864 };
3865
3866 /* Information on stub grouping. */
3867 struct map_stub
3868 {
3869 /* The stub section. */
3870 asection *stub_sec;
3871 /* This is the section to which stubs in the group will be attached. */
3872 asection *link_sec;
3873 /* Next group. */
3874 struct map_stub *next;
3875 /* Whether to emit a copy of register save/restore functions in this
3876 group. */
3877 int needs_save_res;
3878 };
3879
3880 struct ppc_stub_hash_entry {
3881
3882 /* Base hash table entry structure. */
3883 struct bfd_hash_entry root;
3884
3885 enum ppc_stub_type stub_type;
3886
3887 /* Group information. */
3888 struct map_stub *group;
3889
3890 /* Offset within stub_sec of the beginning of this stub. */
3891 bfd_vma stub_offset;
3892
3893 /* Given the symbol's value and its section we can determine its final
3894 value when building the stubs (so the stub knows where to jump. */
3895 bfd_vma target_value;
3896 asection *target_section;
3897
3898 /* The symbol table entry, if any, that this was derived from. */
3899 struct ppc_link_hash_entry *h;
3900 struct plt_entry *plt_ent;
3901
3902 /* Symbol st_other. */
3903 unsigned char other;
3904 };
3905
3906 struct ppc_branch_hash_entry {
3907
3908 /* Base hash table entry structure. */
3909 struct bfd_hash_entry root;
3910
3911 /* Offset within branch lookup table. */
3912 unsigned int offset;
3913
3914 /* Generation marker. */
3915 unsigned int iter;
3916 };
3917
3918 /* Used to track dynamic relocations for local symbols. */
3919 struct ppc_dyn_relocs
3920 {
3921 struct ppc_dyn_relocs *next;
3922
3923 /* The input section of the reloc. */
3924 asection *sec;
3925
3926 /* Total number of relocs copied for the input section. */
3927 unsigned int count : 31;
3928
3929 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3930 unsigned int ifunc : 1;
3931 };
3932
3933 struct ppc_link_hash_entry
3934 {
3935 struct elf_link_hash_entry elf;
3936
3937 union {
3938 /* A pointer to the most recently used stub hash entry against this
3939 symbol. */
3940 struct ppc_stub_hash_entry *stub_cache;
3941
3942 /* A pointer to the next symbol starting with a '.' */
3943 struct ppc_link_hash_entry *next_dot_sym;
3944 } u;
3945
3946 /* Track dynamic relocs copied for this symbol. */
3947 struct elf_dyn_relocs *dyn_relocs;
3948
3949 /* Link between function code and descriptor symbols. */
3950 struct ppc_link_hash_entry *oh;
3951
3952 /* Flag function code and descriptor symbols. */
3953 unsigned int is_func:1;
3954 unsigned int is_func_descriptor:1;
3955 unsigned int fake:1;
3956
3957 /* Whether global opd/toc sym has been adjusted or not.
3958 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3959 should be set for all globals defined in any opd/toc section. */
3960 unsigned int adjust_done:1;
3961
3962 /* Set if we twiddled this symbol to weak at some stage. */
3963 unsigned int was_undefined:1;
3964
3965 /* Set if this is an out-of-line register save/restore function,
3966 with non-standard calling convention. */
3967 unsigned int save_res:1;
3968
3969 /* Contexts in which symbol is used in the GOT (or TOC).
3970 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3971 corresponding relocs are encountered during check_relocs.
3972 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3973 indicate the corresponding GOT entry type is not needed.
3974 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3975 a TPREL one. We use a separate flag rather than setting TPREL
3976 just for convenience in distinguishing the two cases. */
3977 #define TLS_GD 1 /* GD reloc. */
3978 #define TLS_LD 2 /* LD reloc. */
3979 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3980 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3981 #define TLS_TLS 16 /* Any TLS reloc. */
3982 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3983 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3984 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3985 unsigned char tls_mask;
3986 };
3987
3988 /* ppc64 ELF linker hash table. */
3989
3990 struct ppc_link_hash_table
3991 {
3992 struct elf_link_hash_table elf;
3993
3994 /* The stub hash table. */
3995 struct bfd_hash_table stub_hash_table;
3996
3997 /* Another hash table for plt_branch stubs. */
3998 struct bfd_hash_table branch_hash_table;
3999
4000 /* Hash table for function prologue tocsave. */
4001 htab_t tocsave_htab;
4002
4003 /* Various options and other info passed from the linker. */
4004 struct ppc64_elf_params *params;
4005
4006 /* The size of sec_info below. */
4007 unsigned int sec_info_arr_size;
4008
4009 /* Per-section array of extra section info. Done this way rather
4010 than as part of ppc64_elf_section_data so we have the info for
4011 non-ppc64 sections. */
4012 struct
4013 {
4014 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4015 bfd_vma toc_off;
4016
4017 union
4018 {
4019 /* The section group that this section belongs to. */
4020 struct map_stub *group;
4021 /* A temp section list pointer. */
4022 asection *list;
4023 } u;
4024 } *sec_info;
4025
4026 /* Linked list of groups. */
4027 struct map_stub *group;
4028
4029 /* Temp used when calculating TOC pointers. */
4030 bfd_vma toc_curr;
4031 bfd *toc_bfd;
4032 asection *toc_first_sec;
4033
4034 /* Used when adding symbols. */
4035 struct ppc_link_hash_entry *dot_syms;
4036
4037 /* Shortcuts to get to dynamic linker sections. */
4038 asection *dynbss;
4039 asection *relbss;
4040 asection *glink;
4041 asection *sfpr;
4042 asection *brlt;
4043 asection *relbrlt;
4044 asection *glink_eh_frame;
4045
4046 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4047 struct ppc_link_hash_entry *tls_get_addr;
4048 struct ppc_link_hash_entry *tls_get_addr_fd;
4049
4050 /* The size of reliplt used by got entry relocs. */
4051 bfd_size_type got_reli_size;
4052
4053 /* Statistics. */
4054 unsigned long stub_count[ppc_stub_global_entry];
4055
4056 /* Number of stubs against global syms. */
4057 unsigned long stub_globals;
4058
4059 /* Set if we're linking code with function descriptors. */
4060 unsigned int opd_abi:1;
4061
4062 /* Support for multiple toc sections. */
4063 unsigned int do_multi_toc:1;
4064 unsigned int multi_toc_needed:1;
4065 unsigned int second_toc_pass:1;
4066 unsigned int do_toc_opt:1;
4067
4068 /* Set on error. */
4069 unsigned int stub_error:1;
4070
4071 /* Temp used by ppc64_elf_before_check_relocs. */
4072 unsigned int twiddled_syms:1;
4073
4074 /* Incremented every time we size stubs. */
4075 unsigned int stub_iteration;
4076
4077 /* Small local sym cache. */
4078 struct sym_cache sym_cache;
4079 };
4080
4081 /* Rename some of the generic section flags to better document how they
4082 are used here. */
4083
4084 /* Nonzero if this section has TLS related relocations. */
4085 #define has_tls_reloc sec_flg0
4086
4087 /* Nonzero if this section has a call to __tls_get_addr. */
4088 #define has_tls_get_addr_call sec_flg1
4089
4090 /* Nonzero if this section has any toc or got relocs. */
4091 #define has_toc_reloc sec_flg2
4092
4093 /* Nonzero if this section has a call to another section that uses
4094 the toc or got. */
4095 #define makes_toc_func_call sec_flg3
4096
4097 /* Recursion protection when determining above flag. */
4098 #define call_check_in_progress sec_flg4
4099 #define call_check_done sec_flg5
4100
4101 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4102
4103 #define ppc_hash_table(p) \
4104 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4105 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4106
4107 #define ppc_stub_hash_lookup(table, string, create, copy) \
4108 ((struct ppc_stub_hash_entry *) \
4109 bfd_hash_lookup ((table), (string), (create), (copy)))
4110
4111 #define ppc_branch_hash_lookup(table, string, create, copy) \
4112 ((struct ppc_branch_hash_entry *) \
4113 bfd_hash_lookup ((table), (string), (create), (copy)))
4114
4115 /* Create an entry in the stub hash table. */
4116
4117 static struct bfd_hash_entry *
4118 stub_hash_newfunc (struct bfd_hash_entry *entry,
4119 struct bfd_hash_table *table,
4120 const char *string)
4121 {
4122 /* Allocate the structure if it has not already been allocated by a
4123 subclass. */
4124 if (entry == NULL)
4125 {
4126 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4127 if (entry == NULL)
4128 return entry;
4129 }
4130
4131 /* Call the allocation method of the superclass. */
4132 entry = bfd_hash_newfunc (entry, table, string);
4133 if (entry != NULL)
4134 {
4135 struct ppc_stub_hash_entry *eh;
4136
4137 /* Initialize the local fields. */
4138 eh = (struct ppc_stub_hash_entry *) entry;
4139 eh->stub_type = ppc_stub_none;
4140 eh->group = NULL;
4141 eh->stub_offset = 0;
4142 eh->target_value = 0;
4143 eh->target_section = NULL;
4144 eh->h = NULL;
4145 eh->plt_ent = NULL;
4146 eh->other = 0;
4147 }
4148
4149 return entry;
4150 }
4151
4152 /* Create an entry in the branch hash table. */
4153
4154 static struct bfd_hash_entry *
4155 branch_hash_newfunc (struct bfd_hash_entry *entry,
4156 struct bfd_hash_table *table,
4157 const char *string)
4158 {
4159 /* Allocate the structure if it has not already been allocated by a
4160 subclass. */
4161 if (entry == NULL)
4162 {
4163 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4164 if (entry == NULL)
4165 return entry;
4166 }
4167
4168 /* Call the allocation method of the superclass. */
4169 entry = bfd_hash_newfunc (entry, table, string);
4170 if (entry != NULL)
4171 {
4172 struct ppc_branch_hash_entry *eh;
4173
4174 /* Initialize the local fields. */
4175 eh = (struct ppc_branch_hash_entry *) entry;
4176 eh->offset = 0;
4177 eh->iter = 0;
4178 }
4179
4180 return entry;
4181 }
4182
4183 /* Create an entry in a ppc64 ELF linker hash table. */
4184
4185 static struct bfd_hash_entry *
4186 link_hash_newfunc (struct bfd_hash_entry *entry,
4187 struct bfd_hash_table *table,
4188 const char *string)
4189 {
4190 /* Allocate the structure if it has not already been allocated by a
4191 subclass. */
4192 if (entry == NULL)
4193 {
4194 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4195 if (entry == NULL)
4196 return entry;
4197 }
4198
4199 /* Call the allocation method of the superclass. */
4200 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4201 if (entry != NULL)
4202 {
4203 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4204
4205 memset (&eh->u.stub_cache, 0,
4206 (sizeof (struct ppc_link_hash_entry)
4207 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4208
4209 /* When making function calls, old ABI code references function entry
4210 points (dot symbols), while new ABI code references the function
4211 descriptor symbol. We need to make any combination of reference and
4212 definition work together, without breaking archive linking.
4213
4214 For a defined function "foo" and an undefined call to "bar":
4215 An old object defines "foo" and ".foo", references ".bar" (possibly
4216 "bar" too).
4217 A new object defines "foo" and references "bar".
4218
4219 A new object thus has no problem with its undefined symbols being
4220 satisfied by definitions in an old object. On the other hand, the
4221 old object won't have ".bar" satisfied by a new object.
4222
4223 Keep a list of newly added dot-symbols. */
4224
4225 if (string[0] == '.')
4226 {
4227 struct ppc_link_hash_table *htab;
4228
4229 htab = (struct ppc_link_hash_table *) table;
4230 eh->u.next_dot_sym = htab->dot_syms;
4231 htab->dot_syms = eh;
4232 }
4233 }
4234
4235 return entry;
4236 }
4237
4238 struct tocsave_entry {
4239 asection *sec;
4240 bfd_vma offset;
4241 };
4242
4243 static hashval_t
4244 tocsave_htab_hash (const void *p)
4245 {
4246 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4247 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4248 }
4249
4250 static int
4251 tocsave_htab_eq (const void *p1, const void *p2)
4252 {
4253 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4254 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4255 return e1->sec == e2->sec && e1->offset == e2->offset;
4256 }
4257
4258 /* Destroy a ppc64 ELF linker hash table. */
4259
4260 static void
4261 ppc64_elf_link_hash_table_free (bfd *obfd)
4262 {
4263 struct ppc_link_hash_table *htab;
4264
4265 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4266 if (htab->tocsave_htab)
4267 htab_delete (htab->tocsave_htab);
4268 bfd_hash_table_free (&htab->branch_hash_table);
4269 bfd_hash_table_free (&htab->stub_hash_table);
4270 _bfd_elf_link_hash_table_free (obfd);
4271 }
4272
4273 /* Create a ppc64 ELF linker hash table. */
4274
4275 static struct bfd_link_hash_table *
4276 ppc64_elf_link_hash_table_create (bfd *abfd)
4277 {
4278 struct ppc_link_hash_table *htab;
4279 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4280
4281 htab = bfd_zmalloc (amt);
4282 if (htab == NULL)
4283 return NULL;
4284
4285 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4286 sizeof (struct ppc_link_hash_entry),
4287 PPC64_ELF_DATA))
4288 {
4289 free (htab);
4290 return NULL;
4291 }
4292
4293 /* Init the stub hash table too. */
4294 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4295 sizeof (struct ppc_stub_hash_entry)))
4296 {
4297 _bfd_elf_link_hash_table_free (abfd);
4298 return NULL;
4299 }
4300
4301 /* And the branch hash table. */
4302 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4303 sizeof (struct ppc_branch_hash_entry)))
4304 {
4305 bfd_hash_table_free (&htab->stub_hash_table);
4306 _bfd_elf_link_hash_table_free (abfd);
4307 return NULL;
4308 }
4309
4310 htab->tocsave_htab = htab_try_create (1024,
4311 tocsave_htab_hash,
4312 tocsave_htab_eq,
4313 NULL);
4314 if (htab->tocsave_htab == NULL)
4315 {
4316 ppc64_elf_link_hash_table_free (abfd);
4317 return NULL;
4318 }
4319 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4320
4321 /* Initializing two fields of the union is just cosmetic. We really
4322 only care about glist, but when compiled on a 32-bit host the
4323 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4324 debugger inspection of these fields look nicer. */
4325 htab->elf.init_got_refcount.refcount = 0;
4326 htab->elf.init_got_refcount.glist = NULL;
4327 htab->elf.init_plt_refcount.refcount = 0;
4328 htab->elf.init_plt_refcount.glist = NULL;
4329 htab->elf.init_got_offset.offset = 0;
4330 htab->elf.init_got_offset.glist = NULL;
4331 htab->elf.init_plt_offset.offset = 0;
4332 htab->elf.init_plt_offset.glist = NULL;
4333
4334 return &htab->elf.root;
4335 }
4336
4337 /* Create sections for linker generated code. */
4338
4339 static bfd_boolean
4340 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4341 {
4342 struct ppc_link_hash_table *htab;
4343 flagword flags;
4344
4345 htab = ppc_hash_table (info);
4346
4347 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4348 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4349 if (htab->params->save_restore_funcs)
4350 {
4351 /* Create .sfpr for code to save and restore fp regs. */
4352 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4353 flags);
4354 if (htab->sfpr == NULL
4355 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4356 return FALSE;
4357 }
4358
4359 if (bfd_link_relocatable (info))
4360 return TRUE;
4361
4362 /* Create .glink for lazy dynamic linking support. */
4363 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4364 flags);
4365 if (htab->glink == NULL
4366 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4367 return FALSE;
4368
4369 if (!info->no_ld_generated_unwind_info)
4370 {
4371 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4372 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4373 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4374 ".eh_frame",
4375 flags);
4376 if (htab->glink_eh_frame == NULL
4377 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4378 return FALSE;
4379 }
4380
4381 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4382 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4383 if (htab->elf.iplt == NULL
4384 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4385 return FALSE;
4386
4387 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4388 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4389 htab->elf.irelplt
4390 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4391 if (htab->elf.irelplt == NULL
4392 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4393 return FALSE;
4394
4395 /* Create branch lookup table for plt_branch stubs. */
4396 flags = (SEC_ALLOC | SEC_LOAD
4397 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4398 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4399 flags);
4400 if (htab->brlt == NULL
4401 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4402 return FALSE;
4403
4404 if (!bfd_link_pic (info))
4405 return TRUE;
4406
4407 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4408 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4409 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4410 ".rela.branch_lt",
4411 flags);
4412 if (htab->relbrlt == NULL
4413 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4414 return FALSE;
4415
4416 return TRUE;
4417 }
4418
4419 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4420
4421 bfd_boolean
4422 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4423 struct ppc64_elf_params *params)
4424 {
4425 struct ppc_link_hash_table *htab;
4426
4427 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4428
4429 /* Always hook our dynamic sections into the first bfd, which is the
4430 linker created stub bfd. This ensures that the GOT header is at
4431 the start of the output TOC section. */
4432 htab = ppc_hash_table (info);
4433 if (htab == NULL)
4434 return FALSE;
4435 htab->elf.dynobj = params->stub_bfd;
4436 htab->params = params;
4437
4438 return create_linkage_sections (htab->elf.dynobj, info);
4439 }
4440
4441 /* Build a name for an entry in the stub hash table. */
4442
4443 static char *
4444 ppc_stub_name (const asection *input_section,
4445 const asection *sym_sec,
4446 const struct ppc_link_hash_entry *h,
4447 const Elf_Internal_Rela *rel)
4448 {
4449 char *stub_name;
4450 ssize_t len;
4451
4452 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4453 offsets from a sym as a branch target? In fact, we could
4454 probably assume the addend is always zero. */
4455 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4456
4457 if (h)
4458 {
4459 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4460 stub_name = bfd_malloc (len);
4461 if (stub_name == NULL)
4462 return stub_name;
4463
4464 len = sprintf (stub_name, "%08x.%s+%x",
4465 input_section->id & 0xffffffff,
4466 h->elf.root.root.string,
4467 (int) rel->r_addend & 0xffffffff);
4468 }
4469 else
4470 {
4471 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4472 stub_name = bfd_malloc (len);
4473 if (stub_name == NULL)
4474 return stub_name;
4475
4476 len = sprintf (stub_name, "%08x.%x:%x+%x",
4477 input_section->id & 0xffffffff,
4478 sym_sec->id & 0xffffffff,
4479 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4480 (int) rel->r_addend & 0xffffffff);
4481 }
4482 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4483 stub_name[len - 2] = 0;
4484 return stub_name;
4485 }
4486
4487 /* Look up an entry in the stub hash. Stub entries are cached because
4488 creating the stub name takes a bit of time. */
4489
4490 static struct ppc_stub_hash_entry *
4491 ppc_get_stub_entry (const asection *input_section,
4492 const asection *sym_sec,
4493 struct ppc_link_hash_entry *h,
4494 const Elf_Internal_Rela *rel,
4495 struct ppc_link_hash_table *htab)
4496 {
4497 struct ppc_stub_hash_entry *stub_entry;
4498 struct map_stub *group;
4499
4500 /* If this input section is part of a group of sections sharing one
4501 stub section, then use the id of the first section in the group.
4502 Stub names need to include a section id, as there may well be
4503 more than one stub used to reach say, printf, and we need to
4504 distinguish between them. */
4505 group = htab->sec_info[input_section->id].u.group;
4506
4507 if (h != NULL && h->u.stub_cache != NULL
4508 && h->u.stub_cache->h == h
4509 && h->u.stub_cache->group == group)
4510 {
4511 stub_entry = h->u.stub_cache;
4512 }
4513 else
4514 {
4515 char *stub_name;
4516
4517 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4518 if (stub_name == NULL)
4519 return NULL;
4520
4521 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4522 stub_name, FALSE, FALSE);
4523 if (h != NULL)
4524 h->u.stub_cache = stub_entry;
4525
4526 free (stub_name);
4527 }
4528
4529 return stub_entry;
4530 }
4531
4532 /* Add a new stub entry to the stub hash. Not all fields of the new
4533 stub entry are initialised. */
4534
4535 static struct ppc_stub_hash_entry *
4536 ppc_add_stub (const char *stub_name,
4537 asection *section,
4538 struct bfd_link_info *info)
4539 {
4540 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4541 struct map_stub *group;
4542 asection *link_sec;
4543 asection *stub_sec;
4544 struct ppc_stub_hash_entry *stub_entry;
4545
4546 group = htab->sec_info[section->id].u.group;
4547 link_sec = group->link_sec;
4548 stub_sec = group->stub_sec;
4549 if (stub_sec == NULL)
4550 {
4551 size_t namelen;
4552 bfd_size_type len;
4553 char *s_name;
4554
4555 namelen = strlen (link_sec->name);
4556 len = namelen + sizeof (STUB_SUFFIX);
4557 s_name = bfd_alloc (htab->params->stub_bfd, len);
4558 if (s_name == NULL)
4559 return NULL;
4560
4561 memcpy (s_name, link_sec->name, namelen);
4562 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4563 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4564 if (stub_sec == NULL)
4565 return NULL;
4566 group->stub_sec = stub_sec;
4567 }
4568
4569 /* Enter this entry into the linker stub hash table. */
4570 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4571 TRUE, FALSE);
4572 if (stub_entry == NULL)
4573 {
4574 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4575 section->owner, stub_name);
4576 return NULL;
4577 }
4578
4579 stub_entry->group = group;
4580 stub_entry->stub_offset = 0;
4581 return stub_entry;
4582 }
4583
4584 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4585 not already done. */
4586
4587 static bfd_boolean
4588 create_got_section (bfd *abfd, struct bfd_link_info *info)
4589 {
4590 asection *got, *relgot;
4591 flagword flags;
4592 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4593
4594 if (!is_ppc64_elf (abfd))
4595 return FALSE;
4596 if (htab == NULL)
4597 return FALSE;
4598
4599 if (!htab->elf.sgot
4600 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4601 return FALSE;
4602
4603 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4604 | SEC_LINKER_CREATED);
4605
4606 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4607 if (!got
4608 || !bfd_set_section_alignment (abfd, got, 3))
4609 return FALSE;
4610
4611 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4612 flags | SEC_READONLY);
4613 if (!relgot
4614 || ! bfd_set_section_alignment (abfd, relgot, 3))
4615 return FALSE;
4616
4617 ppc64_elf_tdata (abfd)->got = got;
4618 ppc64_elf_tdata (abfd)->relgot = relgot;
4619 return TRUE;
4620 }
4621
4622 /* Create the dynamic sections, and set up shortcuts. */
4623
4624 static bfd_boolean
4625 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4626 {
4627 struct ppc_link_hash_table *htab;
4628
4629 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4630 return FALSE;
4631
4632 htab = ppc_hash_table (info);
4633 if (htab == NULL)
4634 return FALSE;
4635
4636 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4637 if (!bfd_link_pic (info))
4638 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4639
4640 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4641 || (!bfd_link_pic (info) && !htab->relbss))
4642 abort ();
4643
4644 return TRUE;
4645 }
4646
4647 /* Follow indirect and warning symbol links. */
4648
4649 static inline struct bfd_link_hash_entry *
4650 follow_link (struct bfd_link_hash_entry *h)
4651 {
4652 while (h->type == bfd_link_hash_indirect
4653 || h->type == bfd_link_hash_warning)
4654 h = h->u.i.link;
4655 return h;
4656 }
4657
4658 static inline struct elf_link_hash_entry *
4659 elf_follow_link (struct elf_link_hash_entry *h)
4660 {
4661 return (struct elf_link_hash_entry *) follow_link (&h->root);
4662 }
4663
4664 static inline struct ppc_link_hash_entry *
4665 ppc_follow_link (struct ppc_link_hash_entry *h)
4666 {
4667 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4668 }
4669
4670 /* Merge PLT info on FROM with that on TO. */
4671
4672 static void
4673 move_plt_plist (struct ppc_link_hash_entry *from,
4674 struct ppc_link_hash_entry *to)
4675 {
4676 if (from->elf.plt.plist != NULL)
4677 {
4678 if (to->elf.plt.plist != NULL)
4679 {
4680 struct plt_entry **entp;
4681 struct plt_entry *ent;
4682
4683 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4684 {
4685 struct plt_entry *dent;
4686
4687 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4688 if (dent->addend == ent->addend)
4689 {
4690 dent->plt.refcount += ent->plt.refcount;
4691 *entp = ent->next;
4692 break;
4693 }
4694 if (dent == NULL)
4695 entp = &ent->next;
4696 }
4697 *entp = to->elf.plt.plist;
4698 }
4699
4700 to->elf.plt.plist = from->elf.plt.plist;
4701 from->elf.plt.plist = NULL;
4702 }
4703 }
4704
4705 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4706
4707 static void
4708 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4709 struct elf_link_hash_entry *dir,
4710 struct elf_link_hash_entry *ind)
4711 {
4712 struct ppc_link_hash_entry *edir, *eind;
4713
4714 edir = (struct ppc_link_hash_entry *) dir;
4715 eind = (struct ppc_link_hash_entry *) ind;
4716
4717 edir->is_func |= eind->is_func;
4718 edir->is_func_descriptor |= eind->is_func_descriptor;
4719 edir->tls_mask |= eind->tls_mask;
4720 if (eind->oh != NULL)
4721 edir->oh = ppc_follow_link (eind->oh);
4722
4723 /* If called to transfer flags for a weakdef during processing
4724 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4725 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4726 if (!(ELIMINATE_COPY_RELOCS
4727 && eind->elf.root.type != bfd_link_hash_indirect
4728 && edir->elf.dynamic_adjusted))
4729 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4730
4731 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4732 edir->elf.ref_regular |= eind->elf.ref_regular;
4733 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4734 edir->elf.needs_plt |= eind->elf.needs_plt;
4735 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4736
4737 /* Copy over any dynamic relocs we may have on the indirect sym. */
4738 if (eind->dyn_relocs != NULL)
4739 {
4740 if (edir->dyn_relocs != NULL)
4741 {
4742 struct elf_dyn_relocs **pp;
4743 struct elf_dyn_relocs *p;
4744
4745 /* Add reloc counts against the indirect sym to the direct sym
4746 list. Merge any entries against the same section. */
4747 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4748 {
4749 struct elf_dyn_relocs *q;
4750
4751 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4752 if (q->sec == p->sec)
4753 {
4754 q->pc_count += p->pc_count;
4755 q->count += p->count;
4756 *pp = p->next;
4757 break;
4758 }
4759 if (q == NULL)
4760 pp = &p->next;
4761 }
4762 *pp = edir->dyn_relocs;
4763 }
4764
4765 edir->dyn_relocs = eind->dyn_relocs;
4766 eind->dyn_relocs = NULL;
4767 }
4768
4769 /* If we were called to copy over info for a weak sym, that's all.
4770 You might think dyn_relocs need not be copied over; After all,
4771 both syms will be dynamic or both non-dynamic so we're just
4772 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4773 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4774 dyn_relocs in read-only sections, and it does so on what is the
4775 DIR sym here. */
4776 if (eind->elf.root.type != bfd_link_hash_indirect)
4777 return;
4778
4779 /* Copy over got entries that we may have already seen to the
4780 symbol which just became indirect. */
4781 if (eind->elf.got.glist != NULL)
4782 {
4783 if (edir->elf.got.glist != NULL)
4784 {
4785 struct got_entry **entp;
4786 struct got_entry *ent;
4787
4788 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4789 {
4790 struct got_entry *dent;
4791
4792 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4793 if (dent->addend == ent->addend
4794 && dent->owner == ent->owner
4795 && dent->tls_type == ent->tls_type)
4796 {
4797 dent->got.refcount += ent->got.refcount;
4798 *entp = ent->next;
4799 break;
4800 }
4801 if (dent == NULL)
4802 entp = &ent->next;
4803 }
4804 *entp = edir->elf.got.glist;
4805 }
4806
4807 edir->elf.got.glist = eind->elf.got.glist;
4808 eind->elf.got.glist = NULL;
4809 }
4810
4811 /* And plt entries. */
4812 move_plt_plist (eind, edir);
4813
4814 if (eind->elf.dynindx != -1)
4815 {
4816 if (edir->elf.dynindx != -1)
4817 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4818 edir->elf.dynstr_index);
4819 edir->elf.dynindx = eind->elf.dynindx;
4820 edir->elf.dynstr_index = eind->elf.dynstr_index;
4821 eind->elf.dynindx = -1;
4822 eind->elf.dynstr_index = 0;
4823 }
4824 }
4825
4826 /* Find the function descriptor hash entry from the given function code
4827 hash entry FH. Link the entries via their OH fields. */
4828
4829 static struct ppc_link_hash_entry *
4830 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4831 {
4832 struct ppc_link_hash_entry *fdh = fh->oh;
4833
4834 if (fdh == NULL)
4835 {
4836 const char *fd_name = fh->elf.root.root.string + 1;
4837
4838 fdh = (struct ppc_link_hash_entry *)
4839 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4840 if (fdh == NULL)
4841 return fdh;
4842
4843 fdh->is_func_descriptor = 1;
4844 fdh->oh = fh;
4845 fh->is_func = 1;
4846 fh->oh = fdh;
4847 }
4848
4849 return ppc_follow_link (fdh);
4850 }
4851
4852 /* Make a fake function descriptor sym for the code sym FH. */
4853
4854 static struct ppc_link_hash_entry *
4855 make_fdh (struct bfd_link_info *info,
4856 struct ppc_link_hash_entry *fh)
4857 {
4858 bfd *abfd;
4859 asymbol *newsym;
4860 struct bfd_link_hash_entry *bh;
4861 struct ppc_link_hash_entry *fdh;
4862
4863 abfd = fh->elf.root.u.undef.abfd;
4864 newsym = bfd_make_empty_symbol (abfd);
4865 newsym->name = fh->elf.root.root.string + 1;
4866 newsym->section = bfd_und_section_ptr;
4867 newsym->value = 0;
4868 newsym->flags = BSF_WEAK;
4869
4870 bh = NULL;
4871 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4872 newsym->flags, newsym->section,
4873 newsym->value, NULL, FALSE, FALSE,
4874 &bh))
4875 return NULL;
4876
4877 fdh = (struct ppc_link_hash_entry *) bh;
4878 fdh->elf.non_elf = 0;
4879 fdh->fake = 1;
4880 fdh->is_func_descriptor = 1;
4881 fdh->oh = fh;
4882 fh->is_func = 1;
4883 fh->oh = fdh;
4884 return fdh;
4885 }
4886
4887 /* Fix function descriptor symbols defined in .opd sections to be
4888 function type. */
4889
4890 static bfd_boolean
4891 ppc64_elf_add_symbol_hook (bfd *ibfd,
4892 struct bfd_link_info *info,
4893 Elf_Internal_Sym *isym,
4894 const char **name,
4895 flagword *flags ATTRIBUTE_UNUSED,
4896 asection **sec,
4897 bfd_vma *value)
4898 {
4899 if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4900 || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4901 && (ibfd->flags & DYNAMIC) == 0
4902 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4903 elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4904
4905 if (*sec != NULL
4906 && strcmp ((*sec)->name, ".opd") == 0)
4907 {
4908 asection *code_sec;
4909
4910 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4911 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4912 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4913
4914 /* If the symbol is a function defined in .opd, and the function
4915 code is in a discarded group, let it appear to be undefined. */
4916 if (!bfd_link_relocatable (info)
4917 && (*sec)->reloc_count != 0
4918 && opd_entry_value (*sec, *value, &code_sec, NULL,
4919 FALSE) != (bfd_vma) -1
4920 && discarded_section (code_sec))
4921 {
4922 *sec = bfd_und_section_ptr;
4923 isym->st_shndx = SHN_UNDEF;
4924 }
4925 }
4926 else if (*sec != NULL
4927 && strcmp ((*sec)->name, ".toc") == 0
4928 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4929 {
4930 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4931 if (htab != NULL)
4932 htab->params->object_in_toc = 1;
4933 }
4934
4935 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4936 {
4937 if (abiversion (ibfd) == 0)
4938 set_abiversion (ibfd, 2);
4939 else if (abiversion (ibfd) == 1)
4940 {
4941 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4942 " for ABI version 1\n"), name);
4943 bfd_set_error (bfd_error_bad_value);
4944 return FALSE;
4945 }
4946 }
4947
4948 return TRUE;
4949 }
4950
4951 /* Merge non-visibility st_other attributes: local entry point. */
4952
4953 static void
4954 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4955 const Elf_Internal_Sym *isym,
4956 bfd_boolean definition,
4957 bfd_boolean dynamic)
4958 {
4959 if (definition && !dynamic)
4960 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4961 | ELF_ST_VISIBILITY (h->other));
4962 }
4963
4964 /* This function makes an old ABI object reference to ".bar" cause the
4965 inclusion of a new ABI object archive that defines "bar".
4966 NAME is a symbol defined in an archive. Return a symbol in the hash
4967 table that might be satisfied by the archive symbols. */
4968
4969 static struct elf_link_hash_entry *
4970 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4971 struct bfd_link_info *info,
4972 const char *name)
4973 {
4974 struct elf_link_hash_entry *h;
4975 char *dot_name;
4976 size_t len;
4977
4978 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4979 if (h != NULL
4980 /* Don't return this sym if it is a fake function descriptor
4981 created by add_symbol_adjust. */
4982 && !(h->root.type == bfd_link_hash_undefweak
4983 && ((struct ppc_link_hash_entry *) h)->fake))
4984 return h;
4985
4986 if (name[0] == '.')
4987 return h;
4988
4989 len = strlen (name);
4990 dot_name = bfd_alloc (abfd, len + 2);
4991 if (dot_name == NULL)
4992 return (struct elf_link_hash_entry *) 0 - 1;
4993 dot_name[0] = '.';
4994 memcpy (dot_name + 1, name, len + 1);
4995 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4996 bfd_release (abfd, dot_name);
4997 return h;
4998 }
4999
5000 /* This function satisfies all old ABI object references to ".bar" if a
5001 new ABI object defines "bar". Well, at least, undefined dot symbols
5002 are made weak. This stops later archive searches from including an
5003 object if we already have a function descriptor definition. It also
5004 prevents the linker complaining about undefined symbols.
5005 We also check and correct mismatched symbol visibility here. The
5006 most restrictive visibility of the function descriptor and the
5007 function entry symbol is used. */
5008
5009 static bfd_boolean
5010 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5011 {
5012 struct ppc_link_hash_table *htab;
5013 struct ppc_link_hash_entry *fdh;
5014
5015 if (eh->elf.root.type == bfd_link_hash_indirect)
5016 return TRUE;
5017
5018 if (eh->elf.root.type == bfd_link_hash_warning)
5019 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5020
5021 if (eh->elf.root.root.string[0] != '.')
5022 abort ();
5023
5024 htab = ppc_hash_table (info);
5025 if (htab == NULL)
5026 return FALSE;
5027
5028 fdh = lookup_fdh (eh, htab);
5029 if (fdh == NULL)
5030 {
5031 if (!bfd_link_relocatable (info)
5032 && (eh->elf.root.type == bfd_link_hash_undefined
5033 || eh->elf.root.type == bfd_link_hash_undefweak)
5034 && eh->elf.ref_regular)
5035 {
5036 /* Make an undefweak function descriptor sym, which is enough to
5037 pull in an --as-needed shared lib, but won't cause link
5038 errors. Archives are handled elsewhere. */
5039 fdh = make_fdh (info, eh);
5040 if (fdh == NULL)
5041 return FALSE;
5042 fdh->elf.ref_regular = 1;
5043 }
5044 }
5045 else
5046 {
5047 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5048 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5049 if (entry_vis < descr_vis)
5050 fdh->elf.other += entry_vis - descr_vis;
5051 else if (entry_vis > descr_vis)
5052 eh->elf.other += descr_vis - entry_vis;
5053
5054 if ((fdh->elf.root.type == bfd_link_hash_defined
5055 || fdh->elf.root.type == bfd_link_hash_defweak)
5056 && eh->elf.root.type == bfd_link_hash_undefined)
5057 {
5058 eh->elf.root.type = bfd_link_hash_undefweak;
5059 eh->was_undefined = 1;
5060 htab->twiddled_syms = 1;
5061 }
5062 }
5063
5064 return TRUE;
5065 }
5066
5067 /* Set up opd section info and abiversion for IBFD, and process list
5068 of dot-symbols we made in link_hash_newfunc. */
5069
5070 static bfd_boolean
5071 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5072 {
5073 struct ppc_link_hash_table *htab;
5074 struct ppc_link_hash_entry **p, *eh;
5075 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5076
5077 if (opd != NULL && opd->size != 0)
5078 {
5079 if (abiversion (ibfd) == 0)
5080 set_abiversion (ibfd, 1);
5081 else if (abiversion (ibfd) == 2)
5082 {
5083 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5084 " version %d\n"),
5085 ibfd, abiversion (ibfd));
5086 bfd_set_error (bfd_error_bad_value);
5087 return FALSE;
5088 }
5089
5090 if ((ibfd->flags & DYNAMIC) == 0
5091 && (opd->flags & SEC_RELOC) != 0
5092 && opd->reloc_count != 0
5093 && !bfd_is_abs_section (opd->output_section))
5094 {
5095 /* Garbage collection needs some extra help with .opd sections.
5096 We don't want to necessarily keep everything referenced by
5097 relocs in .opd, as that would keep all functions. Instead,
5098 if we reference an .opd symbol (a function descriptor), we
5099 want to keep the function code symbol's section. This is
5100 easy for global symbols, but for local syms we need to keep
5101 information about the associated function section. */
5102 bfd_size_type amt;
5103 asection **opd_sym_map;
5104
5105 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5106 opd_sym_map = bfd_zalloc (ibfd, amt);
5107 if (opd_sym_map == NULL)
5108 return FALSE;
5109 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5110 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5111 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5112 }
5113 }
5114
5115 if (!is_ppc64_elf (info->output_bfd))
5116 return TRUE;
5117 htab = ppc_hash_table (info);
5118 if (htab == NULL)
5119 return FALSE;
5120
5121 /* For input files without an explicit abiversion in e_flags
5122 we should have flagged any with symbol st_other bits set
5123 as ELFv1 and above flagged those with .opd as ELFv2.
5124 Set the output abiversion if not yet set, and for any input
5125 still ambiguous, take its abiversion from the output.
5126 Differences in ABI are reported later. */
5127 if (abiversion (info->output_bfd) == 0)
5128 set_abiversion (info->output_bfd, abiversion (ibfd));
5129 else if (abiversion (ibfd) == 0)
5130 set_abiversion (ibfd, abiversion (info->output_bfd));
5131
5132 p = &htab->dot_syms;
5133 while ((eh = *p) != NULL)
5134 {
5135 *p = NULL;
5136 if (&eh->elf == htab->elf.hgot)
5137 ;
5138 else if (htab->elf.hgot == NULL
5139 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5140 htab->elf.hgot = &eh->elf;
5141 else if (!add_symbol_adjust (eh, info))
5142 return FALSE;
5143 p = &eh->u.next_dot_sym;
5144 }
5145
5146 /* Clear the list for non-ppc64 input files. */
5147 p = &htab->dot_syms;
5148 while ((eh = *p) != NULL)
5149 {
5150 *p = NULL;
5151 p = &eh->u.next_dot_sym;
5152 }
5153
5154 /* We need to fix the undefs list for any syms we have twiddled to
5155 undef_weak. */
5156 if (htab->twiddled_syms)
5157 {
5158 bfd_link_repair_undef_list (&htab->elf.root);
5159 htab->twiddled_syms = 0;
5160 }
5161 return TRUE;
5162 }
5163
5164 /* Undo hash table changes when an --as-needed input file is determined
5165 not to be needed. */
5166
5167 static bfd_boolean
5168 ppc64_elf_notice_as_needed (bfd *ibfd,
5169 struct bfd_link_info *info,
5170 enum notice_asneeded_action act)
5171 {
5172 if (act == notice_not_needed)
5173 {
5174 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5175
5176 if (htab == NULL)
5177 return FALSE;
5178
5179 htab->dot_syms = NULL;
5180 }
5181 return _bfd_elf_notice_as_needed (ibfd, info, act);
5182 }
5183
5184 /* If --just-symbols against a final linked binary, then assume we need
5185 toc adjusting stubs when calling functions defined there. */
5186
5187 static void
5188 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5189 {
5190 if ((sec->flags & SEC_CODE) != 0
5191 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5192 && is_ppc64_elf (sec->owner))
5193 {
5194 if (abiversion (sec->owner) >= 2
5195 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5196 sec->has_toc_reloc = 1;
5197 }
5198 _bfd_elf_link_just_syms (sec, info);
5199 }
5200
5201 static struct plt_entry **
5202 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5203 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5204 {
5205 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5206 struct plt_entry **local_plt;
5207 unsigned char *local_got_tls_masks;
5208
5209 if (local_got_ents == NULL)
5210 {
5211 bfd_size_type size = symtab_hdr->sh_info;
5212
5213 size *= (sizeof (*local_got_ents)
5214 + sizeof (*local_plt)
5215 + sizeof (*local_got_tls_masks));
5216 local_got_ents = bfd_zalloc (abfd, size);
5217 if (local_got_ents == NULL)
5218 return NULL;
5219 elf_local_got_ents (abfd) = local_got_ents;
5220 }
5221
5222 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5223 {
5224 struct got_entry *ent;
5225
5226 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5227 if (ent->addend == r_addend
5228 && ent->owner == abfd
5229 && ent->tls_type == tls_type)
5230 break;
5231 if (ent == NULL)
5232 {
5233 bfd_size_type amt = sizeof (*ent);
5234 ent = bfd_alloc (abfd, amt);
5235 if (ent == NULL)
5236 return FALSE;
5237 ent->next = local_got_ents[r_symndx];
5238 ent->addend = r_addend;
5239 ent->owner = abfd;
5240 ent->tls_type = tls_type;
5241 ent->is_indirect = FALSE;
5242 ent->got.refcount = 0;
5243 local_got_ents[r_symndx] = ent;
5244 }
5245 ent->got.refcount += 1;
5246 }
5247
5248 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5249 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5250 local_got_tls_masks[r_symndx] |= tls_type;
5251
5252 return local_plt + r_symndx;
5253 }
5254
5255 static bfd_boolean
5256 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5257 {
5258 struct plt_entry *ent;
5259
5260 for (ent = *plist; ent != NULL; ent = ent->next)
5261 if (ent->addend == addend)
5262 break;
5263 if (ent == NULL)
5264 {
5265 bfd_size_type amt = sizeof (*ent);
5266 ent = bfd_alloc (abfd, amt);
5267 if (ent == NULL)
5268 return FALSE;
5269 ent->next = *plist;
5270 ent->addend = addend;
5271 ent->plt.refcount = 0;
5272 *plist = ent;
5273 }
5274 ent->plt.refcount += 1;
5275 return TRUE;
5276 }
5277
5278 static bfd_boolean
5279 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5280 {
5281 return (r_type == R_PPC64_REL24
5282 || r_type == R_PPC64_REL14
5283 || r_type == R_PPC64_REL14_BRTAKEN
5284 || r_type == R_PPC64_REL14_BRNTAKEN
5285 || r_type == R_PPC64_ADDR24
5286 || r_type == R_PPC64_ADDR14
5287 || r_type == R_PPC64_ADDR14_BRTAKEN
5288 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5289 }
5290
5291 /* Look through the relocs for a section during the first phase, and
5292 calculate needed space in the global offset table, procedure
5293 linkage table, and dynamic reloc sections. */
5294
5295 static bfd_boolean
5296 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5297 asection *sec, const Elf_Internal_Rela *relocs)
5298 {
5299 struct ppc_link_hash_table *htab;
5300 Elf_Internal_Shdr *symtab_hdr;
5301 struct elf_link_hash_entry **sym_hashes;
5302 const Elf_Internal_Rela *rel;
5303 const Elf_Internal_Rela *rel_end;
5304 asection *sreloc;
5305 asection **opd_sym_map;
5306 struct elf_link_hash_entry *tga, *dottga;
5307
5308 if (bfd_link_relocatable (info))
5309 return TRUE;
5310
5311 /* Don't do anything special with non-loaded, non-alloced sections.
5312 In particular, any relocs in such sections should not affect GOT
5313 and PLT reference counting (ie. we don't allow them to create GOT
5314 or PLT entries), there's no possibility or desire to optimize TLS
5315 relocs, and there's not much point in propagating relocs to shared
5316 libs that the dynamic linker won't relocate. */
5317 if ((sec->flags & SEC_ALLOC) == 0)
5318 return TRUE;
5319
5320 BFD_ASSERT (is_ppc64_elf (abfd));
5321
5322 htab = ppc_hash_table (info);
5323 if (htab == NULL)
5324 return FALSE;
5325
5326 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5327 FALSE, FALSE, TRUE);
5328 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5329 FALSE, FALSE, TRUE);
5330 symtab_hdr = &elf_symtab_hdr (abfd);
5331 sym_hashes = elf_sym_hashes (abfd);
5332 sreloc = NULL;
5333 opd_sym_map = NULL;
5334 if (ppc64_elf_section_data (sec) != NULL
5335 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5336 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5337
5338 rel_end = relocs + sec->reloc_count;
5339 for (rel = relocs; rel < rel_end; rel++)
5340 {
5341 unsigned long r_symndx;
5342 struct elf_link_hash_entry *h;
5343 enum elf_ppc64_reloc_type r_type;
5344 int tls_type;
5345 struct _ppc64_elf_section_data *ppc64_sec;
5346 struct plt_entry **ifunc, **plt_list;
5347
5348 r_symndx = ELF64_R_SYM (rel->r_info);
5349 if (r_symndx < symtab_hdr->sh_info)
5350 h = NULL;
5351 else
5352 {
5353 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5354 h = elf_follow_link (h);
5355
5356 /* PR15323, ref flags aren't set for references in the same
5357 object. */
5358 h->root.non_ir_ref = 1;
5359
5360 if (h == htab->elf.hgot)
5361 sec->has_toc_reloc = 1;
5362 }
5363
5364 tls_type = 0;
5365 ifunc = NULL;
5366 if (h != NULL)
5367 {
5368 if (h->type == STT_GNU_IFUNC)
5369 {
5370 h->needs_plt = 1;
5371 ifunc = &h->plt.plist;
5372 }
5373 }
5374 else
5375 {
5376 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5377 abfd, r_symndx);
5378 if (isym == NULL)
5379 return FALSE;
5380
5381 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5382 {
5383 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5384 rel->r_addend, PLT_IFUNC);
5385 if (ifunc == NULL)
5386 return FALSE;
5387 }
5388 }
5389
5390 r_type = ELF64_R_TYPE (rel->r_info);
5391 switch (r_type)
5392 {
5393 case R_PPC64_TLSGD:
5394 case R_PPC64_TLSLD:
5395 /* These special tls relocs tie a call to __tls_get_addr with
5396 its parameter symbol. */
5397 break;
5398
5399 case R_PPC64_GOT_TLSLD16:
5400 case R_PPC64_GOT_TLSLD16_LO:
5401 case R_PPC64_GOT_TLSLD16_HI:
5402 case R_PPC64_GOT_TLSLD16_HA:
5403 tls_type = TLS_TLS | TLS_LD;
5404 goto dogottls;
5405
5406 case R_PPC64_GOT_TLSGD16:
5407 case R_PPC64_GOT_TLSGD16_LO:
5408 case R_PPC64_GOT_TLSGD16_HI:
5409 case R_PPC64_GOT_TLSGD16_HA:
5410 tls_type = TLS_TLS | TLS_GD;
5411 goto dogottls;
5412
5413 case R_PPC64_GOT_TPREL16_DS:
5414 case R_PPC64_GOT_TPREL16_LO_DS:
5415 case R_PPC64_GOT_TPREL16_HI:
5416 case R_PPC64_GOT_TPREL16_HA:
5417 if (bfd_link_pic (info))
5418 info->flags |= DF_STATIC_TLS;
5419 tls_type = TLS_TLS | TLS_TPREL;
5420 goto dogottls;
5421
5422 case R_PPC64_GOT_DTPREL16_DS:
5423 case R_PPC64_GOT_DTPREL16_LO_DS:
5424 case R_PPC64_GOT_DTPREL16_HI:
5425 case R_PPC64_GOT_DTPREL16_HA:
5426 tls_type = TLS_TLS | TLS_DTPREL;
5427 dogottls:
5428 sec->has_tls_reloc = 1;
5429 /* Fall thru */
5430
5431 case R_PPC64_GOT16:
5432 case R_PPC64_GOT16_DS:
5433 case R_PPC64_GOT16_HA:
5434 case R_PPC64_GOT16_HI:
5435 case R_PPC64_GOT16_LO:
5436 case R_PPC64_GOT16_LO_DS:
5437 /* This symbol requires a global offset table entry. */
5438 sec->has_toc_reloc = 1;
5439 if (r_type == R_PPC64_GOT_TLSLD16
5440 || r_type == R_PPC64_GOT_TLSGD16
5441 || r_type == R_PPC64_GOT_TPREL16_DS
5442 || r_type == R_PPC64_GOT_DTPREL16_DS
5443 || r_type == R_PPC64_GOT16
5444 || r_type == R_PPC64_GOT16_DS)
5445 {
5446 htab->do_multi_toc = 1;
5447 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5448 }
5449
5450 if (ppc64_elf_tdata (abfd)->got == NULL
5451 && !create_got_section (abfd, info))
5452 return FALSE;
5453
5454 if (h != NULL)
5455 {
5456 struct ppc_link_hash_entry *eh;
5457 struct got_entry *ent;
5458
5459 eh = (struct ppc_link_hash_entry *) h;
5460 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5461 if (ent->addend == rel->r_addend
5462 && ent->owner == abfd
5463 && ent->tls_type == tls_type)
5464 break;
5465 if (ent == NULL)
5466 {
5467 bfd_size_type amt = sizeof (*ent);
5468 ent = bfd_alloc (abfd, amt);
5469 if (ent == NULL)
5470 return FALSE;
5471 ent->next = eh->elf.got.glist;
5472 ent->addend = rel->r_addend;
5473 ent->owner = abfd;
5474 ent->tls_type = tls_type;
5475 ent->is_indirect = FALSE;
5476 ent->got.refcount = 0;
5477 eh->elf.got.glist = ent;
5478 }
5479 ent->got.refcount += 1;
5480 eh->tls_mask |= tls_type;
5481 }
5482 else
5483 /* This is a global offset table entry for a local symbol. */
5484 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5485 rel->r_addend, tls_type))
5486 return FALSE;
5487
5488 /* We may also need a plt entry if the symbol turns out to be
5489 an ifunc. */
5490 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5491 {
5492 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5493 return FALSE;
5494 }
5495 break;
5496
5497 case R_PPC64_PLT16_HA:
5498 case R_PPC64_PLT16_HI:
5499 case R_PPC64_PLT16_LO:
5500 case R_PPC64_PLT32:
5501 case R_PPC64_PLT64:
5502 /* This symbol requires a procedure linkage table entry. */
5503 plt_list = ifunc;
5504 if (h != NULL)
5505 {
5506 h->needs_plt = 1;
5507 if (h->root.root.string[0] == '.'
5508 && h->root.root.string[1] != '\0')
5509 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5510 plt_list = &h->plt.plist;
5511 }
5512 if (plt_list == NULL)
5513 {
5514 /* It does not make sense to have a procedure linkage
5515 table entry for a non-ifunc local symbol. */
5516 info->callbacks->einfo
5517 (_("%P: %H: %s reloc against local symbol\n"),
5518 abfd, sec, rel->r_offset,
5519 ppc64_elf_howto_table[r_type]->name);
5520 bfd_set_error (bfd_error_bad_value);
5521 return FALSE;
5522 }
5523 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5524 return FALSE;
5525 break;
5526
5527 /* The following relocations don't need to propagate the
5528 relocation if linking a shared object since they are
5529 section relative. */
5530 case R_PPC64_SECTOFF:
5531 case R_PPC64_SECTOFF_LO:
5532 case R_PPC64_SECTOFF_HI:
5533 case R_PPC64_SECTOFF_HA:
5534 case R_PPC64_SECTOFF_DS:
5535 case R_PPC64_SECTOFF_LO_DS:
5536 case R_PPC64_DTPREL16:
5537 case R_PPC64_DTPREL16_LO:
5538 case R_PPC64_DTPREL16_HI:
5539 case R_PPC64_DTPREL16_HA:
5540 case R_PPC64_DTPREL16_DS:
5541 case R_PPC64_DTPREL16_LO_DS:
5542 case R_PPC64_DTPREL16_HIGH:
5543 case R_PPC64_DTPREL16_HIGHA:
5544 case R_PPC64_DTPREL16_HIGHER:
5545 case R_PPC64_DTPREL16_HIGHERA:
5546 case R_PPC64_DTPREL16_HIGHEST:
5547 case R_PPC64_DTPREL16_HIGHESTA:
5548 break;
5549
5550 /* Nor do these. */
5551 case R_PPC64_REL16:
5552 case R_PPC64_REL16_LO:
5553 case R_PPC64_REL16_HI:
5554 case R_PPC64_REL16_HA:
5555 case R_PPC64_REL16DX_HA:
5556 break;
5557
5558 /* Not supported as a dynamic relocation. */
5559 case R_PPC64_ADDR64_LOCAL:
5560 if (bfd_link_pic (info))
5561 {
5562 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5563 ppc_howto_init ();
5564 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5565 "in shared libraries and PIEs.\n"),
5566 abfd, sec, rel->r_offset,
5567 ppc64_elf_howto_table[r_type]->name);
5568 bfd_set_error (bfd_error_bad_value);
5569 return FALSE;
5570 }
5571 break;
5572
5573 case R_PPC64_TOC16:
5574 case R_PPC64_TOC16_DS:
5575 htab->do_multi_toc = 1;
5576 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5577 case R_PPC64_TOC16_LO:
5578 case R_PPC64_TOC16_HI:
5579 case R_PPC64_TOC16_HA:
5580 case R_PPC64_TOC16_LO_DS:
5581 sec->has_toc_reloc = 1;
5582 break;
5583
5584 /* Marker reloc. */
5585 case R_PPC64_ENTRY:
5586 break;
5587
5588 /* This relocation describes the C++ object vtable hierarchy.
5589 Reconstruct it for later use during GC. */
5590 case R_PPC64_GNU_VTINHERIT:
5591 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5592 return FALSE;
5593 break;
5594
5595 /* This relocation describes which C++ vtable entries are actually
5596 used. Record for later use during GC. */
5597 case R_PPC64_GNU_VTENTRY:
5598 BFD_ASSERT (h != NULL);
5599 if (h != NULL
5600 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5601 return FALSE;
5602 break;
5603
5604 case R_PPC64_REL14:
5605 case R_PPC64_REL14_BRTAKEN:
5606 case R_PPC64_REL14_BRNTAKEN:
5607 {
5608 asection *dest = NULL;
5609
5610 /* Heuristic: If jumping outside our section, chances are
5611 we are going to need a stub. */
5612 if (h != NULL)
5613 {
5614 /* If the sym is weak it may be overridden later, so
5615 don't assume we know where a weak sym lives. */
5616 if (h->root.type == bfd_link_hash_defined)
5617 dest = h->root.u.def.section;
5618 }
5619 else
5620 {
5621 Elf_Internal_Sym *isym;
5622
5623 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5624 abfd, r_symndx);
5625 if (isym == NULL)
5626 return FALSE;
5627
5628 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5629 }
5630
5631 if (dest != sec)
5632 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5633 }
5634 /* Fall through. */
5635
5636 case R_PPC64_REL24:
5637 plt_list = ifunc;
5638 if (h != NULL)
5639 {
5640 h->needs_plt = 1;
5641 if (h->root.root.string[0] == '.'
5642 && h->root.root.string[1] != '\0')
5643 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5644
5645 if (h == tga || h == dottga)
5646 {
5647 sec->has_tls_reloc = 1;
5648 if (rel != relocs
5649 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5650 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5651 /* We have a new-style __tls_get_addr call with
5652 a marker reloc. */
5653 ;
5654 else
5655 /* Mark this section as having an old-style call. */
5656 sec->has_tls_get_addr_call = 1;
5657 }
5658 plt_list = &h->plt.plist;
5659 }
5660
5661 /* We may need a .plt entry if the function this reloc
5662 refers to is in a shared lib. */
5663 if (plt_list
5664 && !update_plt_info (abfd, plt_list, rel->r_addend))
5665 return FALSE;
5666 break;
5667
5668 case R_PPC64_ADDR14:
5669 case R_PPC64_ADDR14_BRNTAKEN:
5670 case R_PPC64_ADDR14_BRTAKEN:
5671 case R_PPC64_ADDR24:
5672 goto dodyn;
5673
5674 case R_PPC64_TPREL64:
5675 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5676 if (bfd_link_pic (info))
5677 info->flags |= DF_STATIC_TLS;
5678 goto dotlstoc;
5679
5680 case R_PPC64_DTPMOD64:
5681 if (rel + 1 < rel_end
5682 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5683 && rel[1].r_offset == rel->r_offset + 8)
5684 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5685 else
5686 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5687 goto dotlstoc;
5688
5689 case R_PPC64_DTPREL64:
5690 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5691 if (rel != relocs
5692 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5693 && rel[-1].r_offset == rel->r_offset - 8)
5694 /* This is the second reloc of a dtpmod, dtprel pair.
5695 Don't mark with TLS_DTPREL. */
5696 goto dodyn;
5697
5698 dotlstoc:
5699 sec->has_tls_reloc = 1;
5700 if (h != NULL)
5701 {
5702 struct ppc_link_hash_entry *eh;
5703 eh = (struct ppc_link_hash_entry *) h;
5704 eh->tls_mask |= tls_type;
5705 }
5706 else
5707 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5708 rel->r_addend, tls_type))
5709 return FALSE;
5710
5711 ppc64_sec = ppc64_elf_section_data (sec);
5712 if (ppc64_sec->sec_type != sec_toc)
5713 {
5714 bfd_size_type amt;
5715
5716 /* One extra to simplify get_tls_mask. */
5717 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5718 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5719 if (ppc64_sec->u.toc.symndx == NULL)
5720 return FALSE;
5721 amt = sec->size * sizeof (bfd_vma) / 8;
5722 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5723 if (ppc64_sec->u.toc.add == NULL)
5724 return FALSE;
5725 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5726 ppc64_sec->sec_type = sec_toc;
5727 }
5728 BFD_ASSERT (rel->r_offset % 8 == 0);
5729 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5730 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5731
5732 /* Mark the second slot of a GD or LD entry.
5733 -1 to indicate GD and -2 to indicate LD. */
5734 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5735 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5736 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5737 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5738 goto dodyn;
5739
5740 case R_PPC64_TPREL16:
5741 case R_PPC64_TPREL16_LO:
5742 case R_PPC64_TPREL16_HI:
5743 case R_PPC64_TPREL16_HA:
5744 case R_PPC64_TPREL16_DS:
5745 case R_PPC64_TPREL16_LO_DS:
5746 case R_PPC64_TPREL16_HIGH:
5747 case R_PPC64_TPREL16_HIGHA:
5748 case R_PPC64_TPREL16_HIGHER:
5749 case R_PPC64_TPREL16_HIGHERA:
5750 case R_PPC64_TPREL16_HIGHEST:
5751 case R_PPC64_TPREL16_HIGHESTA:
5752 if (bfd_link_pic (info))
5753 {
5754 info->flags |= DF_STATIC_TLS;
5755 goto dodyn;
5756 }
5757 break;
5758
5759 case R_PPC64_ADDR64:
5760 if (opd_sym_map != NULL
5761 && rel + 1 < rel_end
5762 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5763 {
5764 if (h != NULL)
5765 {
5766 if (h->root.root.string[0] == '.'
5767 && h->root.root.string[1] != 0
5768 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5769 ;
5770 else
5771 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5772 }
5773 else
5774 {
5775 asection *s;
5776 Elf_Internal_Sym *isym;
5777
5778 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5779 abfd, r_symndx);
5780 if (isym == NULL)
5781 return FALSE;
5782
5783 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5784 if (s != NULL && s != sec)
5785 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5786 }
5787 }
5788 /* Fall through. */
5789
5790 case R_PPC64_ADDR16:
5791 case R_PPC64_ADDR16_DS:
5792 case R_PPC64_ADDR16_HA:
5793 case R_PPC64_ADDR16_HI:
5794 case R_PPC64_ADDR16_HIGH:
5795 case R_PPC64_ADDR16_HIGHA:
5796 case R_PPC64_ADDR16_HIGHER:
5797 case R_PPC64_ADDR16_HIGHERA:
5798 case R_PPC64_ADDR16_HIGHEST:
5799 case R_PPC64_ADDR16_HIGHESTA:
5800 case R_PPC64_ADDR16_LO:
5801 case R_PPC64_ADDR16_LO_DS:
5802 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5803 && rel->r_addend == 0)
5804 {
5805 /* We may need a .plt entry if this reloc refers to a
5806 function in a shared lib. */
5807 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5808 return FALSE;
5809 h->pointer_equality_needed = 1;
5810 }
5811 /* Fall through. */
5812
5813 case R_PPC64_REL30:
5814 case R_PPC64_REL32:
5815 case R_PPC64_REL64:
5816 case R_PPC64_ADDR32:
5817 case R_PPC64_UADDR16:
5818 case R_PPC64_UADDR32:
5819 case R_PPC64_UADDR64:
5820 case R_PPC64_TOC:
5821 if (h != NULL && !bfd_link_pic (info))
5822 /* We may need a copy reloc. */
5823 h->non_got_ref = 1;
5824
5825 /* Don't propagate .opd relocs. */
5826 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5827 break;
5828
5829 /* If we are creating a shared library, and this is a reloc
5830 against a global symbol, or a non PC relative reloc
5831 against a local symbol, then we need to copy the reloc
5832 into the shared library. However, if we are linking with
5833 -Bsymbolic, we do not need to copy a reloc against a
5834 global symbol which is defined in an object we are
5835 including in the link (i.e., DEF_REGULAR is set). At
5836 this point we have not seen all the input files, so it is
5837 possible that DEF_REGULAR is not set now but will be set
5838 later (it is never cleared). In case of a weak definition,
5839 DEF_REGULAR may be cleared later by a strong definition in
5840 a shared library. We account for that possibility below by
5841 storing information in the dyn_relocs field of the hash
5842 table entry. A similar situation occurs when creating
5843 shared libraries and symbol visibility changes render the
5844 symbol local.
5845
5846 If on the other hand, we are creating an executable, we
5847 may need to keep relocations for symbols satisfied by a
5848 dynamic library if we manage to avoid copy relocs for the
5849 symbol. */
5850 dodyn:
5851 if ((bfd_link_pic (info)
5852 && (must_be_dyn_reloc (info, r_type)
5853 || (h != NULL
5854 && (!SYMBOLIC_BIND (info, h)
5855 || h->root.type == bfd_link_hash_defweak
5856 || !h->def_regular))))
5857 || (ELIMINATE_COPY_RELOCS
5858 && !bfd_link_pic (info)
5859 && h != NULL
5860 && (h->root.type == bfd_link_hash_defweak
5861 || !h->def_regular))
5862 || (!bfd_link_pic (info)
5863 && ifunc != NULL))
5864 {
5865 /* We must copy these reloc types into the output file.
5866 Create a reloc section in dynobj and make room for
5867 this reloc. */
5868 if (sreloc == NULL)
5869 {
5870 sreloc = _bfd_elf_make_dynamic_reloc_section
5871 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5872
5873 if (sreloc == NULL)
5874 return FALSE;
5875 }
5876
5877 /* If this is a global symbol, we count the number of
5878 relocations we need for this symbol. */
5879 if (h != NULL)
5880 {
5881 struct elf_dyn_relocs *p;
5882 struct elf_dyn_relocs **head;
5883
5884 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5885 p = *head;
5886 if (p == NULL || p->sec != sec)
5887 {
5888 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5889 if (p == NULL)
5890 return FALSE;
5891 p->next = *head;
5892 *head = p;
5893 p->sec = sec;
5894 p->count = 0;
5895 p->pc_count = 0;
5896 }
5897 p->count += 1;
5898 if (!must_be_dyn_reloc (info, r_type))
5899 p->pc_count += 1;
5900 }
5901 else
5902 {
5903 /* Track dynamic relocs needed for local syms too.
5904 We really need local syms available to do this
5905 easily. Oh well. */
5906 struct ppc_dyn_relocs *p;
5907 struct ppc_dyn_relocs **head;
5908 bfd_boolean is_ifunc;
5909 asection *s;
5910 void *vpp;
5911 Elf_Internal_Sym *isym;
5912
5913 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5914 abfd, r_symndx);
5915 if (isym == NULL)
5916 return FALSE;
5917
5918 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5919 if (s == NULL)
5920 s = sec;
5921
5922 vpp = &elf_section_data (s)->local_dynrel;
5923 head = (struct ppc_dyn_relocs **) vpp;
5924 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5925 p = *head;
5926 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5927 p = p->next;
5928 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5929 {
5930 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5931 if (p == NULL)
5932 return FALSE;
5933 p->next = *head;
5934 *head = p;
5935 p->sec = sec;
5936 p->ifunc = is_ifunc;
5937 p->count = 0;
5938 }
5939 p->count += 1;
5940 }
5941 }
5942 break;
5943
5944 default:
5945 break;
5946 }
5947 }
5948
5949 return TRUE;
5950 }
5951
5952 /* Merge backend specific data from an object file to the output
5953 object file when linking. */
5954
5955 static bfd_boolean
5956 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5957 {
5958 unsigned long iflags, oflags;
5959
5960 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5961 return TRUE;
5962
5963 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5964 return TRUE;
5965
5966 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5967 return FALSE;
5968
5969 iflags = elf_elfheader (ibfd)->e_flags;
5970 oflags = elf_elfheader (obfd)->e_flags;
5971
5972 if (iflags & ~EF_PPC64_ABI)
5973 {
5974 (*_bfd_error_handler)
5975 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5976 bfd_set_error (bfd_error_bad_value);
5977 return FALSE;
5978 }
5979 else if (iflags != oflags && iflags != 0)
5980 {
5981 (*_bfd_error_handler)
5982 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5983 ibfd, iflags, oflags);
5984 bfd_set_error (bfd_error_bad_value);
5985 return FALSE;
5986 }
5987
5988 /* Merge Tag_compatibility attributes and any common GNU ones. */
5989 _bfd_elf_merge_object_attributes (ibfd, obfd);
5990
5991 return TRUE;
5992 }
5993
5994 static bfd_boolean
5995 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5996 {
5997 /* Print normal ELF private data. */
5998 _bfd_elf_print_private_bfd_data (abfd, ptr);
5999
6000 if (elf_elfheader (abfd)->e_flags != 0)
6001 {
6002 FILE *file = ptr;
6003
6004 /* xgettext:c-format */
6005 fprintf (file, _("private flags = 0x%lx:"),
6006 elf_elfheader (abfd)->e_flags);
6007
6008 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6009 fprintf (file, _(" [abiv%ld]"),
6010 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6011 fputc ('\n', file);
6012 }
6013
6014 return TRUE;
6015 }
6016
6017 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6018 of the code entry point, and its section, which must be in the same
6019 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6020
6021 static bfd_vma
6022 opd_entry_value (asection *opd_sec,
6023 bfd_vma offset,
6024 asection **code_sec,
6025 bfd_vma *code_off,
6026 bfd_boolean in_code_sec)
6027 {
6028 bfd *opd_bfd = opd_sec->owner;
6029 Elf_Internal_Rela *relocs;
6030 Elf_Internal_Rela *lo, *hi, *look;
6031 bfd_vma val;
6032
6033 /* No relocs implies we are linking a --just-symbols object, or looking
6034 at a final linked executable with addr2line or somesuch. */
6035 if (opd_sec->reloc_count == 0)
6036 {
6037 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6038
6039 if (contents == NULL)
6040 {
6041 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6042 return (bfd_vma) -1;
6043 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6044 }
6045
6046 /* PR 17512: file: 64b9dfbb. */
6047 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6048 return (bfd_vma) -1;
6049
6050 val = bfd_get_64 (opd_bfd, contents + offset);
6051 if (code_sec != NULL)
6052 {
6053 asection *sec, *likely = NULL;
6054
6055 if (in_code_sec)
6056 {
6057 sec = *code_sec;
6058 if (sec->vma <= val
6059 && val < sec->vma + sec->size)
6060 likely = sec;
6061 else
6062 val = -1;
6063 }
6064 else
6065 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6066 if (sec->vma <= val
6067 && (sec->flags & SEC_LOAD) != 0
6068 && (sec->flags & SEC_ALLOC) != 0)
6069 likely = sec;
6070 if (likely != NULL)
6071 {
6072 *code_sec = likely;
6073 if (code_off != NULL)
6074 *code_off = val - likely->vma;
6075 }
6076 }
6077 return val;
6078 }
6079
6080 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6081
6082 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6083 if (relocs == NULL)
6084 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6085 /* PR 17512: file: df8e1fd6. */
6086 if (relocs == NULL)
6087 return (bfd_vma) -1;
6088
6089 /* Go find the opd reloc at the sym address. */
6090 lo = relocs;
6091 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6092 val = (bfd_vma) -1;
6093 while (lo < hi)
6094 {
6095 look = lo + (hi - lo) / 2;
6096 if (look->r_offset < offset)
6097 lo = look + 1;
6098 else if (look->r_offset > offset)
6099 hi = look;
6100 else
6101 {
6102 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6103
6104 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6105 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6106 {
6107 unsigned long symndx = ELF64_R_SYM (look->r_info);
6108 asection *sec = NULL;
6109
6110 if (symndx >= symtab_hdr->sh_info
6111 && elf_sym_hashes (opd_bfd) != NULL)
6112 {
6113 struct elf_link_hash_entry **sym_hashes;
6114 struct elf_link_hash_entry *rh;
6115
6116 sym_hashes = elf_sym_hashes (opd_bfd);
6117 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6118 if (rh != NULL)
6119 {
6120 rh = elf_follow_link (rh);
6121 if (rh->root.type != bfd_link_hash_defined
6122 && rh->root.type != bfd_link_hash_defweak)
6123 break;
6124 if (rh->root.u.def.section->owner == opd_bfd)
6125 {
6126 val = rh->root.u.def.value;
6127 sec = rh->root.u.def.section;
6128 }
6129 }
6130 }
6131
6132 if (sec == NULL)
6133 {
6134 Elf_Internal_Sym *sym;
6135
6136 if (symndx < symtab_hdr->sh_info)
6137 {
6138 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6139 if (sym == NULL)
6140 {
6141 size_t symcnt = symtab_hdr->sh_info;
6142 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6143 symcnt, 0,
6144 NULL, NULL, NULL);
6145 if (sym == NULL)
6146 break;
6147 symtab_hdr->contents = (bfd_byte *) sym;
6148 }
6149 sym += symndx;
6150 }
6151 else
6152 {
6153 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6154 1, symndx,
6155 NULL, NULL, NULL);
6156 if (sym == NULL)
6157 break;
6158 }
6159 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6160 if (sec == NULL)
6161 break;
6162 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6163 val = sym->st_value;
6164 }
6165
6166 val += look->r_addend;
6167 if (code_off != NULL)
6168 *code_off = val;
6169 if (code_sec != NULL)
6170 {
6171 if (in_code_sec && *code_sec != sec)
6172 return -1;
6173 else
6174 *code_sec = sec;
6175 }
6176 if (sec->output_section != NULL)
6177 val += sec->output_section->vma + sec->output_offset;
6178 }
6179 break;
6180 }
6181 }
6182
6183 return val;
6184 }
6185
6186 /* If the ELF symbol SYM might be a function in SEC, return the
6187 function size and set *CODE_OFF to the function's entry point,
6188 otherwise return zero. */
6189
6190 static bfd_size_type
6191 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6192 bfd_vma *code_off)
6193 {
6194 bfd_size_type size;
6195
6196 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6197 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6198 return 0;
6199
6200 size = 0;
6201 if (!(sym->flags & BSF_SYNTHETIC))
6202 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6203
6204 if (strcmp (sym->section->name, ".opd") == 0)
6205 {
6206 struct _opd_sec_data *opd = get_opd_info (sym->section);
6207 bfd_vma symval = sym->value;
6208
6209 if (opd != NULL
6210 && opd->adjust != NULL
6211 && elf_section_data (sym->section)->relocs != NULL)
6212 {
6213 /* opd_entry_value will use cached relocs that have been
6214 adjusted, but with raw symbols. That means both local
6215 and global symbols need adjusting. */
6216 long adjust = opd->adjust[OPD_NDX (symval)];
6217 if (adjust == -1)
6218 return 0;
6219 symval += adjust;
6220 }
6221
6222 if (opd_entry_value (sym->section, symval,
6223 &sec, code_off, TRUE) == (bfd_vma) -1)
6224 return 0;
6225 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6226 symbol. This size has nothing to do with the code size of the
6227 function, which is what we're supposed to return, but the
6228 code size isn't available without looking up the dot-sym.
6229 However, doing that would be a waste of time particularly
6230 since elf_find_function will look at the dot-sym anyway.
6231 Now, elf_find_function will keep the largest size of any
6232 function sym found at the code address of interest, so return
6233 1 here to avoid it incorrectly caching a larger function size
6234 for a small function. This does mean we return the wrong
6235 size for a new-ABI function of size 24, but all that does is
6236 disable caching for such functions. */
6237 if (size == 24)
6238 size = 1;
6239 }
6240 else
6241 {
6242 if (sym->section != sec)
6243 return 0;
6244 *code_off = sym->value;
6245 }
6246 if (size == 0)
6247 size = 1;
6248 return size;
6249 }
6250
6251 /* Return true if symbol is defined in a regular object file. */
6252
6253 static bfd_boolean
6254 is_static_defined (struct elf_link_hash_entry *h)
6255 {
6256 return ((h->root.type == bfd_link_hash_defined
6257 || h->root.type == bfd_link_hash_defweak)
6258 && h->root.u.def.section != NULL
6259 && h->root.u.def.section->output_section != NULL);
6260 }
6261
6262 /* If FDH is a function descriptor symbol, return the associated code
6263 entry symbol if it is defined. Return NULL otherwise. */
6264
6265 static struct ppc_link_hash_entry *
6266 defined_code_entry (struct ppc_link_hash_entry *fdh)
6267 {
6268 if (fdh->is_func_descriptor)
6269 {
6270 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6271 if (fh->elf.root.type == bfd_link_hash_defined
6272 || fh->elf.root.type == bfd_link_hash_defweak)
6273 return fh;
6274 }
6275 return NULL;
6276 }
6277
6278 /* If FH is a function code entry symbol, return the associated
6279 function descriptor symbol if it is defined. Return NULL otherwise. */
6280
6281 static struct ppc_link_hash_entry *
6282 defined_func_desc (struct ppc_link_hash_entry *fh)
6283 {
6284 if (fh->oh != NULL
6285 && fh->oh->is_func_descriptor)
6286 {
6287 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6288 if (fdh->elf.root.type == bfd_link_hash_defined
6289 || fdh->elf.root.type == bfd_link_hash_defweak)
6290 return fdh;
6291 }
6292 return NULL;
6293 }
6294
6295 /* Mark all our entry sym sections, both opd and code section. */
6296
6297 static void
6298 ppc64_elf_gc_keep (struct bfd_link_info *info)
6299 {
6300 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6301 struct bfd_sym_chain *sym;
6302
6303 if (htab == NULL)
6304 return;
6305
6306 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6307 {
6308 struct ppc_link_hash_entry *eh, *fh;
6309 asection *sec;
6310
6311 eh = (struct ppc_link_hash_entry *)
6312 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6313 if (eh == NULL)
6314 continue;
6315 if (eh->elf.root.type != bfd_link_hash_defined
6316 && eh->elf.root.type != bfd_link_hash_defweak)
6317 continue;
6318
6319 fh = defined_code_entry (eh);
6320 if (fh != NULL)
6321 {
6322 sec = fh->elf.root.u.def.section;
6323 sec->flags |= SEC_KEEP;
6324 }
6325 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6326 && opd_entry_value (eh->elf.root.u.def.section,
6327 eh->elf.root.u.def.value,
6328 &sec, NULL, FALSE) != (bfd_vma) -1)
6329 sec->flags |= SEC_KEEP;
6330
6331 sec = eh->elf.root.u.def.section;
6332 sec->flags |= SEC_KEEP;
6333 }
6334 }
6335
6336 /* Mark sections containing dynamically referenced symbols. When
6337 building shared libraries, we must assume that any visible symbol is
6338 referenced. */
6339
6340 static bfd_boolean
6341 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6342 {
6343 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6344 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6345 struct ppc_link_hash_entry *fdh;
6346 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6347
6348 /* Dynamic linking info is on the func descriptor sym. */
6349 fdh = defined_func_desc (eh);
6350 if (fdh != NULL)
6351 eh = fdh;
6352
6353 if ((eh->elf.root.type == bfd_link_hash_defined
6354 || eh->elf.root.type == bfd_link_hash_defweak)
6355 && (eh->elf.ref_dynamic
6356 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6357 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6358 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6359 && (!bfd_link_executable (info)
6360 || info->export_dynamic
6361 || (eh->elf.dynamic
6362 && d != NULL
6363 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6364 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6365 || !bfd_hide_sym_by_version (info->version_info,
6366 eh->elf.root.root.string)))))
6367 {
6368 asection *code_sec;
6369 struct ppc_link_hash_entry *fh;
6370
6371 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6372
6373 /* Function descriptor syms cause the associated
6374 function code sym section to be marked. */
6375 fh = defined_code_entry (eh);
6376 if (fh != NULL)
6377 {
6378 code_sec = fh->elf.root.u.def.section;
6379 code_sec->flags |= SEC_KEEP;
6380 }
6381 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6382 && opd_entry_value (eh->elf.root.u.def.section,
6383 eh->elf.root.u.def.value,
6384 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6385 code_sec->flags |= SEC_KEEP;
6386 }
6387
6388 return TRUE;
6389 }
6390
6391 /* Return the section that should be marked against GC for a given
6392 relocation. */
6393
6394 static asection *
6395 ppc64_elf_gc_mark_hook (asection *sec,
6396 struct bfd_link_info *info,
6397 Elf_Internal_Rela *rel,
6398 struct elf_link_hash_entry *h,
6399 Elf_Internal_Sym *sym)
6400 {
6401 asection *rsec;
6402
6403 /* Syms return NULL if we're marking .opd, so we avoid marking all
6404 function sections, as all functions are referenced in .opd. */
6405 rsec = NULL;
6406 if (get_opd_info (sec) != NULL)
6407 return rsec;
6408
6409 if (h != NULL)
6410 {
6411 enum elf_ppc64_reloc_type r_type;
6412 struct ppc_link_hash_entry *eh, *fh, *fdh;
6413
6414 r_type = ELF64_R_TYPE (rel->r_info);
6415 switch (r_type)
6416 {
6417 case R_PPC64_GNU_VTINHERIT:
6418 case R_PPC64_GNU_VTENTRY:
6419 break;
6420
6421 default:
6422 switch (h->root.type)
6423 {
6424 case bfd_link_hash_defined:
6425 case bfd_link_hash_defweak:
6426 eh = (struct ppc_link_hash_entry *) h;
6427 fdh = defined_func_desc (eh);
6428 if (fdh != NULL)
6429 eh = fdh;
6430
6431 /* Function descriptor syms cause the associated
6432 function code sym section to be marked. */
6433 fh = defined_code_entry (eh);
6434 if (fh != NULL)
6435 {
6436 /* They also mark their opd section. */
6437 eh->elf.root.u.def.section->gc_mark = 1;
6438
6439 rsec = fh->elf.root.u.def.section;
6440 }
6441 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6442 && opd_entry_value (eh->elf.root.u.def.section,
6443 eh->elf.root.u.def.value,
6444 &rsec, NULL, FALSE) != (bfd_vma) -1)
6445 eh->elf.root.u.def.section->gc_mark = 1;
6446 else
6447 rsec = h->root.u.def.section;
6448 break;
6449
6450 case bfd_link_hash_common:
6451 rsec = h->root.u.c.p->section;
6452 break;
6453
6454 default:
6455 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6456 }
6457 }
6458 }
6459 else
6460 {
6461 struct _opd_sec_data *opd;
6462
6463 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6464 opd = get_opd_info (rsec);
6465 if (opd != NULL && opd->func_sec != NULL)
6466 {
6467 rsec->gc_mark = 1;
6468
6469 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6470 }
6471 }
6472
6473 return rsec;
6474 }
6475
6476 /* Update the .got, .plt. and dynamic reloc reference counts for the
6477 section being removed. */
6478
6479 static bfd_boolean
6480 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6481 asection *sec, const Elf_Internal_Rela *relocs)
6482 {
6483 struct ppc_link_hash_table *htab;
6484 Elf_Internal_Shdr *symtab_hdr;
6485 struct elf_link_hash_entry **sym_hashes;
6486 struct got_entry **local_got_ents;
6487 const Elf_Internal_Rela *rel, *relend;
6488
6489 if (bfd_link_relocatable (info))
6490 return TRUE;
6491
6492 if ((sec->flags & SEC_ALLOC) == 0)
6493 return TRUE;
6494
6495 elf_section_data (sec)->local_dynrel = NULL;
6496
6497 htab = ppc_hash_table (info);
6498 if (htab == NULL)
6499 return FALSE;
6500
6501 symtab_hdr = &elf_symtab_hdr (abfd);
6502 sym_hashes = elf_sym_hashes (abfd);
6503 local_got_ents = elf_local_got_ents (abfd);
6504
6505 relend = relocs + sec->reloc_count;
6506 for (rel = relocs; rel < relend; rel++)
6507 {
6508 unsigned long r_symndx;
6509 enum elf_ppc64_reloc_type r_type;
6510 struct elf_link_hash_entry *h = NULL;
6511 struct plt_entry **plt_list;
6512 unsigned char tls_type = 0;
6513
6514 r_symndx = ELF64_R_SYM (rel->r_info);
6515 r_type = ELF64_R_TYPE (rel->r_info);
6516 if (r_symndx >= symtab_hdr->sh_info)
6517 {
6518 struct ppc_link_hash_entry *eh;
6519 struct elf_dyn_relocs **pp;
6520 struct elf_dyn_relocs *p;
6521
6522 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6523 h = elf_follow_link (h);
6524 eh = (struct ppc_link_hash_entry *) h;
6525
6526 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6527 if (p->sec == sec)
6528 {
6529 /* Everything must go for SEC. */
6530 *pp = p->next;
6531 break;
6532 }
6533 }
6534
6535 switch (r_type)
6536 {
6537 case R_PPC64_GOT_TLSLD16:
6538 case R_PPC64_GOT_TLSLD16_LO:
6539 case R_PPC64_GOT_TLSLD16_HI:
6540 case R_PPC64_GOT_TLSLD16_HA:
6541 tls_type = TLS_TLS | TLS_LD;
6542 goto dogot;
6543
6544 case R_PPC64_GOT_TLSGD16:
6545 case R_PPC64_GOT_TLSGD16_LO:
6546 case R_PPC64_GOT_TLSGD16_HI:
6547 case R_PPC64_GOT_TLSGD16_HA:
6548 tls_type = TLS_TLS | TLS_GD;
6549 goto dogot;
6550
6551 case R_PPC64_GOT_TPREL16_DS:
6552 case R_PPC64_GOT_TPREL16_LO_DS:
6553 case R_PPC64_GOT_TPREL16_HI:
6554 case R_PPC64_GOT_TPREL16_HA:
6555 tls_type = TLS_TLS | TLS_TPREL;
6556 goto dogot;
6557
6558 case R_PPC64_GOT_DTPREL16_DS:
6559 case R_PPC64_GOT_DTPREL16_LO_DS:
6560 case R_PPC64_GOT_DTPREL16_HI:
6561 case R_PPC64_GOT_DTPREL16_HA:
6562 tls_type = TLS_TLS | TLS_DTPREL;
6563 goto dogot;
6564
6565 case R_PPC64_GOT16:
6566 case R_PPC64_GOT16_DS:
6567 case R_PPC64_GOT16_HA:
6568 case R_PPC64_GOT16_HI:
6569 case R_PPC64_GOT16_LO:
6570 case R_PPC64_GOT16_LO_DS:
6571 dogot:
6572 {
6573 struct got_entry *ent;
6574
6575 if (h != NULL)
6576 ent = h->got.glist;
6577 else
6578 ent = local_got_ents[r_symndx];
6579
6580 for (; ent != NULL; ent = ent->next)
6581 if (ent->addend == rel->r_addend
6582 && ent->owner == abfd
6583 && ent->tls_type == tls_type)
6584 break;
6585 if (ent == NULL)
6586 abort ();
6587 if (ent->got.refcount > 0)
6588 ent->got.refcount -= 1;
6589 }
6590 break;
6591
6592 case R_PPC64_PLT16_HA:
6593 case R_PPC64_PLT16_HI:
6594 case R_PPC64_PLT16_LO:
6595 case R_PPC64_PLT32:
6596 case R_PPC64_PLT64:
6597 case R_PPC64_REL14:
6598 case R_PPC64_REL14_BRNTAKEN:
6599 case R_PPC64_REL14_BRTAKEN:
6600 case R_PPC64_REL24:
6601 plt_list = NULL;
6602 if (h != NULL)
6603 plt_list = &h->plt.plist;
6604 else if (local_got_ents != NULL)
6605 {
6606 struct plt_entry **local_plt = (struct plt_entry **)
6607 (local_got_ents + symtab_hdr->sh_info);
6608 unsigned char *local_got_tls_masks = (unsigned char *)
6609 (local_plt + symtab_hdr->sh_info);
6610 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6611 plt_list = local_plt + r_symndx;
6612 }
6613 if (plt_list)
6614 {
6615 struct plt_entry *ent;
6616
6617 for (ent = *plt_list; ent != NULL; ent = ent->next)
6618 if (ent->addend == rel->r_addend)
6619 break;
6620 if (ent != NULL && ent->plt.refcount > 0)
6621 ent->plt.refcount -= 1;
6622 }
6623 break;
6624
6625 default:
6626 break;
6627 }
6628 }
6629 return TRUE;
6630 }
6631
6632 /* The maximum size of .sfpr. */
6633 #define SFPR_MAX (218*4)
6634
6635 struct sfpr_def_parms
6636 {
6637 const char name[12];
6638 unsigned char lo, hi;
6639 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6640 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6641 };
6642
6643 /* Auto-generate _save*, _rest* functions in .sfpr.
6644 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6645 instead. */
6646
6647 static bfd_boolean
6648 sfpr_define (struct bfd_link_info *info,
6649 const struct sfpr_def_parms *parm,
6650 asection *stub_sec)
6651 {
6652 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6653 unsigned int i;
6654 size_t len = strlen (parm->name);
6655 bfd_boolean writing = FALSE;
6656 char sym[16];
6657
6658 if (htab == NULL)
6659 return FALSE;
6660
6661 memcpy (sym, parm->name, len);
6662 sym[len + 2] = 0;
6663
6664 for (i = parm->lo; i <= parm->hi; i++)
6665 {
6666 struct ppc_link_hash_entry *h;
6667
6668 sym[len + 0] = i / 10 + '0';
6669 sym[len + 1] = i % 10 + '0';
6670 h = (struct ppc_link_hash_entry *)
6671 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6672 if (stub_sec != NULL)
6673 {
6674 if (h != NULL
6675 && h->elf.root.type == bfd_link_hash_defined
6676 && h->elf.root.u.def.section == htab->sfpr)
6677 {
6678 struct elf_link_hash_entry *s;
6679 char buf[32];
6680 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6681 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6682 if (s == NULL)
6683 return FALSE;
6684 if (s->root.type == bfd_link_hash_new
6685 || (s->root.type = bfd_link_hash_defined
6686 && s->root.u.def.section == stub_sec))
6687 {
6688 s->root.type = bfd_link_hash_defined;
6689 s->root.u.def.section = stub_sec;
6690 s->root.u.def.value = (stub_sec->size
6691 + h->elf.root.u.def.value);
6692 s->ref_regular = 1;
6693 s->def_regular = 1;
6694 s->ref_regular_nonweak = 1;
6695 s->forced_local = 1;
6696 s->non_elf = 0;
6697 s->root.linker_def = 1;
6698 }
6699 }
6700 continue;
6701 }
6702 if (h != NULL)
6703 {
6704 h->save_res = 1;
6705 if (!h->elf.def_regular)
6706 {
6707 h->elf.root.type = bfd_link_hash_defined;
6708 h->elf.root.u.def.section = htab->sfpr;
6709 h->elf.root.u.def.value = htab->sfpr->size;
6710 h->elf.type = STT_FUNC;
6711 h->elf.def_regular = 1;
6712 h->elf.non_elf = 0;
6713 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6714 writing = TRUE;
6715 if (htab->sfpr->contents == NULL)
6716 {
6717 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6718 if (htab->sfpr->contents == NULL)
6719 return FALSE;
6720 }
6721 }
6722 }
6723 if (writing)
6724 {
6725 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6726 if (i != parm->hi)
6727 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6728 else
6729 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6730 htab->sfpr->size = p - htab->sfpr->contents;
6731 }
6732 }
6733
6734 return TRUE;
6735 }
6736
6737 static bfd_byte *
6738 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6739 {
6740 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6741 return p + 4;
6742 }
6743
6744 static bfd_byte *
6745 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6746 {
6747 p = savegpr0 (abfd, p, r);
6748 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6749 p = p + 4;
6750 bfd_put_32 (abfd, BLR, p);
6751 return p + 4;
6752 }
6753
6754 static bfd_byte *
6755 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6756 {
6757 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6758 return p + 4;
6759 }
6760
6761 static bfd_byte *
6762 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6763 {
6764 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6765 p = p + 4;
6766 p = restgpr0 (abfd, p, r);
6767 bfd_put_32 (abfd, MTLR_R0, p);
6768 p = p + 4;
6769 if (r == 29)
6770 {
6771 p = restgpr0 (abfd, p, 30);
6772 p = restgpr0 (abfd, p, 31);
6773 }
6774 bfd_put_32 (abfd, BLR, p);
6775 return p + 4;
6776 }
6777
6778 static bfd_byte *
6779 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6780 {
6781 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6782 return p + 4;
6783 }
6784
6785 static bfd_byte *
6786 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6787 {
6788 p = savegpr1 (abfd, p, r);
6789 bfd_put_32 (abfd, BLR, p);
6790 return p + 4;
6791 }
6792
6793 static bfd_byte *
6794 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6795 {
6796 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6797 return p + 4;
6798 }
6799
6800 static bfd_byte *
6801 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6802 {
6803 p = restgpr1 (abfd, p, r);
6804 bfd_put_32 (abfd, BLR, p);
6805 return p + 4;
6806 }
6807
6808 static bfd_byte *
6809 savefpr (bfd *abfd, bfd_byte *p, int r)
6810 {
6811 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6812 return p + 4;
6813 }
6814
6815 static bfd_byte *
6816 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6817 {
6818 p = savefpr (abfd, p, r);
6819 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6820 p = p + 4;
6821 bfd_put_32 (abfd, BLR, p);
6822 return p + 4;
6823 }
6824
6825 static bfd_byte *
6826 restfpr (bfd *abfd, bfd_byte *p, int r)
6827 {
6828 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6829 return p + 4;
6830 }
6831
6832 static bfd_byte *
6833 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6834 {
6835 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6836 p = p + 4;
6837 p = restfpr (abfd, p, r);
6838 bfd_put_32 (abfd, MTLR_R0, p);
6839 p = p + 4;
6840 if (r == 29)
6841 {
6842 p = restfpr (abfd, p, 30);
6843 p = restfpr (abfd, p, 31);
6844 }
6845 bfd_put_32 (abfd, BLR, p);
6846 return p + 4;
6847 }
6848
6849 static bfd_byte *
6850 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6851 {
6852 p = savefpr (abfd, p, r);
6853 bfd_put_32 (abfd, BLR, p);
6854 return p + 4;
6855 }
6856
6857 static bfd_byte *
6858 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6859 {
6860 p = restfpr (abfd, p, r);
6861 bfd_put_32 (abfd, BLR, p);
6862 return p + 4;
6863 }
6864
6865 static bfd_byte *
6866 savevr (bfd *abfd, bfd_byte *p, int r)
6867 {
6868 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6869 p = p + 4;
6870 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6871 return p + 4;
6872 }
6873
6874 static bfd_byte *
6875 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6876 {
6877 p = savevr (abfd, p, r);
6878 bfd_put_32 (abfd, BLR, p);
6879 return p + 4;
6880 }
6881
6882 static bfd_byte *
6883 restvr (bfd *abfd, bfd_byte *p, int r)
6884 {
6885 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6886 p = p + 4;
6887 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6888 return p + 4;
6889 }
6890
6891 static bfd_byte *
6892 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6893 {
6894 p = restvr (abfd, p, r);
6895 bfd_put_32 (abfd, BLR, p);
6896 return p + 4;
6897 }
6898
6899 /* Called via elf_link_hash_traverse to transfer dynamic linking
6900 information on function code symbol entries to their corresponding
6901 function descriptor symbol entries. */
6902
6903 static bfd_boolean
6904 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6905 {
6906 struct bfd_link_info *info;
6907 struct ppc_link_hash_table *htab;
6908 struct plt_entry *ent;
6909 struct ppc_link_hash_entry *fh;
6910 struct ppc_link_hash_entry *fdh;
6911 bfd_boolean force_local;
6912
6913 fh = (struct ppc_link_hash_entry *) h;
6914 if (fh->elf.root.type == bfd_link_hash_indirect)
6915 return TRUE;
6916
6917 info = inf;
6918 htab = ppc_hash_table (info);
6919 if (htab == NULL)
6920 return FALSE;
6921
6922 /* Resolve undefined references to dot-symbols as the value
6923 in the function descriptor, if we have one in a regular object.
6924 This is to satisfy cases like ".quad .foo". Calls to functions
6925 in dynamic objects are handled elsewhere. */
6926 if (fh->elf.root.type == bfd_link_hash_undefweak
6927 && fh->was_undefined
6928 && (fdh = defined_func_desc (fh)) != NULL
6929 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6930 && opd_entry_value (fdh->elf.root.u.def.section,
6931 fdh->elf.root.u.def.value,
6932 &fh->elf.root.u.def.section,
6933 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6934 {
6935 fh->elf.root.type = fdh->elf.root.type;
6936 fh->elf.forced_local = 1;
6937 fh->elf.def_regular = fdh->elf.def_regular;
6938 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6939 }
6940
6941 /* If this is a function code symbol, transfer dynamic linking
6942 information to the function descriptor symbol. */
6943 if (!fh->is_func)
6944 return TRUE;
6945
6946 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6947 if (ent->plt.refcount > 0)
6948 break;
6949 if (ent == NULL
6950 || fh->elf.root.root.string[0] != '.'
6951 || fh->elf.root.root.string[1] == '\0')
6952 return TRUE;
6953
6954 /* Find the corresponding function descriptor symbol. Create it
6955 as undefined if necessary. */
6956
6957 fdh = lookup_fdh (fh, htab);
6958 if (fdh == NULL
6959 && !bfd_link_executable (info)
6960 && (fh->elf.root.type == bfd_link_hash_undefined
6961 || fh->elf.root.type == bfd_link_hash_undefweak))
6962 {
6963 fdh = make_fdh (info, fh);
6964 if (fdh == NULL)
6965 return FALSE;
6966 }
6967
6968 /* Fake function descriptors are made undefweak. If the function
6969 code symbol is strong undefined, make the fake sym the same.
6970 If the function code symbol is defined, then force the fake
6971 descriptor local; We can't support overriding of symbols in a
6972 shared library on a fake descriptor. */
6973
6974 if (fdh != NULL
6975 && fdh->fake
6976 && fdh->elf.root.type == bfd_link_hash_undefweak)
6977 {
6978 if (fh->elf.root.type == bfd_link_hash_undefined)
6979 {
6980 fdh->elf.root.type = bfd_link_hash_undefined;
6981 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6982 }
6983 else if (fh->elf.root.type == bfd_link_hash_defined
6984 || fh->elf.root.type == bfd_link_hash_defweak)
6985 {
6986 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6987 }
6988 }
6989
6990 if (fdh != NULL
6991 && !fdh->elf.forced_local
6992 && (!bfd_link_executable (info)
6993 || fdh->elf.def_dynamic
6994 || fdh->elf.ref_dynamic
6995 || (fdh->elf.root.type == bfd_link_hash_undefweak
6996 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6997 {
6998 if (fdh->elf.dynindx == -1)
6999 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7000 return FALSE;
7001 fdh->elf.ref_regular |= fh->elf.ref_regular;
7002 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7003 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7004 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7005 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7006 {
7007 move_plt_plist (fh, fdh);
7008 fdh->elf.needs_plt = 1;
7009 }
7010 fdh->is_func_descriptor = 1;
7011 fdh->oh = fh;
7012 fh->oh = fdh;
7013 }
7014
7015 /* Now that the info is on the function descriptor, clear the
7016 function code sym info. Any function code syms for which we
7017 don't have a definition in a regular file, we force local.
7018 This prevents a shared library from exporting syms that have
7019 been imported from another library. Function code syms that
7020 are really in the library we must leave global to prevent the
7021 linker dragging in a definition from a static library. */
7022 force_local = (!fh->elf.def_regular
7023 || fdh == NULL
7024 || !fdh->elf.def_regular
7025 || fdh->elf.forced_local);
7026 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7027
7028 return TRUE;
7029 }
7030
7031 static const struct sfpr_def_parms save_res_funcs[] =
7032 {
7033 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7034 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7035 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7036 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7037 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7038 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7039 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7040 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7041 { "._savef", 14, 31, savefpr, savefpr1_tail },
7042 { "._restf", 14, 31, restfpr, restfpr1_tail },
7043 { "_savevr_", 20, 31, savevr, savevr_tail },
7044 { "_restvr_", 20, 31, restvr, restvr_tail }
7045 };
7046
7047 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7048 this hook to a) provide some gcc support functions, and b) transfer
7049 dynamic linking information gathered so far on function code symbol
7050 entries, to their corresponding function descriptor symbol entries. */
7051
7052 static bfd_boolean
7053 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7054 struct bfd_link_info *info)
7055 {
7056 struct ppc_link_hash_table *htab;
7057
7058 htab = ppc_hash_table (info);
7059 if (htab == NULL)
7060 return FALSE;
7061
7062 /* Provide any missing _save* and _rest* functions. */
7063 if (htab->sfpr != NULL)
7064 {
7065 unsigned int i;
7066
7067 htab->sfpr->size = 0;
7068 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7069 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7070 return FALSE;
7071 if (htab->sfpr->size == 0)
7072 htab->sfpr->flags |= SEC_EXCLUDE;
7073 }
7074
7075 if (bfd_link_relocatable (info))
7076 return TRUE;
7077
7078 if (htab->elf.hgot != NULL)
7079 {
7080 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7081 /* Make .TOC. defined so as to prevent it being made dynamic.
7082 The wrong value here is fixed later in ppc64_elf_set_toc. */
7083 if (!htab->elf.hgot->def_regular
7084 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7085 {
7086 htab->elf.hgot->root.type = bfd_link_hash_defined;
7087 htab->elf.hgot->root.u.def.value = 0;
7088 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7089 htab->elf.hgot->def_regular = 1;
7090 htab->elf.hgot->root.linker_def = 1;
7091 }
7092 htab->elf.hgot->type = STT_OBJECT;
7093 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7094 | STV_HIDDEN);
7095 }
7096
7097 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7098
7099 return TRUE;
7100 }
7101
7102 /* Return true if we have dynamic relocs that apply to read-only sections. */
7103
7104 static bfd_boolean
7105 readonly_dynrelocs (struct elf_link_hash_entry *h)
7106 {
7107 struct ppc_link_hash_entry *eh;
7108 struct elf_dyn_relocs *p;
7109
7110 eh = (struct ppc_link_hash_entry *) h;
7111 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7112 {
7113 asection *s = p->sec->output_section;
7114
7115 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7116 return TRUE;
7117 }
7118 return FALSE;
7119 }
7120
7121 /* Adjust a symbol defined by a dynamic object and referenced by a
7122 regular object. The current definition is in some section of the
7123 dynamic object, but we're not including those sections. We have to
7124 change the definition to something the rest of the link can
7125 understand. */
7126
7127 static bfd_boolean
7128 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7129 struct elf_link_hash_entry *h)
7130 {
7131 struct ppc_link_hash_table *htab;
7132 asection *s;
7133
7134 htab = ppc_hash_table (info);
7135 if (htab == NULL)
7136 return FALSE;
7137
7138 /* Deal with function syms. */
7139 if (h->type == STT_FUNC
7140 || h->type == STT_GNU_IFUNC
7141 || h->needs_plt)
7142 {
7143 /* Clear procedure linkage table information for any symbol that
7144 won't need a .plt entry. */
7145 struct plt_entry *ent;
7146 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7147 if (ent->plt.refcount > 0)
7148 break;
7149 if (ent == NULL
7150 || (h->type != STT_GNU_IFUNC
7151 && (SYMBOL_CALLS_LOCAL (info, h)
7152 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7153 && h->root.type == bfd_link_hash_undefweak)))
7154 || ((struct ppc_link_hash_entry *) h)->save_res)
7155 {
7156 h->plt.plist = NULL;
7157 h->needs_plt = 0;
7158 h->pointer_equality_needed = 0;
7159 }
7160 else if (abiversion (info->output_bfd) == 2)
7161 {
7162 /* Taking a function's address in a read/write section
7163 doesn't require us to define the function symbol in the
7164 executable on a global entry stub. A dynamic reloc can
7165 be used instead. */
7166 if (h->pointer_equality_needed
7167 && h->type != STT_GNU_IFUNC
7168 && !readonly_dynrelocs (h))
7169 {
7170 h->pointer_equality_needed = 0;
7171 h->non_got_ref = 0;
7172 }
7173
7174 /* After adjust_dynamic_symbol, non_got_ref set in the
7175 non-shared case means that we have allocated space in
7176 .dynbss for the symbol and thus dyn_relocs for this
7177 symbol should be discarded.
7178 If we get here we know we are making a PLT entry for this
7179 symbol, and in an executable we'd normally resolve
7180 relocations against this symbol to the PLT entry. Allow
7181 dynamic relocs if the reference is weak, and the dynamic
7182 relocs will not cause text relocation. */
7183 else if (!h->ref_regular_nonweak
7184 && h->non_got_ref
7185 && h->type != STT_GNU_IFUNC
7186 && !readonly_dynrelocs (h))
7187 h->non_got_ref = 0;
7188
7189 /* If making a plt entry, then we don't need copy relocs. */
7190 return TRUE;
7191 }
7192 }
7193 else
7194 h->plt.plist = NULL;
7195
7196 /* If this is a weak symbol, and there is a real definition, the
7197 processor independent code will have arranged for us to see the
7198 real definition first, and we can just use the same value. */
7199 if (h->u.weakdef != NULL)
7200 {
7201 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7202 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7203 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7204 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7205 if (ELIMINATE_COPY_RELOCS)
7206 h->non_got_ref = h->u.weakdef->non_got_ref;
7207 return TRUE;
7208 }
7209
7210 /* If we are creating a shared library, we must presume that the
7211 only references to the symbol are via the global offset table.
7212 For such cases we need not do anything here; the relocations will
7213 be handled correctly by relocate_section. */
7214 if (bfd_link_pic (info))
7215 return TRUE;
7216
7217 /* If there are no references to this symbol that do not use the
7218 GOT, we don't need to generate a copy reloc. */
7219 if (!h->non_got_ref)
7220 return TRUE;
7221
7222 /* Don't generate a copy reloc for symbols defined in the executable. */
7223 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7224 return TRUE;
7225
7226 /* If -z nocopyreloc was given, don't generate them either. */
7227 if (info->nocopyreloc)
7228 {
7229 h->non_got_ref = 0;
7230 return TRUE;
7231 }
7232
7233 /* If we didn't find any dynamic relocs in read-only sections, then
7234 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7235 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7236 {
7237 h->non_got_ref = 0;
7238 return TRUE;
7239 }
7240
7241 /* Protected variables do not work with .dynbss. The copy in
7242 .dynbss won't be used by the shared library with the protected
7243 definition for the variable. Text relocations are preferable
7244 to an incorrect program. */
7245 if (h->protected_def)
7246 {
7247 h->non_got_ref = 0;
7248 return TRUE;
7249 }
7250
7251 if (h->plt.plist != NULL)
7252 {
7253 /* We should never get here, but unfortunately there are versions
7254 of gcc out there that improperly (for this ABI) put initialized
7255 function pointers, vtable refs and suchlike in read-only
7256 sections. Allow them to proceed, but warn that this might
7257 break at runtime. */
7258 info->callbacks->einfo
7259 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7260 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7261 h->root.root.string);
7262 }
7263
7264 /* This is a reference to a symbol defined by a dynamic object which
7265 is not a function. */
7266
7267 /* We must allocate the symbol in our .dynbss section, which will
7268 become part of the .bss section of the executable. There will be
7269 an entry for this symbol in the .dynsym section. The dynamic
7270 object will contain position independent code, so all references
7271 from the dynamic object to this symbol will go through the global
7272 offset table. The dynamic linker will use the .dynsym entry to
7273 determine the address it must put in the global offset table, so
7274 both the dynamic object and the regular object will refer to the
7275 same memory location for the variable. */
7276
7277 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7278 to copy the initial value out of the dynamic object and into the
7279 runtime process image. We need to remember the offset into the
7280 .rela.bss section we are going to use. */
7281 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7282 {
7283 htab->relbss->size += sizeof (Elf64_External_Rela);
7284 h->needs_copy = 1;
7285 }
7286
7287 s = htab->dynbss;
7288
7289 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7290 }
7291
7292 /* If given a function descriptor symbol, hide both the function code
7293 sym and the descriptor. */
7294 static void
7295 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7296 struct elf_link_hash_entry *h,
7297 bfd_boolean force_local)
7298 {
7299 struct ppc_link_hash_entry *eh;
7300 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7301
7302 eh = (struct ppc_link_hash_entry *) h;
7303 if (eh->is_func_descriptor)
7304 {
7305 struct ppc_link_hash_entry *fh = eh->oh;
7306
7307 if (fh == NULL)
7308 {
7309 const char *p, *q;
7310 struct ppc_link_hash_table *htab;
7311 char save;
7312
7313 /* We aren't supposed to use alloca in BFD because on
7314 systems which do not have alloca the version in libiberty
7315 calls xmalloc, which might cause the program to crash
7316 when it runs out of memory. This function doesn't have a
7317 return status, so there's no way to gracefully return an
7318 error. So cheat. We know that string[-1] can be safely
7319 accessed; It's either a string in an ELF string table,
7320 or allocated in an objalloc structure. */
7321
7322 p = eh->elf.root.root.string - 1;
7323 save = *p;
7324 *(char *) p = '.';
7325 htab = ppc_hash_table (info);
7326 if (htab == NULL)
7327 return;
7328
7329 fh = (struct ppc_link_hash_entry *)
7330 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7331 *(char *) p = save;
7332
7333 /* Unfortunately, if it so happens that the string we were
7334 looking for was allocated immediately before this string,
7335 then we overwrote the string terminator. That's the only
7336 reason the lookup should fail. */
7337 if (fh == NULL)
7338 {
7339 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7340 while (q >= eh->elf.root.root.string && *q == *p)
7341 --q, --p;
7342 if (q < eh->elf.root.root.string && *p == '.')
7343 fh = (struct ppc_link_hash_entry *)
7344 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7345 }
7346 if (fh != NULL)
7347 {
7348 eh->oh = fh;
7349 fh->oh = eh;
7350 }
7351 }
7352 if (fh != NULL)
7353 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7354 }
7355 }
7356
7357 static bfd_boolean
7358 get_sym_h (struct elf_link_hash_entry **hp,
7359 Elf_Internal_Sym **symp,
7360 asection **symsecp,
7361 unsigned char **tls_maskp,
7362 Elf_Internal_Sym **locsymsp,
7363 unsigned long r_symndx,
7364 bfd *ibfd)
7365 {
7366 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7367
7368 if (r_symndx >= symtab_hdr->sh_info)
7369 {
7370 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7371 struct elf_link_hash_entry *h;
7372
7373 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7374 h = elf_follow_link (h);
7375
7376 if (hp != NULL)
7377 *hp = h;
7378
7379 if (symp != NULL)
7380 *symp = NULL;
7381
7382 if (symsecp != NULL)
7383 {
7384 asection *symsec = NULL;
7385 if (h->root.type == bfd_link_hash_defined
7386 || h->root.type == bfd_link_hash_defweak)
7387 symsec = h->root.u.def.section;
7388 *symsecp = symsec;
7389 }
7390
7391 if (tls_maskp != NULL)
7392 {
7393 struct ppc_link_hash_entry *eh;
7394
7395 eh = (struct ppc_link_hash_entry *) h;
7396 *tls_maskp = &eh->tls_mask;
7397 }
7398 }
7399 else
7400 {
7401 Elf_Internal_Sym *sym;
7402 Elf_Internal_Sym *locsyms = *locsymsp;
7403
7404 if (locsyms == NULL)
7405 {
7406 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7407 if (locsyms == NULL)
7408 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7409 symtab_hdr->sh_info,
7410 0, NULL, NULL, NULL);
7411 if (locsyms == NULL)
7412 return FALSE;
7413 *locsymsp = locsyms;
7414 }
7415 sym = locsyms + r_symndx;
7416
7417 if (hp != NULL)
7418 *hp = NULL;
7419
7420 if (symp != NULL)
7421 *symp = sym;
7422
7423 if (symsecp != NULL)
7424 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7425
7426 if (tls_maskp != NULL)
7427 {
7428 struct got_entry **lgot_ents;
7429 unsigned char *tls_mask;
7430
7431 tls_mask = NULL;
7432 lgot_ents = elf_local_got_ents (ibfd);
7433 if (lgot_ents != NULL)
7434 {
7435 struct plt_entry **local_plt = (struct plt_entry **)
7436 (lgot_ents + symtab_hdr->sh_info);
7437 unsigned char *lgot_masks = (unsigned char *)
7438 (local_plt + symtab_hdr->sh_info);
7439 tls_mask = &lgot_masks[r_symndx];
7440 }
7441 *tls_maskp = tls_mask;
7442 }
7443 }
7444 return TRUE;
7445 }
7446
7447 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7448 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7449 type suitable for optimization, and 1 otherwise. */
7450
7451 static int
7452 get_tls_mask (unsigned char **tls_maskp,
7453 unsigned long *toc_symndx,
7454 bfd_vma *toc_addend,
7455 Elf_Internal_Sym **locsymsp,
7456 const Elf_Internal_Rela *rel,
7457 bfd *ibfd)
7458 {
7459 unsigned long r_symndx;
7460 int next_r;
7461 struct elf_link_hash_entry *h;
7462 Elf_Internal_Sym *sym;
7463 asection *sec;
7464 bfd_vma off;
7465
7466 r_symndx = ELF64_R_SYM (rel->r_info);
7467 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7468 return 0;
7469
7470 if ((*tls_maskp != NULL && **tls_maskp != 0)
7471 || sec == NULL
7472 || ppc64_elf_section_data (sec) == NULL
7473 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7474 return 1;
7475
7476 /* Look inside a TOC section too. */
7477 if (h != NULL)
7478 {
7479 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7480 off = h->root.u.def.value;
7481 }
7482 else
7483 off = sym->st_value;
7484 off += rel->r_addend;
7485 BFD_ASSERT (off % 8 == 0);
7486 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7487 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7488 if (toc_symndx != NULL)
7489 *toc_symndx = r_symndx;
7490 if (toc_addend != NULL)
7491 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7492 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7493 return 0;
7494 if ((h == NULL || is_static_defined (h))
7495 && (next_r == -1 || next_r == -2))
7496 return 1 - next_r;
7497 return 1;
7498 }
7499
7500 /* Find (or create) an entry in the tocsave hash table. */
7501
7502 static struct tocsave_entry *
7503 tocsave_find (struct ppc_link_hash_table *htab,
7504 enum insert_option insert,
7505 Elf_Internal_Sym **local_syms,
7506 const Elf_Internal_Rela *irela,
7507 bfd *ibfd)
7508 {
7509 unsigned long r_indx;
7510 struct elf_link_hash_entry *h;
7511 Elf_Internal_Sym *sym;
7512 struct tocsave_entry ent, *p;
7513 hashval_t hash;
7514 struct tocsave_entry **slot;
7515
7516 r_indx = ELF64_R_SYM (irela->r_info);
7517 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7518 return NULL;
7519 if (ent.sec == NULL || ent.sec->output_section == NULL)
7520 {
7521 (*_bfd_error_handler)
7522 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7523 return NULL;
7524 }
7525
7526 if (h != NULL)
7527 ent.offset = h->root.u.def.value;
7528 else
7529 ent.offset = sym->st_value;
7530 ent.offset += irela->r_addend;
7531
7532 hash = tocsave_htab_hash (&ent);
7533 slot = ((struct tocsave_entry **)
7534 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7535 if (slot == NULL)
7536 return NULL;
7537
7538 if (*slot == NULL)
7539 {
7540 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7541 if (p == NULL)
7542 return NULL;
7543 *p = ent;
7544 *slot = p;
7545 }
7546 return *slot;
7547 }
7548
7549 /* Adjust all global syms defined in opd sections. In gcc generated
7550 code for the old ABI, these will already have been done. */
7551
7552 static bfd_boolean
7553 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7554 {
7555 struct ppc_link_hash_entry *eh;
7556 asection *sym_sec;
7557 struct _opd_sec_data *opd;
7558
7559 if (h->root.type == bfd_link_hash_indirect)
7560 return TRUE;
7561
7562 if (h->root.type != bfd_link_hash_defined
7563 && h->root.type != bfd_link_hash_defweak)
7564 return TRUE;
7565
7566 eh = (struct ppc_link_hash_entry *) h;
7567 if (eh->adjust_done)
7568 return TRUE;
7569
7570 sym_sec = eh->elf.root.u.def.section;
7571 opd = get_opd_info (sym_sec);
7572 if (opd != NULL && opd->adjust != NULL)
7573 {
7574 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7575 if (adjust == -1)
7576 {
7577 /* This entry has been deleted. */
7578 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7579 if (dsec == NULL)
7580 {
7581 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7582 if (discarded_section (dsec))
7583 {
7584 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7585 break;
7586 }
7587 }
7588 eh->elf.root.u.def.value = 0;
7589 eh->elf.root.u.def.section = dsec;
7590 }
7591 else
7592 eh->elf.root.u.def.value += adjust;
7593 eh->adjust_done = 1;
7594 }
7595 return TRUE;
7596 }
7597
7598 /* Handles decrementing dynamic reloc counts for the reloc specified by
7599 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7600 have already been determined. */
7601
7602 static bfd_boolean
7603 dec_dynrel_count (bfd_vma r_info,
7604 asection *sec,
7605 struct bfd_link_info *info,
7606 Elf_Internal_Sym **local_syms,
7607 struct elf_link_hash_entry *h,
7608 Elf_Internal_Sym *sym)
7609 {
7610 enum elf_ppc64_reloc_type r_type;
7611 asection *sym_sec = NULL;
7612
7613 /* Can this reloc be dynamic? This switch, and later tests here
7614 should be kept in sync with the code in check_relocs. */
7615 r_type = ELF64_R_TYPE (r_info);
7616 switch (r_type)
7617 {
7618 default:
7619 return TRUE;
7620
7621 case R_PPC64_TPREL16:
7622 case R_PPC64_TPREL16_LO:
7623 case R_PPC64_TPREL16_HI:
7624 case R_PPC64_TPREL16_HA:
7625 case R_PPC64_TPREL16_DS:
7626 case R_PPC64_TPREL16_LO_DS:
7627 case R_PPC64_TPREL16_HIGH:
7628 case R_PPC64_TPREL16_HIGHA:
7629 case R_PPC64_TPREL16_HIGHER:
7630 case R_PPC64_TPREL16_HIGHERA:
7631 case R_PPC64_TPREL16_HIGHEST:
7632 case R_PPC64_TPREL16_HIGHESTA:
7633 if (!bfd_link_pic (info))
7634 return TRUE;
7635
7636 case R_PPC64_TPREL64:
7637 case R_PPC64_DTPMOD64:
7638 case R_PPC64_DTPREL64:
7639 case R_PPC64_ADDR64:
7640 case R_PPC64_REL30:
7641 case R_PPC64_REL32:
7642 case R_PPC64_REL64:
7643 case R_PPC64_ADDR14:
7644 case R_PPC64_ADDR14_BRNTAKEN:
7645 case R_PPC64_ADDR14_BRTAKEN:
7646 case R_PPC64_ADDR16:
7647 case R_PPC64_ADDR16_DS:
7648 case R_PPC64_ADDR16_HA:
7649 case R_PPC64_ADDR16_HI:
7650 case R_PPC64_ADDR16_HIGH:
7651 case R_PPC64_ADDR16_HIGHA:
7652 case R_PPC64_ADDR16_HIGHER:
7653 case R_PPC64_ADDR16_HIGHERA:
7654 case R_PPC64_ADDR16_HIGHEST:
7655 case R_PPC64_ADDR16_HIGHESTA:
7656 case R_PPC64_ADDR16_LO:
7657 case R_PPC64_ADDR16_LO_DS:
7658 case R_PPC64_ADDR24:
7659 case R_PPC64_ADDR32:
7660 case R_PPC64_UADDR16:
7661 case R_PPC64_UADDR32:
7662 case R_PPC64_UADDR64:
7663 case R_PPC64_TOC:
7664 break;
7665 }
7666
7667 if (local_syms != NULL)
7668 {
7669 unsigned long r_symndx;
7670 bfd *ibfd = sec->owner;
7671
7672 r_symndx = ELF64_R_SYM (r_info);
7673 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7674 return FALSE;
7675 }
7676
7677 if ((bfd_link_pic (info)
7678 && (must_be_dyn_reloc (info, r_type)
7679 || (h != NULL
7680 && (!SYMBOLIC_BIND (info, h)
7681 || h->root.type == bfd_link_hash_defweak
7682 || !h->def_regular))))
7683 || (ELIMINATE_COPY_RELOCS
7684 && !bfd_link_pic (info)
7685 && h != NULL
7686 && (h->root.type == bfd_link_hash_defweak
7687 || !h->def_regular)))
7688 ;
7689 else
7690 return TRUE;
7691
7692 if (h != NULL)
7693 {
7694 struct elf_dyn_relocs *p;
7695 struct elf_dyn_relocs **pp;
7696 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7697
7698 /* elf_gc_sweep may have already removed all dyn relocs associated
7699 with local syms for a given section. Also, symbol flags are
7700 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7701 report a dynreloc miscount. */
7702 if (*pp == NULL && info->gc_sections)
7703 return TRUE;
7704
7705 while ((p = *pp) != NULL)
7706 {
7707 if (p->sec == sec)
7708 {
7709 if (!must_be_dyn_reloc (info, r_type))
7710 p->pc_count -= 1;
7711 p->count -= 1;
7712 if (p->count == 0)
7713 *pp = p->next;
7714 return TRUE;
7715 }
7716 pp = &p->next;
7717 }
7718 }
7719 else
7720 {
7721 struct ppc_dyn_relocs *p;
7722 struct ppc_dyn_relocs **pp;
7723 void *vpp;
7724 bfd_boolean is_ifunc;
7725
7726 if (local_syms == NULL)
7727 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7728 if (sym_sec == NULL)
7729 sym_sec = sec;
7730
7731 vpp = &elf_section_data (sym_sec)->local_dynrel;
7732 pp = (struct ppc_dyn_relocs **) vpp;
7733
7734 if (*pp == NULL && info->gc_sections)
7735 return TRUE;
7736
7737 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7738 while ((p = *pp) != NULL)
7739 {
7740 if (p->sec == sec && p->ifunc == is_ifunc)
7741 {
7742 p->count -= 1;
7743 if (p->count == 0)
7744 *pp = p->next;
7745 return TRUE;
7746 }
7747 pp = &p->next;
7748 }
7749 }
7750
7751 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7752 sec->owner, sec);
7753 bfd_set_error (bfd_error_bad_value);
7754 return FALSE;
7755 }
7756
7757 /* Remove unused Official Procedure Descriptor entries. Currently we
7758 only remove those associated with functions in discarded link-once
7759 sections, or weakly defined functions that have been overridden. It
7760 would be possible to remove many more entries for statically linked
7761 applications. */
7762
7763 bfd_boolean
7764 ppc64_elf_edit_opd (struct bfd_link_info *info)
7765 {
7766 bfd *ibfd;
7767 bfd_boolean some_edited = FALSE;
7768 asection *need_pad = NULL;
7769 struct ppc_link_hash_table *htab;
7770
7771 htab = ppc_hash_table (info);
7772 if (htab == NULL)
7773 return FALSE;
7774
7775 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7776 {
7777 asection *sec;
7778 Elf_Internal_Rela *relstart, *rel, *relend;
7779 Elf_Internal_Shdr *symtab_hdr;
7780 Elf_Internal_Sym *local_syms;
7781 struct _opd_sec_data *opd;
7782 bfd_boolean need_edit, add_aux_fields, broken;
7783 bfd_size_type cnt_16b = 0;
7784
7785 if (!is_ppc64_elf (ibfd))
7786 continue;
7787
7788 sec = bfd_get_section_by_name (ibfd, ".opd");
7789 if (sec == NULL || sec->size == 0)
7790 continue;
7791
7792 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7793 continue;
7794
7795 if (sec->output_section == bfd_abs_section_ptr)
7796 continue;
7797
7798 /* Look through the section relocs. */
7799 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7800 continue;
7801
7802 local_syms = NULL;
7803 symtab_hdr = &elf_symtab_hdr (ibfd);
7804
7805 /* Read the relocations. */
7806 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7807 info->keep_memory);
7808 if (relstart == NULL)
7809 return FALSE;
7810
7811 /* First run through the relocs to check they are sane, and to
7812 determine whether we need to edit this opd section. */
7813 need_edit = FALSE;
7814 broken = FALSE;
7815 need_pad = sec;
7816 relend = relstart + sec->reloc_count;
7817 for (rel = relstart; rel < relend; )
7818 {
7819 enum elf_ppc64_reloc_type r_type;
7820 unsigned long r_symndx;
7821 asection *sym_sec;
7822 struct elf_link_hash_entry *h;
7823 Elf_Internal_Sym *sym;
7824 bfd_vma offset;
7825
7826 /* .opd contains an array of 16 or 24 byte entries. We're
7827 only interested in the reloc pointing to a function entry
7828 point. */
7829 offset = rel->r_offset;
7830 if (rel + 1 == relend
7831 || rel[1].r_offset != offset + 8)
7832 {
7833 /* If someone messes with .opd alignment then after a
7834 "ld -r" we might have padding in the middle of .opd.
7835 Also, there's nothing to prevent someone putting
7836 something silly in .opd with the assembler. No .opd
7837 optimization for them! */
7838 broken_opd:
7839 (*_bfd_error_handler)
7840 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7841 broken = TRUE;
7842 break;
7843 }
7844
7845 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7846 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7847 {
7848 (*_bfd_error_handler)
7849 (_("%B: unexpected reloc type %u in .opd section"),
7850 ibfd, r_type);
7851 broken = TRUE;
7852 break;
7853 }
7854
7855 r_symndx = ELF64_R_SYM (rel->r_info);
7856 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7857 r_symndx, ibfd))
7858 goto error_ret;
7859
7860 if (sym_sec == NULL || sym_sec->owner == NULL)
7861 {
7862 const char *sym_name;
7863 if (h != NULL)
7864 sym_name = h->root.root.string;
7865 else
7866 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7867 sym_sec);
7868
7869 (*_bfd_error_handler)
7870 (_("%B: undefined sym `%s' in .opd section"),
7871 ibfd, sym_name);
7872 broken = TRUE;
7873 break;
7874 }
7875
7876 /* opd entries are always for functions defined in the
7877 current input bfd. If the symbol isn't defined in the
7878 input bfd, then we won't be using the function in this
7879 bfd; It must be defined in a linkonce section in another
7880 bfd, or is weak. It's also possible that we are
7881 discarding the function due to a linker script /DISCARD/,
7882 which we test for via the output_section. */
7883 if (sym_sec->owner != ibfd
7884 || sym_sec->output_section == bfd_abs_section_ptr)
7885 need_edit = TRUE;
7886
7887 rel += 2;
7888 if (rel + 1 == relend
7889 || (rel + 2 < relend
7890 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7891 ++rel;
7892
7893 if (rel == relend)
7894 {
7895 if (sec->size == offset + 24)
7896 {
7897 need_pad = NULL;
7898 break;
7899 }
7900 if (sec->size == offset + 16)
7901 {
7902 cnt_16b++;
7903 break;
7904 }
7905 goto broken_opd;
7906 }
7907 else if (rel + 1 < relend
7908 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7909 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7910 {
7911 if (rel[0].r_offset == offset + 16)
7912 cnt_16b++;
7913 else if (rel[0].r_offset != offset + 24)
7914 goto broken_opd;
7915 }
7916 else
7917 goto broken_opd;
7918 }
7919
7920 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7921
7922 if (!broken && (need_edit || add_aux_fields))
7923 {
7924 Elf_Internal_Rela *write_rel;
7925 Elf_Internal_Shdr *rel_hdr;
7926 bfd_byte *rptr, *wptr;
7927 bfd_byte *new_contents;
7928 bfd_size_type amt;
7929
7930 new_contents = NULL;
7931 amt = OPD_NDX (sec->size) * sizeof (long);
7932 opd = &ppc64_elf_section_data (sec)->u.opd;
7933 opd->adjust = bfd_zalloc (sec->owner, amt);
7934 if (opd->adjust == NULL)
7935 return FALSE;
7936 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7937
7938 /* This seems a waste of time as input .opd sections are all
7939 zeros as generated by gcc, but I suppose there's no reason
7940 this will always be so. We might start putting something in
7941 the third word of .opd entries. */
7942 if ((sec->flags & SEC_IN_MEMORY) == 0)
7943 {
7944 bfd_byte *loc;
7945 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7946 {
7947 if (loc != NULL)
7948 free (loc);
7949 error_ret:
7950 if (local_syms != NULL
7951 && symtab_hdr->contents != (unsigned char *) local_syms)
7952 free (local_syms);
7953 if (elf_section_data (sec)->relocs != relstart)
7954 free (relstart);
7955 return FALSE;
7956 }
7957 sec->contents = loc;
7958 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7959 }
7960
7961 elf_section_data (sec)->relocs = relstart;
7962
7963 new_contents = sec->contents;
7964 if (add_aux_fields)
7965 {
7966 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7967 if (new_contents == NULL)
7968 return FALSE;
7969 need_pad = NULL;
7970 }
7971 wptr = new_contents;
7972 rptr = sec->contents;
7973 write_rel = relstart;
7974 for (rel = relstart; rel < relend; )
7975 {
7976 unsigned long r_symndx;
7977 asection *sym_sec;
7978 struct elf_link_hash_entry *h;
7979 struct ppc_link_hash_entry *fdh = NULL;
7980 Elf_Internal_Sym *sym;
7981 long opd_ent_size;
7982 Elf_Internal_Rela *next_rel;
7983 bfd_boolean skip;
7984
7985 r_symndx = ELF64_R_SYM (rel->r_info);
7986 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7987 r_symndx, ibfd))
7988 goto error_ret;
7989
7990 next_rel = rel + 2;
7991 if (next_rel + 1 == relend
7992 || (next_rel + 2 < relend
7993 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7994 ++next_rel;
7995
7996 /* See if the .opd entry is full 24 byte or
7997 16 byte (with fd_aux entry overlapped with next
7998 fd_func). */
7999 opd_ent_size = 24;
8000 if (next_rel == relend)
8001 {
8002 if (sec->size == rel->r_offset + 16)
8003 opd_ent_size = 16;
8004 }
8005 else if (next_rel->r_offset == rel->r_offset + 16)
8006 opd_ent_size = 16;
8007
8008 if (h != NULL
8009 && h->root.root.string[0] == '.')
8010 {
8011 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8012 if (fdh != NULL
8013 && fdh->elf.root.type != bfd_link_hash_defined
8014 && fdh->elf.root.type != bfd_link_hash_defweak)
8015 fdh = NULL;
8016 }
8017
8018 skip = (sym_sec->owner != ibfd
8019 || sym_sec->output_section == bfd_abs_section_ptr);
8020 if (skip)
8021 {
8022 if (fdh != NULL && sym_sec->owner == ibfd)
8023 {
8024 /* Arrange for the function descriptor sym
8025 to be dropped. */
8026 fdh->elf.root.u.def.value = 0;
8027 fdh->elf.root.u.def.section = sym_sec;
8028 }
8029 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8030
8031 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8032 rel = next_rel;
8033 else
8034 while (1)
8035 {
8036 if (!dec_dynrel_count (rel->r_info, sec, info,
8037 NULL, h, sym))
8038 goto error_ret;
8039
8040 if (++rel == next_rel)
8041 break;
8042
8043 r_symndx = ELF64_R_SYM (rel->r_info);
8044 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8045 r_symndx, ibfd))
8046 goto error_ret;
8047 }
8048 }
8049 else
8050 {
8051 /* We'll be keeping this opd entry. */
8052 long adjust;
8053
8054 if (fdh != NULL)
8055 {
8056 /* Redefine the function descriptor symbol to
8057 this location in the opd section. It is
8058 necessary to update the value here rather
8059 than using an array of adjustments as we do
8060 for local symbols, because various places
8061 in the generic ELF code use the value
8062 stored in u.def.value. */
8063 fdh->elf.root.u.def.value = wptr - new_contents;
8064 fdh->adjust_done = 1;
8065 }
8066
8067 /* Local syms are a bit tricky. We could
8068 tweak them as they can be cached, but
8069 we'd need to look through the local syms
8070 for the function descriptor sym which we
8071 don't have at the moment. So keep an
8072 array of adjustments. */
8073 adjust = (wptr - new_contents) - (rptr - sec->contents);
8074 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8075
8076 if (wptr != rptr)
8077 memcpy (wptr, rptr, opd_ent_size);
8078 wptr += opd_ent_size;
8079 if (add_aux_fields && opd_ent_size == 16)
8080 {
8081 memset (wptr, '\0', 8);
8082 wptr += 8;
8083 }
8084
8085 /* We need to adjust any reloc offsets to point to the
8086 new opd entries. */
8087 for ( ; rel != next_rel; ++rel)
8088 {
8089 rel->r_offset += adjust;
8090 if (write_rel != rel)
8091 memcpy (write_rel, rel, sizeof (*rel));
8092 ++write_rel;
8093 }
8094 }
8095
8096 rptr += opd_ent_size;
8097 }
8098
8099 sec->size = wptr - new_contents;
8100 sec->reloc_count = write_rel - relstart;
8101 if (add_aux_fields)
8102 {
8103 free (sec->contents);
8104 sec->contents = new_contents;
8105 }
8106
8107 /* Fudge the header size too, as this is used later in
8108 elf_bfd_final_link if we are emitting relocs. */
8109 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8110 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8111 some_edited = TRUE;
8112 }
8113 else if (elf_section_data (sec)->relocs != relstart)
8114 free (relstart);
8115
8116 if (local_syms != NULL
8117 && symtab_hdr->contents != (unsigned char *) local_syms)
8118 {
8119 if (!info->keep_memory)
8120 free (local_syms);
8121 else
8122 symtab_hdr->contents = (unsigned char *) local_syms;
8123 }
8124 }
8125
8126 if (some_edited)
8127 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8128
8129 /* If we are doing a final link and the last .opd entry is just 16 byte
8130 long, add a 8 byte padding after it. */
8131 if (need_pad != NULL && !bfd_link_relocatable (info))
8132 {
8133 bfd_byte *p;
8134
8135 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8136 {
8137 BFD_ASSERT (need_pad->size > 0);
8138
8139 p = bfd_malloc (need_pad->size + 8);
8140 if (p == NULL)
8141 return FALSE;
8142
8143 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8144 p, 0, need_pad->size))
8145 return FALSE;
8146
8147 need_pad->contents = p;
8148 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8149 }
8150 else
8151 {
8152 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8153 if (p == NULL)
8154 return FALSE;
8155
8156 need_pad->contents = p;
8157 }
8158
8159 memset (need_pad->contents + need_pad->size, 0, 8);
8160 need_pad->size += 8;
8161 }
8162
8163 return TRUE;
8164 }
8165
8166 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8167
8168 asection *
8169 ppc64_elf_tls_setup (struct bfd_link_info *info)
8170 {
8171 struct ppc_link_hash_table *htab;
8172
8173 htab = ppc_hash_table (info);
8174 if (htab == NULL)
8175 return NULL;
8176
8177 if (abiversion (info->output_bfd) == 1)
8178 htab->opd_abi = 1;
8179
8180 if (htab->params->no_multi_toc)
8181 htab->do_multi_toc = 0;
8182 else if (!htab->do_multi_toc)
8183 htab->params->no_multi_toc = 1;
8184
8185 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8186 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8187 FALSE, FALSE, TRUE));
8188 /* Move dynamic linking info to the function descriptor sym. */
8189 if (htab->tls_get_addr != NULL)
8190 func_desc_adjust (&htab->tls_get_addr->elf, info);
8191 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8192 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8193 FALSE, FALSE, TRUE));
8194 if (htab->params->tls_get_addr_opt)
8195 {
8196 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8197
8198 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8199 FALSE, FALSE, TRUE);
8200 if (opt != NULL)
8201 func_desc_adjust (opt, info);
8202 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8203 FALSE, FALSE, TRUE);
8204 if (opt_fd != NULL
8205 && (opt_fd->root.type == bfd_link_hash_defined
8206 || opt_fd->root.type == bfd_link_hash_defweak))
8207 {
8208 /* If glibc supports an optimized __tls_get_addr call stub,
8209 signalled by the presence of __tls_get_addr_opt, and we'll
8210 be calling __tls_get_addr via a plt call stub, then
8211 make __tls_get_addr point to __tls_get_addr_opt. */
8212 tga_fd = &htab->tls_get_addr_fd->elf;
8213 if (htab->elf.dynamic_sections_created
8214 && tga_fd != NULL
8215 && (tga_fd->type == STT_FUNC
8216 || tga_fd->needs_plt)
8217 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8218 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8219 && tga_fd->root.type == bfd_link_hash_undefweak)))
8220 {
8221 struct plt_entry *ent;
8222
8223 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8224 if (ent->plt.refcount > 0)
8225 break;
8226 if (ent != NULL)
8227 {
8228 tga_fd->root.type = bfd_link_hash_indirect;
8229 tga_fd->root.u.i.link = &opt_fd->root;
8230 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8231 if (opt_fd->dynindx != -1)
8232 {
8233 /* Use __tls_get_addr_opt in dynamic relocations. */
8234 opt_fd->dynindx = -1;
8235 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8236 opt_fd->dynstr_index);
8237 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8238 return NULL;
8239 }
8240 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8241 tga = &htab->tls_get_addr->elf;
8242 if (opt != NULL && tga != NULL)
8243 {
8244 tga->root.type = bfd_link_hash_indirect;
8245 tga->root.u.i.link = &opt->root;
8246 ppc64_elf_copy_indirect_symbol (info, opt, tga);
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