projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
argv.c (expandargv): Check for directories passed as @-files.
[deliverable/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_dtrel_excludes_plt 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
91
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_before_check_relocs
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded ppc64_elf_action_discarded
115 #define elf_backend_relocate_section ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections ppc64_elf_special_sections
121 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
122 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
123
124 /* The name of the dynamic interpreter. This is put in the .interp
125 section. */
126 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
127
128 /* The size in bytes of an entry in the procedure linkage table. */
129 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
130
131 /* The initial size of the plt reserved for the dynamic linker. */
132 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
133
134 /* Offsets to some stack save slots. */
135 #define STK_LR 16
136 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
137 /* This one is dodgy. ELFv2 does not have a linker word, so use the
138 CR save slot. Used only by optimised __tls_get_addr call stub,
139 relying on __tls_get_addr_opt not saving CR.. */
140 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
141
142 /* TOC base pointers offset from start of TOC. */
143 #define TOC_BASE_OFF 0x8000
144 /* TOC base alignment. */
145 #define TOC_BASE_ALIGN 256
146
147 /* Offset of tp and dtp pointers from start of TLS block. */
148 #define TP_OFFSET 0x7000
149 #define DTP_OFFSET 0x8000
150
151 /* .plt call stub instructions. The normal stub is like this, but
152 sometimes the .plt entry crosses a 64k boundary and we need to
153 insert an addi to adjust r11. */
154 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
155 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
156 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
157 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
158 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
159 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
160 #define BCTR 0x4e800420 /* bctr */
161
162 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
163 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
164 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
165
166 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
167 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
168 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
169 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
170 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
171 #define BNECTR 0x4ca20420 /* bnectr+ */
172 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
173
174 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
175 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
176 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
177
178 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
179 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
180 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
181
182 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
183 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
184 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
185 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
186 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
187
188 /* glink call stub instructions. We enter with the index in R0. */
189 #define GLINK_CALL_STUB_SIZE (16*4)
190 /* 0: */
191 /* .quad plt0-1f */
192 /* __glink: */
193 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
194 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
195 /* 1: */
196 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
197 /* ld %2,(0b-1b)(%11) */
198 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
199 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
200 /* ld %12,0(%11) */
201 /* ld %2,8(%11) */
202 /* mtctr %12 */
203 /* ld %11,16(%11) */
204 /* bctr */
205 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
206 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
207 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
208 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
209 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
210
211 /* Pad with this. */
212 #define NOP 0x60000000
213
214 /* Some other nops. */
215 #define CROR_151515 0x4def7b82
216 #define CROR_313131 0x4ffffb82
217
218 /* .glink entries for the first 32k functions are two instructions. */
219 #define LI_R0_0 0x38000000 /* li %r0,0 */
220 #define B_DOT 0x48000000 /* b . */
221
222 /* After that, we need two instructions to load the index, followed by
223 a branch. */
224 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
225 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
226
227 /* Instructions used by the save and restore reg functions. */
228 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
229 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
230 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
231 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
232 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
233 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
234 #define LI_R12_0 0x39800000 /* li %r12,0 */
235 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
236 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
237 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
238 #define BLR 0x4e800020 /* blr */
239
240 /* Since .opd is an array of descriptors and each entry will end up
241 with identical R_PPC64_RELATIVE relocs, there is really no need to
242 propagate .opd relocs; The dynamic linker should be taught to
243 relocate .opd without reloc entries. */
244 #ifndef NO_OPD_RELOCS
245 #define NO_OPD_RELOCS 0
246 #endif
247
248 #ifndef ARRAY_SIZE
249 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
250 #endif
251
252 static inline int
253 abiversion (bfd *abfd)
254 {
255 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
256 }
257
258 static inline void
259 set_abiversion (bfd *abfd, int ver)
260 {
261 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
262 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
263 }
264 \f
265 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
266
267 /* Relocation HOWTO's. */
268 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
269
270 static reloc_howto_type ppc64_elf_howto_raw[] = {
271 /* This reloc does nothing. */
272 HOWTO (R_PPC64_NONE, /* type */
273 0, /* rightshift */
274 3, /* size (0 = byte, 1 = short, 2 = long) */
275 0, /* bitsize */
276 FALSE, /* pc_relative */
277 0, /* bitpos */
278 complain_overflow_dont, /* complain_on_overflow */
279 bfd_elf_generic_reloc, /* special_function */
280 "R_PPC64_NONE", /* name */
281 FALSE, /* partial_inplace */
282 0, /* src_mask */
283 0, /* dst_mask */
284 FALSE), /* pcrel_offset */
285
286 /* A standard 32 bit relocation. */
287 HOWTO (R_PPC64_ADDR32, /* type */
288 0, /* rightshift */
289 2, /* size (0 = byte, 1 = short, 2 = long) */
290 32, /* bitsize */
291 FALSE, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_bitfield, /* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_PPC64_ADDR32", /* name */
296 FALSE, /* partial_inplace */
297 0, /* src_mask */
298 0xffffffff, /* dst_mask */
299 FALSE), /* pcrel_offset */
300
301 /* An absolute 26 bit branch; the lower two bits must be zero.
302 FIXME: we don't check that, we just clear them. */
303 HOWTO (R_PPC64_ADDR24, /* type */
304 0, /* rightshift */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
306 26, /* bitsize */
307 FALSE, /* pc_relative */
308 0, /* bitpos */
309 complain_overflow_bitfield, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_PPC64_ADDR24", /* name */
312 FALSE, /* partial_inplace */
313 0, /* src_mask */
314 0x03fffffc, /* dst_mask */
315 FALSE), /* pcrel_offset */
316
317 /* A standard 16 bit relocation. */
318 HOWTO (R_PPC64_ADDR16, /* type */
319 0, /* rightshift */
320 1, /* size (0 = byte, 1 = short, 2 = long) */
321 16, /* bitsize */
322 FALSE, /* pc_relative */
323 0, /* bitpos */
324 complain_overflow_bitfield, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_PPC64_ADDR16", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0xffff, /* dst_mask */
330 FALSE), /* pcrel_offset */
331
332 /* A 16 bit relocation without overflow. */
333 HOWTO (R_PPC64_ADDR16_LO, /* type */
334 0, /* rightshift */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
336 16, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_dont,/* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_PPC64_ADDR16_LO", /* name */
342 FALSE, /* partial_inplace */
343 0, /* src_mask */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 /* Bits 16-31 of an address. */
348 HOWTO (R_PPC64_ADDR16_HI, /* type */
349 16, /* rightshift */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 FALSE, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_signed, /* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_PPC64_ADDR16_HI", /* name */
357 FALSE, /* partial_inplace */
358 0, /* src_mask */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
361
362 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
363 bits, treated as a signed number, is negative. */
364 HOWTO (R_PPC64_ADDR16_HA, /* type */
365 16, /* rightshift */
366 1, /* size (0 = byte, 1 = short, 2 = long) */
367 16, /* bitsize */
368 FALSE, /* pc_relative */
369 0, /* bitpos */
370 complain_overflow_signed, /* complain_on_overflow */
371 ppc64_elf_ha_reloc, /* special_function */
372 "R_PPC64_ADDR16_HA", /* name */
373 FALSE, /* partial_inplace */
374 0, /* src_mask */
375 0xffff, /* dst_mask */
376 FALSE), /* pcrel_offset */
377
378 /* An absolute 16 bit branch; the lower two bits must be zero.
379 FIXME: we don't check that, we just clear them. */
380 HOWTO (R_PPC64_ADDR14, /* type */
381 0, /* rightshift */
382 2, /* size (0 = byte, 1 = short, 2 = long) */
383 16, /* bitsize */
384 FALSE, /* pc_relative */
385 0, /* bitpos */
386 complain_overflow_signed, /* complain_on_overflow */
387 ppc64_elf_branch_reloc, /* special_function */
388 "R_PPC64_ADDR14", /* name */
389 FALSE, /* partial_inplace */
390 0, /* src_mask */
391 0x0000fffc, /* dst_mask */
392 FALSE), /* pcrel_offset */
393
394 /* An absolute 16 bit branch, for which bit 10 should be set to
395 indicate that the branch is expected to be taken. The lower two
396 bits must be zero. */
397 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
398 0, /* rightshift */
399 2, /* size (0 = byte, 1 = short, 2 = long) */
400 16, /* bitsize */
401 FALSE, /* pc_relative */
402 0, /* bitpos */
403 complain_overflow_signed, /* complain_on_overflow */
404 ppc64_elf_brtaken_reloc, /* special_function */
405 "R_PPC64_ADDR14_BRTAKEN",/* name */
406 FALSE, /* partial_inplace */
407 0, /* src_mask */
408 0x0000fffc, /* dst_mask */
409 FALSE), /* pcrel_offset */
410
411 /* An absolute 16 bit branch, for which bit 10 should be set to
412 indicate that the branch is not expected to be taken. The lower
413 two bits must be zero. */
414 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
415 0, /* rightshift */
416 2, /* size (0 = byte, 1 = short, 2 = long) */
417 16, /* bitsize */
418 FALSE, /* pc_relative */
419 0, /* bitpos */
420 complain_overflow_signed, /* complain_on_overflow */
421 ppc64_elf_brtaken_reloc, /* special_function */
422 "R_PPC64_ADDR14_BRNTAKEN",/* name */
423 FALSE, /* partial_inplace */
424 0, /* src_mask */
425 0x0000fffc, /* dst_mask */
426 FALSE), /* pcrel_offset */
427
428 /* A relative 26 bit branch; the lower two bits must be zero. */
429 HOWTO (R_PPC64_REL24, /* type */
430 0, /* rightshift */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
432 26, /* bitsize */
433 TRUE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_signed, /* complain_on_overflow */
436 ppc64_elf_branch_reloc, /* special_function */
437 "R_PPC64_REL24", /* name */
438 FALSE, /* partial_inplace */
439 0, /* src_mask */
440 0x03fffffc, /* dst_mask */
441 TRUE), /* pcrel_offset */
442
443 /* A relative 16 bit branch; the lower two bits must be zero. */
444 HOWTO (R_PPC64_REL14, /* type */
445 0, /* rightshift */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
447 16, /* bitsize */
448 TRUE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_signed, /* complain_on_overflow */
451 ppc64_elf_branch_reloc, /* special_function */
452 "R_PPC64_REL14", /* name */
453 FALSE, /* partial_inplace */
454 0, /* src_mask */
455 0x0000fffc, /* dst_mask */
456 TRUE), /* pcrel_offset */
457
458 /* A relative 16 bit branch. Bit 10 should be set to indicate that
459 the branch is expected to be taken. The lower two bits must be
460 zero. */
461 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
462 0, /* rightshift */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
464 16, /* bitsize */
465 TRUE, /* pc_relative */
466 0, /* bitpos */
467 complain_overflow_signed, /* complain_on_overflow */
468 ppc64_elf_brtaken_reloc, /* special_function */
469 "R_PPC64_REL14_BRTAKEN", /* name */
470 FALSE, /* partial_inplace */
471 0, /* src_mask */
472 0x0000fffc, /* dst_mask */
473 TRUE), /* pcrel_offset */
474
475 /* A relative 16 bit branch. Bit 10 should be set to indicate that
476 the branch is not expected to be taken. The lower two bits must
477 be zero. */
478 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
479 0, /* rightshift */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
481 16, /* bitsize */
482 TRUE, /* pc_relative */
483 0, /* bitpos */
484 complain_overflow_signed, /* complain_on_overflow */
485 ppc64_elf_brtaken_reloc, /* special_function */
486 "R_PPC64_REL14_BRNTAKEN",/* name */
487 FALSE, /* partial_inplace */
488 0, /* src_mask */
489 0x0000fffc, /* dst_mask */
490 TRUE), /* pcrel_offset */
491
492 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
493 symbol. */
494 HOWTO (R_PPC64_GOT16, /* type */
495 0, /* rightshift */
496 1, /* size (0 = byte, 1 = short, 2 = long) */
497 16, /* bitsize */
498 FALSE, /* pc_relative */
499 0, /* bitpos */
500 complain_overflow_signed, /* complain_on_overflow */
501 ppc64_elf_unhandled_reloc, /* special_function */
502 "R_PPC64_GOT16", /* name */
503 FALSE, /* partial_inplace */
504 0, /* src_mask */
505 0xffff, /* dst_mask */
506 FALSE), /* pcrel_offset */
507
508 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
509 the symbol. */
510 HOWTO (R_PPC64_GOT16_LO, /* type */
511 0, /* rightshift */
512 1, /* size (0 = byte, 1 = short, 2 = long) */
513 16, /* bitsize */
514 FALSE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_dont, /* complain_on_overflow */
517 ppc64_elf_unhandled_reloc, /* special_function */
518 "R_PPC64_GOT16_LO", /* name */
519 FALSE, /* partial_inplace */
520 0, /* src_mask */
521 0xffff, /* dst_mask */
522 FALSE), /* pcrel_offset */
523
524 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
525 the symbol. */
526 HOWTO (R_PPC64_GOT16_HI, /* type */
527 16, /* rightshift */
528 1, /* size (0 = byte, 1 = short, 2 = long) */
529 16, /* bitsize */
530 FALSE, /* pc_relative */
531 0, /* bitpos */
532 complain_overflow_signed,/* complain_on_overflow */
533 ppc64_elf_unhandled_reloc, /* special_function */
534 "R_PPC64_GOT16_HI", /* name */
535 FALSE, /* partial_inplace */
536 0, /* src_mask */
537 0xffff, /* dst_mask */
538 FALSE), /* pcrel_offset */
539
540 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
541 the symbol. */
542 HOWTO (R_PPC64_GOT16_HA, /* type */
543 16, /* rightshift */
544 1, /* size (0 = byte, 1 = short, 2 = long) */
545 16, /* bitsize */
546 FALSE, /* pc_relative */
547 0, /* bitpos */
548 complain_overflow_signed,/* complain_on_overflow */
549 ppc64_elf_unhandled_reloc, /* special_function */
550 "R_PPC64_GOT16_HA", /* name */
551 FALSE, /* partial_inplace */
552 0, /* src_mask */
553 0xffff, /* dst_mask */
554 FALSE), /* pcrel_offset */
555
556 /* This is used only by the dynamic linker. The symbol should exist
557 both in the object being run and in some shared library. The
558 dynamic linker copies the data addressed by the symbol from the
559 shared library into the object, because the object being
560 run has to have the data at some particular address. */
561 HOWTO (R_PPC64_COPY, /* type */
562 0, /* rightshift */
563 0, /* this one is variable size */
564 0, /* bitsize */
565 FALSE, /* pc_relative */
566 0, /* bitpos */
567 complain_overflow_dont, /* complain_on_overflow */
568 ppc64_elf_unhandled_reloc, /* special_function */
569 "R_PPC64_COPY", /* name */
570 FALSE, /* partial_inplace */
571 0, /* src_mask */
572 0, /* dst_mask */
573 FALSE), /* pcrel_offset */
574
575 /* Like R_PPC64_ADDR64, but used when setting global offset table
576 entries. */
577 HOWTO (R_PPC64_GLOB_DAT, /* type */
578 0, /* rightshift */
579 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
580 64, /* bitsize */
581 FALSE, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_dont, /* complain_on_overflow */
584 ppc64_elf_unhandled_reloc, /* special_function */
585 "R_PPC64_GLOB_DAT", /* name */
586 FALSE, /* partial_inplace */
587 0, /* src_mask */
588 ONES (64), /* dst_mask */
589 FALSE), /* pcrel_offset */
590
591 /* Created by the link editor. Marks a procedure linkage table
592 entry for a symbol. */
593 HOWTO (R_PPC64_JMP_SLOT, /* type */
594 0, /* rightshift */
595 0, /* size (0 = byte, 1 = short, 2 = long) */
596 0, /* bitsize */
597 FALSE, /* pc_relative */
598 0, /* bitpos */
599 complain_overflow_dont, /* complain_on_overflow */
600 ppc64_elf_unhandled_reloc, /* special_function */
601 "R_PPC64_JMP_SLOT", /* name */
602 FALSE, /* partial_inplace */
603 0, /* src_mask */
604 0, /* dst_mask */
605 FALSE), /* pcrel_offset */
606
607 /* Used only by the dynamic linker. When the object is run, this
608 doubleword64 is set to the load address of the object, plus the
609 addend. */
610 HOWTO (R_PPC64_RELATIVE, /* type */
611 0, /* rightshift */
612 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
613 64, /* bitsize */
614 FALSE, /* pc_relative */
615 0, /* bitpos */
616 complain_overflow_dont, /* complain_on_overflow */
617 bfd_elf_generic_reloc, /* special_function */
618 "R_PPC64_RELATIVE", /* name */
619 FALSE, /* partial_inplace */
620 0, /* src_mask */
621 ONES (64), /* dst_mask */
622 FALSE), /* pcrel_offset */
623
624 /* Like R_PPC64_ADDR32, but may be unaligned. */
625 HOWTO (R_PPC64_UADDR32, /* type */
626 0, /* rightshift */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
628 32, /* bitsize */
629 FALSE, /* pc_relative */
630 0, /* bitpos */
631 complain_overflow_bitfield, /* complain_on_overflow */
632 bfd_elf_generic_reloc, /* special_function */
633 "R_PPC64_UADDR32", /* name */
634 FALSE, /* partial_inplace */
635 0, /* src_mask */
636 0xffffffff, /* dst_mask */
637 FALSE), /* pcrel_offset */
638
639 /* Like R_PPC64_ADDR16, but may be unaligned. */
640 HOWTO (R_PPC64_UADDR16, /* type */
641 0, /* rightshift */
642 1, /* size (0 = byte, 1 = short, 2 = long) */
643 16, /* bitsize */
644 FALSE, /* pc_relative */
645 0, /* bitpos */
646 complain_overflow_bitfield, /* complain_on_overflow */
647 bfd_elf_generic_reloc, /* special_function */
648 "R_PPC64_UADDR16", /* name */
649 FALSE, /* partial_inplace */
650 0, /* src_mask */
651 0xffff, /* dst_mask */
652 FALSE), /* pcrel_offset */
653
654 /* 32-bit PC relative. */
655 HOWTO (R_PPC64_REL32, /* type */
656 0, /* rightshift */
657 2, /* size (0 = byte, 1 = short, 2 = long) */
658 32, /* bitsize */
659 TRUE, /* pc_relative */
660 0, /* bitpos */
661 complain_overflow_signed, /* complain_on_overflow */
662 bfd_elf_generic_reloc, /* special_function */
663 "R_PPC64_REL32", /* name */
664 FALSE, /* partial_inplace */
665 0, /* src_mask */
666 0xffffffff, /* dst_mask */
667 TRUE), /* pcrel_offset */
668
669 /* 32-bit relocation to the symbol's procedure linkage table. */
670 HOWTO (R_PPC64_PLT32, /* type */
671 0, /* rightshift */
672 2, /* size (0 = byte, 1 = short, 2 = long) */
673 32, /* bitsize */
674 FALSE, /* pc_relative */
675 0, /* bitpos */
676 complain_overflow_bitfield, /* complain_on_overflow */
677 ppc64_elf_unhandled_reloc, /* special_function */
678 "R_PPC64_PLT32", /* name */
679 FALSE, /* partial_inplace */
680 0, /* src_mask */
681 0xffffffff, /* dst_mask */
682 FALSE), /* pcrel_offset */
683
684 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
685 FIXME: R_PPC64_PLTREL32 not supported. */
686 HOWTO (R_PPC64_PLTREL32, /* type */
687 0, /* rightshift */
688 2, /* size (0 = byte, 1 = short, 2 = long) */
689 32, /* bitsize */
690 TRUE, /* pc_relative */
691 0, /* bitpos */
692 complain_overflow_signed, /* complain_on_overflow */
693 ppc64_elf_unhandled_reloc, /* special_function */
694 "R_PPC64_PLTREL32", /* name */
695 FALSE, /* partial_inplace */
696 0, /* src_mask */
697 0xffffffff, /* dst_mask */
698 TRUE), /* pcrel_offset */
699
700 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
701 the symbol. */
702 HOWTO (R_PPC64_PLT16_LO, /* type */
703 0, /* rightshift */
704 1, /* size (0 = byte, 1 = short, 2 = long) */
705 16, /* bitsize */
706 FALSE, /* pc_relative */
707 0, /* bitpos */
708 complain_overflow_dont, /* complain_on_overflow */
709 ppc64_elf_unhandled_reloc, /* special_function */
710 "R_PPC64_PLT16_LO", /* name */
711 FALSE, /* partial_inplace */
712 0, /* src_mask */
713 0xffff, /* dst_mask */
714 FALSE), /* pcrel_offset */
715
716 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
717 the symbol. */
718 HOWTO (R_PPC64_PLT16_HI, /* type */
719 16, /* rightshift */
720 1, /* size (0 = byte, 1 = short, 2 = long) */
721 16, /* bitsize */
722 FALSE, /* pc_relative */
723 0, /* bitpos */
724 complain_overflow_signed, /* complain_on_overflow */
725 ppc64_elf_unhandled_reloc, /* special_function */
726 "R_PPC64_PLT16_HI", /* name */
727 FALSE, /* partial_inplace */
728 0, /* src_mask */
729 0xffff, /* dst_mask */
730 FALSE), /* pcrel_offset */
731
732 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
733 the symbol. */
734 HOWTO (R_PPC64_PLT16_HA, /* type */
735 16, /* rightshift */
736 1, /* size (0 = byte, 1 = short, 2 = long) */
737 16, /* bitsize */
738 FALSE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_signed, /* complain_on_overflow */
741 ppc64_elf_unhandled_reloc, /* special_function */
742 "R_PPC64_PLT16_HA", /* name */
743 FALSE, /* partial_inplace */
744 0, /* src_mask */
745 0xffff, /* dst_mask */
746 FALSE), /* pcrel_offset */
747
748 /* 16-bit section relative relocation. */
749 HOWTO (R_PPC64_SECTOFF, /* type */
750 0, /* rightshift */
751 1, /* size (0 = byte, 1 = short, 2 = long) */
752 16, /* bitsize */
753 FALSE, /* pc_relative */
754 0, /* bitpos */
755 complain_overflow_signed, /* complain_on_overflow */
756 ppc64_elf_sectoff_reloc, /* special_function */
757 "R_PPC64_SECTOFF", /* name */
758 FALSE, /* partial_inplace */
759 0, /* src_mask */
760 0xffff, /* dst_mask */
761 FALSE), /* pcrel_offset */
762
763 /* Like R_PPC64_SECTOFF, but no overflow warning. */
764 HOWTO (R_PPC64_SECTOFF_LO, /* type */
765 0, /* rightshift */
766 1, /* size (0 = byte, 1 = short, 2 = long) */
767 16, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_dont, /* complain_on_overflow */
771 ppc64_elf_sectoff_reloc, /* special_function */
772 "R_PPC64_SECTOFF_LO", /* name */
773 FALSE, /* partial_inplace */
774 0, /* src_mask */
775 0xffff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 /* 16-bit upper half section relative relocation. */
779 HOWTO (R_PPC64_SECTOFF_HI, /* type */
780 16, /* rightshift */
781 1, /* size (0 = byte, 1 = short, 2 = long) */
782 16, /* bitsize */
783 FALSE, /* pc_relative */
784 0, /* bitpos */
785 complain_overflow_signed, /* complain_on_overflow */
786 ppc64_elf_sectoff_reloc, /* special_function */
787 "R_PPC64_SECTOFF_HI", /* name */
788 FALSE, /* partial_inplace */
789 0, /* src_mask */
790 0xffff, /* dst_mask */
791 FALSE), /* pcrel_offset */
792
793 /* 16-bit upper half adjusted section relative relocation. */
794 HOWTO (R_PPC64_SECTOFF_HA, /* type */
795 16, /* rightshift */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
797 16, /* bitsize */
798 FALSE, /* pc_relative */
799 0, /* bitpos */
800 complain_overflow_signed, /* complain_on_overflow */
801 ppc64_elf_sectoff_ha_reloc, /* special_function */
802 "R_PPC64_SECTOFF_HA", /* name */
803 FALSE, /* partial_inplace */
804 0, /* src_mask */
805 0xffff, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 /* Like R_PPC64_REL24 without touching the two least significant bits. */
809 HOWTO (R_PPC64_REL30, /* type */
810 2, /* rightshift */
811 2, /* size (0 = byte, 1 = short, 2 = long) */
812 30, /* bitsize */
813 TRUE, /* pc_relative */
814 0, /* bitpos */
815 complain_overflow_dont, /* complain_on_overflow */
816 bfd_elf_generic_reloc, /* special_function */
817 "R_PPC64_REL30", /* name */
818 FALSE, /* partial_inplace */
819 0, /* src_mask */
820 0xfffffffc, /* dst_mask */
821 TRUE), /* pcrel_offset */
822
823 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
824
825 /* A standard 64-bit relocation. */
826 HOWTO (R_PPC64_ADDR64, /* type */
827 0, /* rightshift */
828 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
829 64, /* bitsize */
830 FALSE, /* pc_relative */
831 0, /* bitpos */
832 complain_overflow_dont, /* complain_on_overflow */
833 bfd_elf_generic_reloc, /* special_function */
834 "R_PPC64_ADDR64", /* name */
835 FALSE, /* partial_inplace */
836 0, /* src_mask */
837 ONES (64), /* dst_mask */
838 FALSE), /* pcrel_offset */
839
840 /* The bits 32-47 of an address. */
841 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
842 32, /* rightshift */
843 1, /* size (0 = byte, 1 = short, 2 = long) */
844 16, /* bitsize */
845 FALSE, /* pc_relative */
846 0, /* bitpos */
847 complain_overflow_dont, /* complain_on_overflow */
848 bfd_elf_generic_reloc, /* special_function */
849 "R_PPC64_ADDR16_HIGHER", /* name */
850 FALSE, /* partial_inplace */
851 0, /* src_mask */
852 0xffff, /* dst_mask */
853 FALSE), /* pcrel_offset */
854
855 /* The bits 32-47 of an address, plus 1 if the contents of the low
856 16 bits, treated as a signed number, is negative. */
857 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
858 32, /* rightshift */
859 1, /* size (0 = byte, 1 = short, 2 = long) */
860 16, /* bitsize */
861 FALSE, /* pc_relative */
862 0, /* bitpos */
863 complain_overflow_dont, /* complain_on_overflow */
864 ppc64_elf_ha_reloc, /* special_function */
865 "R_PPC64_ADDR16_HIGHERA", /* name */
866 FALSE, /* partial_inplace */
867 0, /* src_mask */
868 0xffff, /* dst_mask */
869 FALSE), /* pcrel_offset */
870
871 /* The bits 48-63 of an address. */
872 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
873 48, /* rightshift */
874 1, /* size (0 = byte, 1 = short, 2 = long) */
875 16, /* bitsize */
876 FALSE, /* pc_relative */
877 0, /* bitpos */
878 complain_overflow_dont, /* complain_on_overflow */
879 bfd_elf_generic_reloc, /* special_function */
880 "R_PPC64_ADDR16_HIGHEST", /* name */
881 FALSE, /* partial_inplace */
882 0, /* src_mask */
883 0xffff, /* dst_mask */
884 FALSE), /* pcrel_offset */
885
886 /* The bits 48-63 of an address, plus 1 if the contents of the low
887 16 bits, treated as a signed number, is negative. */
888 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
889 48, /* rightshift */
890 1, /* size (0 = byte, 1 = short, 2 = long) */
891 16, /* bitsize */
892 FALSE, /* pc_relative */
893 0, /* bitpos */
894 complain_overflow_dont, /* complain_on_overflow */
895 ppc64_elf_ha_reloc, /* special_function */
896 "R_PPC64_ADDR16_HIGHESTA", /* name */
897 FALSE, /* partial_inplace */
898 0, /* src_mask */
899 0xffff, /* dst_mask */
900 FALSE), /* pcrel_offset */
901
902 /* Like ADDR64, but may be unaligned. */
903 HOWTO (R_PPC64_UADDR64, /* type */
904 0, /* rightshift */
905 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
906 64, /* bitsize */
907 FALSE, /* pc_relative */
908 0, /* bitpos */
909 complain_overflow_dont, /* complain_on_overflow */
910 bfd_elf_generic_reloc, /* special_function */
911 "R_PPC64_UADDR64", /* name */
912 FALSE, /* partial_inplace */
913 0, /* src_mask */
914 ONES (64), /* dst_mask */
915 FALSE), /* pcrel_offset */
916
917 /* 64-bit relative relocation. */
918 HOWTO (R_PPC64_REL64, /* type */
919 0, /* rightshift */
920 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
921 64, /* bitsize */
922 TRUE, /* pc_relative */
923 0, /* bitpos */
924 complain_overflow_dont, /* complain_on_overflow */
925 bfd_elf_generic_reloc, /* special_function */
926 "R_PPC64_REL64", /* name */
927 FALSE, /* partial_inplace */
928 0, /* src_mask */
929 ONES (64), /* dst_mask */
930 TRUE), /* pcrel_offset */
931
932 /* 64-bit relocation to the symbol's procedure linkage table. */
933 HOWTO (R_PPC64_PLT64, /* type */
934 0, /* rightshift */
935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
936 64, /* bitsize */
937 FALSE, /* pc_relative */
938 0, /* bitpos */
939 complain_overflow_dont, /* complain_on_overflow */
940 ppc64_elf_unhandled_reloc, /* special_function */
941 "R_PPC64_PLT64", /* name */
942 FALSE, /* partial_inplace */
943 0, /* src_mask */
944 ONES (64), /* dst_mask */
945 FALSE), /* pcrel_offset */
946
947 /* 64-bit PC relative relocation to the symbol's procedure linkage
948 table. */
949 /* FIXME: R_PPC64_PLTREL64 not supported. */
950 HOWTO (R_PPC64_PLTREL64, /* type */
951 0, /* rightshift */
952 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
953 64, /* bitsize */
954 TRUE, /* pc_relative */
955 0, /* bitpos */
956 complain_overflow_dont, /* complain_on_overflow */
957 ppc64_elf_unhandled_reloc, /* special_function */
958 "R_PPC64_PLTREL64", /* name */
959 FALSE, /* partial_inplace */
960 0, /* src_mask */
961 ONES (64), /* dst_mask */
962 TRUE), /* pcrel_offset */
963
964 /* 16 bit TOC-relative relocation. */
965
966 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
967 HOWTO (R_PPC64_TOC16, /* type */
968 0, /* rightshift */
969 1, /* size (0 = byte, 1 = short, 2 = long) */
970 16, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_signed, /* complain_on_overflow */
974 ppc64_elf_toc_reloc, /* special_function */
975 "R_PPC64_TOC16", /* name */
976 FALSE, /* partial_inplace */
977 0, /* src_mask */
978 0xffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980
981 /* 16 bit TOC-relative relocation without overflow. */
982
983 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
984 HOWTO (R_PPC64_TOC16_LO, /* type */
985 0, /* rightshift */
986 1, /* size (0 = byte, 1 = short, 2 = long) */
987 16, /* bitsize */
988 FALSE, /* pc_relative */
989 0, /* bitpos */
990 complain_overflow_dont, /* complain_on_overflow */
991 ppc64_elf_toc_reloc, /* special_function */
992 "R_PPC64_TOC16_LO", /* name */
993 FALSE, /* partial_inplace */
994 0, /* src_mask */
995 0xffff, /* dst_mask */
996 FALSE), /* pcrel_offset */
997
998 /* 16 bit TOC-relative relocation, high 16 bits. */
999
1000 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1001 HOWTO (R_PPC64_TOC16_HI, /* type */
1002 16, /* rightshift */
1003 1, /* size (0 = byte, 1 = short, 2 = long) */
1004 16, /* bitsize */
1005 FALSE, /* pc_relative */
1006 0, /* bitpos */
1007 complain_overflow_signed, /* complain_on_overflow */
1008 ppc64_elf_toc_reloc, /* special_function */
1009 "R_PPC64_TOC16_HI", /* name */
1010 FALSE, /* partial_inplace */
1011 0, /* src_mask */
1012 0xffff, /* dst_mask */
1013 FALSE), /* pcrel_offset */
1014
1015 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1016 contents of the low 16 bits, treated as a signed number, is
1017 negative. */
1018
1019 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1020 HOWTO (R_PPC64_TOC16_HA, /* type */
1021 16, /* rightshift */
1022 1, /* size (0 = byte, 1 = short, 2 = long) */
1023 16, /* bitsize */
1024 FALSE, /* pc_relative */
1025 0, /* bitpos */
1026 complain_overflow_signed, /* complain_on_overflow */
1027 ppc64_elf_toc_ha_reloc, /* special_function */
1028 "R_PPC64_TOC16_HA", /* name */
1029 FALSE, /* partial_inplace */
1030 0, /* src_mask */
1031 0xffff, /* dst_mask */
1032 FALSE), /* pcrel_offset */
1033
1034 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1035
1036 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1037 HOWTO (R_PPC64_TOC, /* type */
1038 0, /* rightshift */
1039 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1040 64, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_dont, /* complain_on_overflow */
1044 ppc64_elf_toc64_reloc, /* special_function */
1045 "R_PPC64_TOC", /* name */
1046 FALSE, /* partial_inplace */
1047 0, /* src_mask */
1048 ONES (64), /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Like R_PPC64_GOT16, but also informs the link editor that the
1052 value to relocate may (!) refer to a PLT entry which the link
1053 editor (a) may replace with the symbol value. If the link editor
1054 is unable to fully resolve the symbol, it may (b) create a PLT
1055 entry and store the address to the new PLT entry in the GOT.
1056 This permits lazy resolution of function symbols at run time.
1057 The link editor may also skip all of this and just (c) emit a
1058 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1059 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1060 HOWTO (R_PPC64_PLTGOT16, /* type */
1061 0, /* rightshift */
1062 1, /* size (0 = byte, 1 = short, 2 = long) */
1063 16, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_signed, /* complain_on_overflow */
1067 ppc64_elf_unhandled_reloc, /* special_function */
1068 "R_PPC64_PLTGOT16", /* name */
1069 FALSE, /* partial_inplace */
1070 0, /* src_mask */
1071 0xffff, /* dst_mask */
1072 FALSE), /* pcrel_offset */
1073
1074 /* Like R_PPC64_PLTGOT16, but without overflow. */
1075 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1076 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1077 0, /* rightshift */
1078 1, /* size (0 = byte, 1 = short, 2 = long) */
1079 16, /* bitsize */
1080 FALSE, /* pc_relative */
1081 0, /* bitpos */
1082 complain_overflow_dont, /* complain_on_overflow */
1083 ppc64_elf_unhandled_reloc, /* special_function */
1084 "R_PPC64_PLTGOT16_LO", /* name */
1085 FALSE, /* partial_inplace */
1086 0, /* src_mask */
1087 0xffff, /* dst_mask */
1088 FALSE), /* pcrel_offset */
1089
1090 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1091 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1092 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1093 16, /* rightshift */
1094 1, /* size (0 = byte, 1 = short, 2 = long) */
1095 16, /* bitsize */
1096 FALSE, /* pc_relative */
1097 0, /* bitpos */
1098 complain_overflow_signed, /* complain_on_overflow */
1099 ppc64_elf_unhandled_reloc, /* special_function */
1100 "R_PPC64_PLTGOT16_HI", /* name */
1101 FALSE, /* partial_inplace */
1102 0, /* src_mask */
1103 0xffff, /* dst_mask */
1104 FALSE), /* pcrel_offset */
1105
1106 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1107 1 if the contents of the low 16 bits, treated as a signed number,
1108 is negative. */
1109 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1110 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1111 16, /* rightshift */
1112 1, /* size (0 = byte, 1 = short, 2 = long) */
1113 16, /* bitsize */
1114 FALSE, /* pc_relative */
1115 0, /* bitpos */
1116 complain_overflow_signed, /* complain_on_overflow */
1117 ppc64_elf_unhandled_reloc, /* special_function */
1118 "R_PPC64_PLTGOT16_HA", /* name */
1119 FALSE, /* partial_inplace */
1120 0, /* src_mask */
1121 0xffff, /* dst_mask */
1122 FALSE), /* pcrel_offset */
1123
1124 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1125 HOWTO (R_PPC64_ADDR16_DS, /* type */
1126 0, /* rightshift */
1127 1, /* size (0 = byte, 1 = short, 2 = long) */
1128 16, /* bitsize */
1129 FALSE, /* pc_relative */
1130 0, /* bitpos */
1131 complain_overflow_signed, /* complain_on_overflow */
1132 bfd_elf_generic_reloc, /* special_function */
1133 "R_PPC64_ADDR16_DS", /* name */
1134 FALSE, /* partial_inplace */
1135 0, /* src_mask */
1136 0xfffc, /* dst_mask */
1137 FALSE), /* pcrel_offset */
1138
1139 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1140 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1141 0, /* rightshift */
1142 1, /* size (0 = byte, 1 = short, 2 = long) */
1143 16, /* bitsize */
1144 FALSE, /* pc_relative */
1145 0, /* bitpos */
1146 complain_overflow_dont,/* complain_on_overflow */
1147 bfd_elf_generic_reloc, /* special_function */
1148 "R_PPC64_ADDR16_LO_DS",/* name */
1149 FALSE, /* partial_inplace */
1150 0, /* src_mask */
1151 0xfffc, /* dst_mask */
1152 FALSE), /* pcrel_offset */
1153
1154 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1155 HOWTO (R_PPC64_GOT16_DS, /* type */
1156 0, /* rightshift */
1157 1, /* size (0 = byte, 1 = short, 2 = long) */
1158 16, /* bitsize */
1159 FALSE, /* pc_relative */
1160 0, /* bitpos */
1161 complain_overflow_signed, /* complain_on_overflow */
1162 ppc64_elf_unhandled_reloc, /* special_function */
1163 "R_PPC64_GOT16_DS", /* name */
1164 FALSE, /* partial_inplace */
1165 0, /* src_mask */
1166 0xfffc, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1168
1169 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1170 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1171 0, /* rightshift */
1172 1, /* size (0 = byte, 1 = short, 2 = long) */
1173 16, /* bitsize */
1174 FALSE, /* pc_relative */
1175 0, /* bitpos */
1176 complain_overflow_dont, /* complain_on_overflow */
1177 ppc64_elf_unhandled_reloc, /* special_function */
1178 "R_PPC64_GOT16_LO_DS", /* name */
1179 FALSE, /* partial_inplace */
1180 0, /* src_mask */
1181 0xfffc, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1183
1184 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1185 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1186 0, /* rightshift */
1187 1, /* size (0 = byte, 1 = short, 2 = long) */
1188 16, /* bitsize */
1189 FALSE, /* pc_relative */
1190 0, /* bitpos */
1191 complain_overflow_dont, /* complain_on_overflow */
1192 ppc64_elf_unhandled_reloc, /* special_function */
1193 "R_PPC64_PLT16_LO_DS", /* name */
1194 FALSE, /* partial_inplace */
1195 0, /* src_mask */
1196 0xfffc, /* dst_mask */
1197 FALSE), /* pcrel_offset */
1198
1199 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1200 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1201 0, /* rightshift */
1202 1, /* size (0 = byte, 1 = short, 2 = long) */
1203 16, /* bitsize */
1204 FALSE, /* pc_relative */
1205 0, /* bitpos */
1206 complain_overflow_signed, /* complain_on_overflow */
1207 ppc64_elf_sectoff_reloc, /* special_function */
1208 "R_PPC64_SECTOFF_DS", /* name */
1209 FALSE, /* partial_inplace */
1210 0, /* src_mask */
1211 0xfffc, /* dst_mask */
1212 FALSE), /* pcrel_offset */
1213
1214 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1215 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1216 0, /* rightshift */
1217 1, /* size (0 = byte, 1 = short, 2 = long) */
1218 16, /* bitsize */
1219 FALSE, /* pc_relative */
1220 0, /* bitpos */
1221 complain_overflow_dont, /* complain_on_overflow */
1222 ppc64_elf_sectoff_reloc, /* special_function */
1223 "R_PPC64_SECTOFF_LO_DS",/* name */
1224 FALSE, /* partial_inplace */
1225 0, /* src_mask */
1226 0xfffc, /* dst_mask */
1227 FALSE), /* pcrel_offset */
1228
1229 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1230 HOWTO (R_PPC64_TOC16_DS, /* type */
1231 0, /* rightshift */
1232 1, /* size (0 = byte, 1 = short, 2 = long) */
1233 16, /* bitsize */
1234 FALSE, /* pc_relative */
1235 0, /* bitpos */
1236 complain_overflow_signed, /* complain_on_overflow */
1237 ppc64_elf_toc_reloc, /* special_function */
1238 "R_PPC64_TOC16_DS", /* name */
1239 FALSE, /* partial_inplace */
1240 0, /* src_mask */
1241 0xfffc, /* dst_mask */
1242 FALSE), /* pcrel_offset */
1243
1244 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1245 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1246 0, /* rightshift */
1247 1, /* size (0 = byte, 1 = short, 2 = long) */
1248 16, /* bitsize */
1249 FALSE, /* pc_relative */
1250 0, /* bitpos */
1251 complain_overflow_dont, /* complain_on_overflow */
1252 ppc64_elf_toc_reloc, /* special_function */
1253 "R_PPC64_TOC16_LO_DS", /* name */
1254 FALSE, /* partial_inplace */
1255 0, /* src_mask */
1256 0xfffc, /* dst_mask */
1257 FALSE), /* pcrel_offset */
1258
1259 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1260 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1261 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1262 0, /* rightshift */
1263 1, /* size (0 = byte, 1 = short, 2 = long) */
1264 16, /* bitsize */
1265 FALSE, /* pc_relative */
1266 0, /* bitpos */
1267 complain_overflow_signed, /* complain_on_overflow */
1268 ppc64_elf_unhandled_reloc, /* special_function */
1269 "R_PPC64_PLTGOT16_DS", /* name */
1270 FALSE, /* partial_inplace */
1271 0, /* src_mask */
1272 0xfffc, /* dst_mask */
1273 FALSE), /* pcrel_offset */
1274
1275 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1276 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1277 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1278 0, /* rightshift */
1279 1, /* size (0 = byte, 1 = short, 2 = long) */
1280 16, /* bitsize */
1281 FALSE, /* pc_relative */
1282 0, /* bitpos */
1283 complain_overflow_dont, /* complain_on_overflow */
1284 ppc64_elf_unhandled_reloc, /* special_function */
1285 "R_PPC64_PLTGOT16_LO_DS",/* name */
1286 FALSE, /* partial_inplace */
1287 0, /* src_mask */
1288 0xfffc, /* dst_mask */
1289 FALSE), /* pcrel_offset */
1290
1291 /* Marker relocs for TLS. */
1292 HOWTO (R_PPC64_TLS,
1293 0, /* rightshift */
1294 2, /* size (0 = byte, 1 = short, 2 = long) */
1295 32, /* bitsize */
1296 FALSE, /* pc_relative */
1297 0, /* bitpos */
1298 complain_overflow_dont, /* complain_on_overflow */
1299 bfd_elf_generic_reloc, /* special_function */
1300 "R_PPC64_TLS", /* name */
1301 FALSE, /* partial_inplace */
1302 0, /* src_mask */
1303 0, /* dst_mask */
1304 FALSE), /* pcrel_offset */
1305
1306 HOWTO (R_PPC64_TLSGD,
1307 0, /* rightshift */
1308 2, /* size (0 = byte, 1 = short, 2 = long) */
1309 32, /* bitsize */
1310 FALSE, /* pc_relative */
1311 0, /* bitpos */
1312 complain_overflow_dont, /* complain_on_overflow */
1313 bfd_elf_generic_reloc, /* special_function */
1314 "R_PPC64_TLSGD", /* name */
1315 FALSE, /* partial_inplace */
1316 0, /* src_mask */
1317 0, /* dst_mask */
1318 FALSE), /* pcrel_offset */
1319
1320 HOWTO (R_PPC64_TLSLD,
1321 0, /* rightshift */
1322 2, /* size (0 = byte, 1 = short, 2 = long) */
1323 32, /* bitsize */
1324 FALSE, /* pc_relative */
1325 0, /* bitpos */
1326 complain_overflow_dont, /* complain_on_overflow */
1327 bfd_elf_generic_reloc, /* special_function */
1328 "R_PPC64_TLSLD", /* name */
1329 FALSE, /* partial_inplace */
1330 0, /* src_mask */
1331 0, /* dst_mask */
1332 FALSE), /* pcrel_offset */
1333
1334 HOWTO (R_PPC64_TOCSAVE,
1335 0, /* rightshift */
1336 2, /* size (0 = byte, 1 = short, 2 = long) */
1337 32, /* bitsize */
1338 FALSE, /* pc_relative */
1339 0, /* bitpos */
1340 complain_overflow_dont, /* complain_on_overflow */
1341 bfd_elf_generic_reloc, /* special_function */
1342 "R_PPC64_TOCSAVE", /* name */
1343 FALSE, /* partial_inplace */
1344 0, /* src_mask */
1345 0, /* dst_mask */
1346 FALSE), /* pcrel_offset */
1347
1348 /* Computes the load module index of the load module that contains the
1349 definition of its TLS sym. */
1350 HOWTO (R_PPC64_DTPMOD64,
1351 0, /* rightshift */
1352 4, /* size (0 = byte, 1 = short, 2 = long) */
1353 64, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 ppc64_elf_unhandled_reloc, /* special_function */
1358 "R_PPC64_DTPMOD64", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 ONES (64), /* dst_mask */
1362 FALSE), /* pcrel_offset */
1363
1364 /* Computes a dtv-relative displacement, the difference between the value
1365 of sym+add and the base address of the thread-local storage block that
1366 contains the definition of sym, minus 0x8000. */
1367 HOWTO (R_PPC64_DTPREL64,
1368 0, /* rightshift */
1369 4, /* size (0 = byte, 1 = short, 2 = long) */
1370 64, /* bitsize */
1371 FALSE, /* pc_relative */
1372 0, /* bitpos */
1373 complain_overflow_dont, /* complain_on_overflow */
1374 ppc64_elf_unhandled_reloc, /* special_function */
1375 "R_PPC64_DTPREL64", /* name */
1376 FALSE, /* partial_inplace */
1377 0, /* src_mask */
1378 ONES (64), /* dst_mask */
1379 FALSE), /* pcrel_offset */
1380
1381 /* A 16 bit dtprel reloc. */
1382 HOWTO (R_PPC64_DTPREL16,
1383 0, /* rightshift */
1384 1, /* size (0 = byte, 1 = short, 2 = long) */
1385 16, /* bitsize */
1386 FALSE, /* pc_relative */
1387 0, /* bitpos */
1388 complain_overflow_signed, /* complain_on_overflow */
1389 ppc64_elf_unhandled_reloc, /* special_function */
1390 "R_PPC64_DTPREL16", /* name */
1391 FALSE, /* partial_inplace */
1392 0, /* src_mask */
1393 0xffff, /* dst_mask */
1394 FALSE), /* pcrel_offset */
1395
1396 /* Like DTPREL16, but no overflow. */
1397 HOWTO (R_PPC64_DTPREL16_LO,
1398 0, /* rightshift */
1399 1, /* size (0 = byte, 1 = short, 2 = long) */
1400 16, /* bitsize */
1401 FALSE, /* pc_relative */
1402 0, /* bitpos */
1403 complain_overflow_dont, /* complain_on_overflow */
1404 ppc64_elf_unhandled_reloc, /* special_function */
1405 "R_PPC64_DTPREL16_LO", /* name */
1406 FALSE, /* partial_inplace */
1407 0, /* src_mask */
1408 0xffff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1410
1411 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1412 HOWTO (R_PPC64_DTPREL16_HI,
1413 16, /* rightshift */
1414 1, /* size (0 = byte, 1 = short, 2 = long) */
1415 16, /* bitsize */
1416 FALSE, /* pc_relative */
1417 0, /* bitpos */
1418 complain_overflow_signed, /* complain_on_overflow */
1419 ppc64_elf_unhandled_reloc, /* special_function */
1420 "R_PPC64_DTPREL16_HI", /* name */
1421 FALSE, /* partial_inplace */
1422 0, /* src_mask */
1423 0xffff, /* dst_mask */
1424 FALSE), /* pcrel_offset */
1425
1426 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1427 HOWTO (R_PPC64_DTPREL16_HA,
1428 16, /* rightshift */
1429 1, /* size (0 = byte, 1 = short, 2 = long) */
1430 16, /* bitsize */
1431 FALSE, /* pc_relative */
1432 0, /* bitpos */
1433 complain_overflow_signed, /* complain_on_overflow */
1434 ppc64_elf_unhandled_reloc, /* special_function */
1435 "R_PPC64_DTPREL16_HA", /* name */
1436 FALSE, /* partial_inplace */
1437 0, /* src_mask */
1438 0xffff, /* dst_mask */
1439 FALSE), /* pcrel_offset */
1440
1441 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1442 HOWTO (R_PPC64_DTPREL16_HIGHER,
1443 32, /* rightshift */
1444 1, /* size (0 = byte, 1 = short, 2 = long) */
1445 16, /* bitsize */
1446 FALSE, /* pc_relative */
1447 0, /* bitpos */
1448 complain_overflow_dont, /* complain_on_overflow */
1449 ppc64_elf_unhandled_reloc, /* special_function */
1450 "R_PPC64_DTPREL16_HIGHER", /* name */
1451 FALSE, /* partial_inplace */
1452 0, /* src_mask */
1453 0xffff, /* dst_mask */
1454 FALSE), /* pcrel_offset */
1455
1456 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1457 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1458 32, /* rightshift */
1459 1, /* size (0 = byte, 1 = short, 2 = long) */
1460 16, /* bitsize */
1461 FALSE, /* pc_relative */
1462 0, /* bitpos */
1463 complain_overflow_dont, /* complain_on_overflow */
1464 ppc64_elf_unhandled_reloc, /* special_function */
1465 "R_PPC64_DTPREL16_HIGHERA", /* name */
1466 FALSE, /* partial_inplace */
1467 0, /* src_mask */
1468 0xffff, /* dst_mask */
1469 FALSE), /* pcrel_offset */
1470
1471 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1472 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1473 48, /* rightshift */
1474 1, /* size (0 = byte, 1 = short, 2 = long) */
1475 16, /* bitsize */
1476 FALSE, /* pc_relative */
1477 0, /* bitpos */
1478 complain_overflow_dont, /* complain_on_overflow */
1479 ppc64_elf_unhandled_reloc, /* special_function */
1480 "R_PPC64_DTPREL16_HIGHEST", /* name */
1481 FALSE, /* partial_inplace */
1482 0, /* src_mask */
1483 0xffff, /* dst_mask */
1484 FALSE), /* pcrel_offset */
1485
1486 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1487 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1488 48, /* rightshift */
1489 1, /* size (0 = byte, 1 = short, 2 = long) */
1490 16, /* bitsize */
1491 FALSE, /* pc_relative */
1492 0, /* bitpos */
1493 complain_overflow_dont, /* complain_on_overflow */
1494 ppc64_elf_unhandled_reloc, /* special_function */
1495 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1496 FALSE, /* partial_inplace */
1497 0, /* src_mask */
1498 0xffff, /* dst_mask */
1499 FALSE), /* pcrel_offset */
1500
1501 /* Like DTPREL16, but for insns with a DS field. */
1502 HOWTO (R_PPC64_DTPREL16_DS,
1503 0, /* rightshift */
1504 1, /* size (0 = byte, 1 = short, 2 = long) */
1505 16, /* bitsize */
1506 FALSE, /* pc_relative */
1507 0, /* bitpos */
1508 complain_overflow_signed, /* complain_on_overflow */
1509 ppc64_elf_unhandled_reloc, /* special_function */
1510 "R_PPC64_DTPREL16_DS", /* name */
1511 FALSE, /* partial_inplace */
1512 0, /* src_mask */
1513 0xfffc, /* dst_mask */
1514 FALSE), /* pcrel_offset */
1515
1516 /* Like DTPREL16_DS, but no overflow. */
1517 HOWTO (R_PPC64_DTPREL16_LO_DS,
1518 0, /* rightshift */
1519 1, /* size (0 = byte, 1 = short, 2 = long) */
1520 16, /* bitsize */
1521 FALSE, /* pc_relative */
1522 0, /* bitpos */
1523 complain_overflow_dont, /* complain_on_overflow */
1524 ppc64_elf_unhandled_reloc, /* special_function */
1525 "R_PPC64_DTPREL16_LO_DS", /* name */
1526 FALSE, /* partial_inplace */
1527 0, /* src_mask */
1528 0xfffc, /* dst_mask */
1529 FALSE), /* pcrel_offset */
1530
1531 /* Computes a tp-relative displacement, the difference between the value of
1532 sym+add and the value of the thread pointer (r13). */
1533 HOWTO (R_PPC64_TPREL64,
1534 0, /* rightshift */
1535 4, /* size (0 = byte, 1 = short, 2 = long) */
1536 64, /* bitsize */
1537 FALSE, /* pc_relative */
1538 0, /* bitpos */
1539 complain_overflow_dont, /* complain_on_overflow */
1540 ppc64_elf_unhandled_reloc, /* special_function */
1541 "R_PPC64_TPREL64", /* name */
1542 FALSE, /* partial_inplace */
1543 0, /* src_mask */
1544 ONES (64), /* dst_mask */
1545 FALSE), /* pcrel_offset */
1546
1547 /* A 16 bit tprel reloc. */
1548 HOWTO (R_PPC64_TPREL16,
1549 0, /* rightshift */
1550 1, /* size (0 = byte, 1 = short, 2 = long) */
1551 16, /* bitsize */
1552 FALSE, /* pc_relative */
1553 0, /* bitpos */
1554 complain_overflow_signed, /* complain_on_overflow */
1555 ppc64_elf_unhandled_reloc, /* special_function */
1556 "R_PPC64_TPREL16", /* name */
1557 FALSE, /* partial_inplace */
1558 0, /* src_mask */
1559 0xffff, /* dst_mask */
1560 FALSE), /* pcrel_offset */
1561
1562 /* Like TPREL16, but no overflow. */
1563 HOWTO (R_PPC64_TPREL16_LO,
1564 0, /* rightshift */
1565 1, /* size (0 = byte, 1 = short, 2 = long) */
1566 16, /* bitsize */
1567 FALSE, /* pc_relative */
1568 0, /* bitpos */
1569 complain_overflow_dont, /* complain_on_overflow */
1570 ppc64_elf_unhandled_reloc, /* special_function */
1571 "R_PPC64_TPREL16_LO", /* name */
1572 FALSE, /* partial_inplace */
1573 0, /* src_mask */
1574 0xffff, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1576
1577 /* Like TPREL16_LO, but next higher group of 16 bits. */
1578 HOWTO (R_PPC64_TPREL16_HI,
1579 16, /* rightshift */
1580 1, /* size (0 = byte, 1 = short, 2 = long) */
1581 16, /* bitsize */
1582 FALSE, /* pc_relative */
1583 0, /* bitpos */
1584 complain_overflow_signed, /* complain_on_overflow */
1585 ppc64_elf_unhandled_reloc, /* special_function */
1586 "R_PPC64_TPREL16_HI", /* name */
1587 FALSE, /* partial_inplace */
1588 0, /* src_mask */
1589 0xffff, /* dst_mask */
1590 FALSE), /* pcrel_offset */
1591
1592 /* Like TPREL16_HI, but adjust for low 16 bits. */
1593 HOWTO (R_PPC64_TPREL16_HA,
1594 16, /* rightshift */
1595 1, /* size (0 = byte, 1 = short, 2 = long) */
1596 16, /* bitsize */
1597 FALSE, /* pc_relative */
1598 0, /* bitpos */
1599 complain_overflow_signed, /* complain_on_overflow */
1600 ppc64_elf_unhandled_reloc, /* special_function */
1601 "R_PPC64_TPREL16_HA", /* name */
1602 FALSE, /* partial_inplace */
1603 0, /* src_mask */
1604 0xffff, /* dst_mask */
1605 FALSE), /* pcrel_offset */
1606
1607 /* Like TPREL16_HI, but next higher group of 16 bits. */
1608 HOWTO (R_PPC64_TPREL16_HIGHER,
1609 32, /* rightshift */
1610 1, /* size (0 = byte, 1 = short, 2 = long) */
1611 16, /* bitsize */
1612 FALSE, /* pc_relative */
1613 0, /* bitpos */
1614 complain_overflow_dont, /* complain_on_overflow */
1615 ppc64_elf_unhandled_reloc, /* special_function */
1616 "R_PPC64_TPREL16_HIGHER", /* name */
1617 FALSE, /* partial_inplace */
1618 0, /* src_mask */
1619 0xffff, /* dst_mask */
1620 FALSE), /* pcrel_offset */
1621
1622 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1623 HOWTO (R_PPC64_TPREL16_HIGHERA,
1624 32, /* rightshift */
1625 1, /* size (0 = byte, 1 = short, 2 = long) */
1626 16, /* bitsize */
1627 FALSE, /* pc_relative */
1628 0, /* bitpos */
1629 complain_overflow_dont, /* complain_on_overflow */
1630 ppc64_elf_unhandled_reloc, /* special_function */
1631 "R_PPC64_TPREL16_HIGHERA", /* name */
1632 FALSE, /* partial_inplace */
1633 0, /* src_mask */
1634 0xffff, /* dst_mask */
1635 FALSE), /* pcrel_offset */
1636
1637 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1638 HOWTO (R_PPC64_TPREL16_HIGHEST,
1639 48, /* rightshift */
1640 1, /* size (0 = byte, 1 = short, 2 = long) */
1641 16, /* bitsize */
1642 FALSE, /* pc_relative */
1643 0, /* bitpos */
1644 complain_overflow_dont, /* complain_on_overflow */
1645 ppc64_elf_unhandled_reloc, /* special_function */
1646 "R_PPC64_TPREL16_HIGHEST", /* name */
1647 FALSE, /* partial_inplace */
1648 0, /* src_mask */
1649 0xffff, /* dst_mask */
1650 FALSE), /* pcrel_offset */
1651
1652 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1653 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1654 48, /* rightshift */
1655 1, /* size (0 = byte, 1 = short, 2 = long) */
1656 16, /* bitsize */
1657 FALSE, /* pc_relative */
1658 0, /* bitpos */
1659 complain_overflow_dont, /* complain_on_overflow */
1660 ppc64_elf_unhandled_reloc, /* special_function */
1661 "R_PPC64_TPREL16_HIGHESTA", /* name */
1662 FALSE, /* partial_inplace */
1663 0, /* src_mask */
1664 0xffff, /* dst_mask */
1665 FALSE), /* pcrel_offset */
1666
1667 /* Like TPREL16, but for insns with a DS field. */
1668 HOWTO (R_PPC64_TPREL16_DS,
1669 0, /* rightshift */
1670 1, /* size (0 = byte, 1 = short, 2 = long) */
1671 16, /* bitsize */
1672 FALSE, /* pc_relative */
1673 0, /* bitpos */
1674 complain_overflow_signed, /* complain_on_overflow */
1675 ppc64_elf_unhandled_reloc, /* special_function */
1676 "R_PPC64_TPREL16_DS", /* name */
1677 FALSE, /* partial_inplace */
1678 0, /* src_mask */
1679 0xfffc, /* dst_mask */
1680 FALSE), /* pcrel_offset */
1681
1682 /* Like TPREL16_DS, but no overflow. */
1683 HOWTO (R_PPC64_TPREL16_LO_DS,
1684 0, /* rightshift */
1685 1, /* size (0 = byte, 1 = short, 2 = long) */
1686 16, /* bitsize */
1687 FALSE, /* pc_relative */
1688 0, /* bitpos */
1689 complain_overflow_dont, /* complain_on_overflow */
1690 ppc64_elf_unhandled_reloc, /* special_function */
1691 "R_PPC64_TPREL16_LO_DS", /* name */
1692 FALSE, /* partial_inplace */
1693 0, /* src_mask */
1694 0xfffc, /* dst_mask */
1695 FALSE), /* pcrel_offset */
1696
1697 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1698 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1699 to the first entry relative to the TOC base (r2). */
1700 HOWTO (R_PPC64_GOT_TLSGD16,
1701 0, /* rightshift */
1702 1, /* size (0 = byte, 1 = short, 2 = long) */
1703 16, /* bitsize */
1704 FALSE, /* pc_relative */
1705 0, /* bitpos */
1706 complain_overflow_signed, /* complain_on_overflow */
1707 ppc64_elf_unhandled_reloc, /* special_function */
1708 "R_PPC64_GOT_TLSGD16", /* name */
1709 FALSE, /* partial_inplace */
1710 0, /* src_mask */
1711 0xffff, /* dst_mask */
1712 FALSE), /* pcrel_offset */
1713
1714 /* Like GOT_TLSGD16, but no overflow. */
1715 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1716 0, /* rightshift */
1717 1, /* size (0 = byte, 1 = short, 2 = long) */
1718 16, /* bitsize */
1719 FALSE, /* pc_relative */
1720 0, /* bitpos */
1721 complain_overflow_dont, /* complain_on_overflow */
1722 ppc64_elf_unhandled_reloc, /* special_function */
1723 "R_PPC64_GOT_TLSGD16_LO", /* name */
1724 FALSE, /* partial_inplace */
1725 0, /* src_mask */
1726 0xffff, /* dst_mask */
1727 FALSE), /* pcrel_offset */
1728
1729 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1730 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1731 16, /* rightshift */
1732 1, /* size (0 = byte, 1 = short, 2 = long) */
1733 16, /* bitsize */
1734 FALSE, /* pc_relative */
1735 0, /* bitpos */
1736 complain_overflow_signed, /* complain_on_overflow */
1737 ppc64_elf_unhandled_reloc, /* special_function */
1738 "R_PPC64_GOT_TLSGD16_HI", /* name */
1739 FALSE, /* partial_inplace */
1740 0, /* src_mask */
1741 0xffff, /* dst_mask */
1742 FALSE), /* pcrel_offset */
1743
1744 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1745 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1746 16, /* rightshift */
1747 1, /* size (0 = byte, 1 = short, 2 = long) */
1748 16, /* bitsize */
1749 FALSE, /* pc_relative */
1750 0, /* bitpos */
1751 complain_overflow_signed, /* complain_on_overflow */
1752 ppc64_elf_unhandled_reloc, /* special_function */
1753 "R_PPC64_GOT_TLSGD16_HA", /* name */
1754 FALSE, /* partial_inplace */
1755 0, /* src_mask */
1756 0xffff, /* dst_mask */
1757 FALSE), /* pcrel_offset */
1758
1759 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1760 with values (sym+add)@dtpmod and zero, and computes the offset to the
1761 first entry relative to the TOC base (r2). */
1762 HOWTO (R_PPC64_GOT_TLSLD16,
1763 0, /* rightshift */
1764 1, /* size (0 = byte, 1 = short, 2 = long) */
1765 16, /* bitsize */
1766 FALSE, /* pc_relative */
1767 0, /* bitpos */
1768 complain_overflow_signed, /* complain_on_overflow */
1769 ppc64_elf_unhandled_reloc, /* special_function */
1770 "R_PPC64_GOT_TLSLD16", /* name */
1771 FALSE, /* partial_inplace */
1772 0, /* src_mask */
1773 0xffff, /* dst_mask */
1774 FALSE), /* pcrel_offset */
1775
1776 /* Like GOT_TLSLD16, but no overflow. */
1777 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1778 0, /* rightshift */
1779 1, /* size (0 = byte, 1 = short, 2 = long) */
1780 16, /* bitsize */
1781 FALSE, /* pc_relative */
1782 0, /* bitpos */
1783 complain_overflow_dont, /* complain_on_overflow */
1784 ppc64_elf_unhandled_reloc, /* special_function */
1785 "R_PPC64_GOT_TLSLD16_LO", /* name */
1786 FALSE, /* partial_inplace */
1787 0, /* src_mask */
1788 0xffff, /* dst_mask */
1789 FALSE), /* pcrel_offset */
1790
1791 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1792 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1793 16, /* rightshift */
1794 1, /* size (0 = byte, 1 = short, 2 = long) */
1795 16, /* bitsize */
1796 FALSE, /* pc_relative */
1797 0, /* bitpos */
1798 complain_overflow_signed, /* complain_on_overflow */
1799 ppc64_elf_unhandled_reloc, /* special_function */
1800 "R_PPC64_GOT_TLSLD16_HI", /* name */
1801 FALSE, /* partial_inplace */
1802 0, /* src_mask */
1803 0xffff, /* dst_mask */
1804 FALSE), /* pcrel_offset */
1805
1806 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1807 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1808 16, /* rightshift */
1809 1, /* size (0 = byte, 1 = short, 2 = long) */
1810 16, /* bitsize */
1811 FALSE, /* pc_relative */
1812 0, /* bitpos */
1813 complain_overflow_signed, /* complain_on_overflow */
1814 ppc64_elf_unhandled_reloc, /* special_function */
1815 "R_PPC64_GOT_TLSLD16_HA", /* name */
1816 FALSE, /* partial_inplace */
1817 0, /* src_mask */
1818 0xffff, /* dst_mask */
1819 FALSE), /* pcrel_offset */
1820
1821 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1822 the offset to the entry relative to the TOC base (r2). */
1823 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1824 0, /* rightshift */
1825 1, /* size (0 = byte, 1 = short, 2 = long) */
1826 16, /* bitsize */
1827 FALSE, /* pc_relative */
1828 0, /* bitpos */
1829 complain_overflow_signed, /* complain_on_overflow */
1830 ppc64_elf_unhandled_reloc, /* special_function */
1831 "R_PPC64_GOT_DTPREL16_DS", /* name */
1832 FALSE, /* partial_inplace */
1833 0, /* src_mask */
1834 0xfffc, /* dst_mask */
1835 FALSE), /* pcrel_offset */
1836
1837 /* Like GOT_DTPREL16_DS, but no overflow. */
1838 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1839 0, /* rightshift */
1840 1, /* size (0 = byte, 1 = short, 2 = long) */
1841 16, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_dont, /* complain_on_overflow */
1845 ppc64_elf_unhandled_reloc, /* special_function */
1846 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1847 FALSE, /* partial_inplace */
1848 0, /* src_mask */
1849 0xfffc, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1853 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1854 16, /* rightshift */
1855 1, /* size (0 = byte, 1 = short, 2 = long) */
1856 16, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_signed, /* complain_on_overflow */
1860 ppc64_elf_unhandled_reloc, /* special_function */
1861 "R_PPC64_GOT_DTPREL16_HI", /* name */
1862 FALSE, /* partial_inplace */
1863 0, /* src_mask */
1864 0xffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1868 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1869 16, /* rightshift */
1870 1, /* size (0 = byte, 1 = short, 2 = long) */
1871 16, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 ppc64_elf_unhandled_reloc, /* special_function */
1876 "R_PPC64_GOT_DTPREL16_HA", /* name */
1877 FALSE, /* partial_inplace */
1878 0, /* src_mask */
1879 0xffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1883 offset to the entry relative to the TOC base (r2). */
1884 HOWTO (R_PPC64_GOT_TPREL16_DS,
1885 0, /* rightshift */
1886 1, /* size (0 = byte, 1 = short, 2 = long) */
1887 16, /* bitsize */
1888 FALSE, /* pc_relative */
1889 0, /* bitpos */
1890 complain_overflow_signed, /* complain_on_overflow */
1891 ppc64_elf_unhandled_reloc, /* special_function */
1892 "R_PPC64_GOT_TPREL16_DS", /* name */
1893 FALSE, /* partial_inplace */
1894 0, /* src_mask */
1895 0xfffc, /* dst_mask */
1896 FALSE), /* pcrel_offset */
1897
1898 /* Like GOT_TPREL16_DS, but no overflow. */
1899 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1900 0, /* rightshift */
1901 1, /* size (0 = byte, 1 = short, 2 = long) */
1902 16, /* bitsize */
1903 FALSE, /* pc_relative */
1904 0, /* bitpos */
1905 complain_overflow_dont, /* complain_on_overflow */
1906 ppc64_elf_unhandled_reloc, /* special_function */
1907 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1908 FALSE, /* partial_inplace */
1909 0, /* src_mask */
1910 0xfffc, /* dst_mask */
1911 FALSE), /* pcrel_offset */
1912
1913 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1914 HOWTO (R_PPC64_GOT_TPREL16_HI,
1915 16, /* rightshift */
1916 1, /* size (0 = byte, 1 = short, 2 = long) */
1917 16, /* bitsize */
1918 FALSE, /* pc_relative */
1919 0, /* bitpos */
1920 complain_overflow_signed, /* complain_on_overflow */
1921 ppc64_elf_unhandled_reloc, /* special_function */
1922 "R_PPC64_GOT_TPREL16_HI", /* name */
1923 FALSE, /* partial_inplace */
1924 0, /* src_mask */
1925 0xffff, /* dst_mask */
1926 FALSE), /* pcrel_offset */
1927
1928 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1929 HOWTO (R_PPC64_GOT_TPREL16_HA,
1930 16, /* rightshift */
1931 1, /* size (0 = byte, 1 = short, 2 = long) */
1932 16, /* bitsize */
1933 FALSE, /* pc_relative */
1934 0, /* bitpos */
1935 complain_overflow_signed, /* complain_on_overflow */
1936 ppc64_elf_unhandled_reloc, /* special_function */
1937 "R_PPC64_GOT_TPREL16_HA", /* name */
1938 FALSE, /* partial_inplace */
1939 0, /* src_mask */
1940 0xffff, /* dst_mask */
1941 FALSE), /* pcrel_offset */
1942
1943 HOWTO (R_PPC64_JMP_IREL, /* type */
1944 0, /* rightshift */
1945 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1946 0, /* bitsize */
1947 FALSE, /* pc_relative */
1948 0, /* bitpos */
1949 complain_overflow_dont, /* complain_on_overflow */
1950 ppc64_elf_unhandled_reloc, /* special_function */
1951 "R_PPC64_JMP_IREL", /* name */
1952 FALSE, /* partial_inplace */
1953 0, /* src_mask */
1954 0, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 HOWTO (R_PPC64_IRELATIVE, /* type */
1958 0, /* rightshift */
1959 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1960 64, /* bitsize */
1961 FALSE, /* pc_relative */
1962 0, /* bitpos */
1963 complain_overflow_dont, /* complain_on_overflow */
1964 bfd_elf_generic_reloc, /* special_function */
1965 "R_PPC64_IRELATIVE", /* name */
1966 FALSE, /* partial_inplace */
1967 0, /* src_mask */
1968 ONES (64), /* dst_mask */
1969 FALSE), /* pcrel_offset */
1970
1971 /* A 16 bit relative relocation. */
1972 HOWTO (R_PPC64_REL16, /* type */
1973 0, /* rightshift */
1974 1, /* size (0 = byte, 1 = short, 2 = long) */
1975 16, /* bitsize */
1976 TRUE, /* pc_relative */
1977 0, /* bitpos */
1978 complain_overflow_signed, /* complain_on_overflow */
1979 bfd_elf_generic_reloc, /* special_function */
1980 "R_PPC64_REL16", /* name */
1981 FALSE, /* partial_inplace */
1982 0, /* src_mask */
1983 0xffff, /* dst_mask */
1984 TRUE), /* pcrel_offset */
1985
1986 /* A 16 bit relative relocation without overflow. */
1987 HOWTO (R_PPC64_REL16_LO, /* type */
1988 0, /* rightshift */
1989 1, /* size (0 = byte, 1 = short, 2 = long) */
1990 16, /* bitsize */
1991 TRUE, /* pc_relative */
1992 0, /* bitpos */
1993 complain_overflow_dont,/* complain_on_overflow */
1994 bfd_elf_generic_reloc, /* special_function */
1995 "R_PPC64_REL16_LO", /* name */
1996 FALSE, /* partial_inplace */
1997 0, /* src_mask */
1998 0xffff, /* dst_mask */
1999 TRUE), /* pcrel_offset */
2000
2001 /* The high order 16 bits of a relative address. */
2002 HOWTO (R_PPC64_REL16_HI, /* type */
2003 16, /* rightshift */
2004 1, /* size (0 = byte, 1 = short, 2 = long) */
2005 16, /* bitsize */
2006 TRUE, /* pc_relative */
2007 0, /* bitpos */
2008 complain_overflow_signed, /* complain_on_overflow */
2009 bfd_elf_generic_reloc, /* special_function */
2010 "R_PPC64_REL16_HI", /* name */
2011 FALSE, /* partial_inplace */
2012 0, /* src_mask */
2013 0xffff, /* dst_mask */
2014 TRUE), /* pcrel_offset */
2015
2016 /* The high order 16 bits of a relative address, plus 1 if the contents of
2017 the low 16 bits, treated as a signed number, is negative. */
2018 HOWTO (R_PPC64_REL16_HA, /* type */
2019 16, /* rightshift */
2020 1, /* size (0 = byte, 1 = short, 2 = long) */
2021 16, /* bitsize */
2022 TRUE, /* pc_relative */
2023 0, /* bitpos */
2024 complain_overflow_signed, /* complain_on_overflow */
2025 ppc64_elf_ha_reloc, /* special_function */
2026 "R_PPC64_REL16_HA", /* name */
2027 FALSE, /* partial_inplace */
2028 0, /* src_mask */
2029 0xffff, /* dst_mask */
2030 TRUE), /* pcrel_offset */
2031
2032 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2033 HOWTO (R_PPC64_REL16DX_HA, /* type */
2034 16, /* rightshift */
2035 2, /* size (0 = byte, 1 = short, 2 = long) */
2036 16, /* bitsize */
2037 TRUE, /* pc_relative */
2038 0, /* bitpos */
2039 complain_overflow_signed, /* complain_on_overflow */
2040 ppc64_elf_ha_reloc, /* special_function */
2041 "R_PPC64_REL16DX_HA", /* name */
2042 FALSE, /* partial_inplace */
2043 0, /* src_mask */
2044 0x1fffc1, /* dst_mask */
2045 TRUE), /* pcrel_offset */
2046
2047 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2048 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2049 16, /* rightshift */
2050 1, /* size (0 = byte, 1 = short, 2 = long) */
2051 16, /* bitsize */
2052 FALSE, /* pc_relative */
2053 0, /* bitpos */
2054 complain_overflow_dont, /* complain_on_overflow */
2055 bfd_elf_generic_reloc, /* special_function */
2056 "R_PPC64_ADDR16_HIGH", /* name */
2057 FALSE, /* partial_inplace */
2058 0, /* src_mask */
2059 0xffff, /* dst_mask */
2060 FALSE), /* pcrel_offset */
2061
2062 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2063 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2064 16, /* rightshift */
2065 1, /* size (0 = byte, 1 = short, 2 = long) */
2066 16, /* bitsize */
2067 FALSE, /* pc_relative */
2068 0, /* bitpos */
2069 complain_overflow_dont, /* complain_on_overflow */
2070 ppc64_elf_ha_reloc, /* special_function */
2071 "R_PPC64_ADDR16_HIGHA", /* name */
2072 FALSE, /* partial_inplace */
2073 0, /* src_mask */
2074 0xffff, /* dst_mask */
2075 FALSE), /* pcrel_offset */
2076
2077 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2078 HOWTO (R_PPC64_DTPREL16_HIGH,
2079 16, /* rightshift */
2080 1, /* size (0 = byte, 1 = short, 2 = long) */
2081 16, /* bitsize */
2082 FALSE, /* pc_relative */
2083 0, /* bitpos */
2084 complain_overflow_dont, /* complain_on_overflow */
2085 ppc64_elf_unhandled_reloc, /* special_function */
2086 "R_PPC64_DTPREL16_HIGH", /* name */
2087 FALSE, /* partial_inplace */
2088 0, /* src_mask */
2089 0xffff, /* dst_mask */
2090 FALSE), /* pcrel_offset */
2091
2092 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2093 HOWTO (R_PPC64_DTPREL16_HIGHA,
2094 16, /* rightshift */
2095 1, /* size (0 = byte, 1 = short, 2 = long) */
2096 16, /* bitsize */
2097 FALSE, /* pc_relative */
2098 0, /* bitpos */
2099 complain_overflow_dont, /* complain_on_overflow */
2100 ppc64_elf_unhandled_reloc, /* special_function */
2101 "R_PPC64_DTPREL16_HIGHA", /* name */
2102 FALSE, /* partial_inplace */
2103 0, /* src_mask */
2104 0xffff, /* dst_mask */
2105 FALSE), /* pcrel_offset */
2106
2107 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2108 HOWTO (R_PPC64_TPREL16_HIGH,
2109 16, /* rightshift */
2110 1, /* size (0 = byte, 1 = short, 2 = long) */
2111 16, /* bitsize */
2112 FALSE, /* pc_relative */
2113 0, /* bitpos */
2114 complain_overflow_dont, /* complain_on_overflow */
2115 ppc64_elf_unhandled_reloc, /* special_function */
2116 "R_PPC64_TPREL16_HIGH", /* name */
2117 FALSE, /* partial_inplace */
2118 0, /* src_mask */
2119 0xffff, /* dst_mask */
2120 FALSE), /* pcrel_offset */
2121
2122 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2123 HOWTO (R_PPC64_TPREL16_HIGHA,
2124 16, /* rightshift */
2125 1, /* size (0 = byte, 1 = short, 2 = long) */
2126 16, /* bitsize */
2127 FALSE, /* pc_relative */
2128 0, /* bitpos */
2129 complain_overflow_dont, /* complain_on_overflow */
2130 ppc64_elf_unhandled_reloc, /* special_function */
2131 "R_PPC64_TPREL16_HIGHA", /* name */
2132 FALSE, /* partial_inplace */
2133 0, /* src_mask */
2134 0xffff, /* dst_mask */
2135 FALSE), /* pcrel_offset */
2136
2137 /* Marker reloc on ELFv2 large-model function entry. */
2138 HOWTO (R_PPC64_ENTRY,
2139 0, /* rightshift */
2140 2, /* size (0 = byte, 1 = short, 2 = long) */
2141 32, /* bitsize */
2142 FALSE, /* pc_relative */
2143 0, /* bitpos */
2144 complain_overflow_dont, /* complain_on_overflow */
2145 bfd_elf_generic_reloc, /* special_function */
2146 "R_PPC64_ENTRY", /* name */
2147 FALSE, /* partial_inplace */
2148 0, /* src_mask */
2149 0, /* dst_mask */
2150 FALSE), /* pcrel_offset */
2151
2152 /* Like ADDR64, but use local entry point of function. */
2153 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2154 0, /* rightshift */
2155 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2156 64, /* bitsize */
2157 FALSE, /* pc_relative */
2158 0, /* bitpos */
2159 complain_overflow_dont, /* complain_on_overflow */
2160 bfd_elf_generic_reloc, /* special_function */
2161 "R_PPC64_ADDR64_LOCAL", /* name */
2162 FALSE, /* partial_inplace */
2163 0, /* src_mask */
2164 ONES (64), /* dst_mask */
2165 FALSE), /* pcrel_offset */
2166
2167 /* GNU extension to record C++ vtable hierarchy. */
2168 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2169 0, /* rightshift */
2170 0, /* size (0 = byte, 1 = short, 2 = long) */
2171 0, /* bitsize */
2172 FALSE, /* pc_relative */
2173 0, /* bitpos */
2174 complain_overflow_dont, /* complain_on_overflow */
2175 NULL, /* special_function */
2176 "R_PPC64_GNU_VTINHERIT", /* name */
2177 FALSE, /* partial_inplace */
2178 0, /* src_mask */
2179 0, /* dst_mask */
2180 FALSE), /* pcrel_offset */
2181
2182 /* GNU extension to record C++ vtable member usage. */
2183 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2184 0, /* rightshift */
2185 0, /* size (0 = byte, 1 = short, 2 = long) */
2186 0, /* bitsize */
2187 FALSE, /* pc_relative */
2188 0, /* bitpos */
2189 complain_overflow_dont, /* complain_on_overflow */
2190 NULL, /* special_function */
2191 "R_PPC64_GNU_VTENTRY", /* name */
2192 FALSE, /* partial_inplace */
2193 0, /* src_mask */
2194 0, /* dst_mask */
2195 FALSE), /* pcrel_offset */
2196 };
2197
2198 \f
2199 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2200 be done. */
2201
2202 static void
2203 ppc_howto_init (void)
2204 {
2205 unsigned int i, type;
2206
2207 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2208 {
2209 type = ppc64_elf_howto_raw[i].type;
2210 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2211 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2212 }
2213 }
2214
2215 static reloc_howto_type *
2216 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2217 bfd_reloc_code_real_type code)
2218 {
2219 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2220
2221 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2222 /* Initialize howto table if needed. */
2223 ppc_howto_init ();
2224
2225 switch (code)
2226 {
2227 default:
2228 return NULL;
2229
2230 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2231 break;
2232 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2233 break;
2234 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2235 break;
2236 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2237 break;
2238 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2239 break;
2240 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2241 break;
2242 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2243 break;
2244 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2245 break;
2246 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2247 break;
2248 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2249 break;
2250 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2251 break;
2252 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2253 break;
2254 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2255 break;
2256 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2257 break;
2258 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2259 break;
2260 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2261 break;
2262 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2263 break;
2264 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2265 break;
2266 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2267 break;
2268 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2269 break;
2270 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2271 break;
2272 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2273 break;
2274 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2275 break;
2276 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2277 break;
2278 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2279 break;
2280 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2281 break;
2282 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2283 break;
2284 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2285 break;
2286 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2287 break;
2288 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2289 break;
2290 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2291 break;
2292 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2293 break;
2294 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2295 break;
2296 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2297 break;
2298 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2299 break;
2300 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2301 break;
2302 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2303 break;
2304 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2305 break;
2306 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2307 break;
2308 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2309 break;
2310 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2311 break;
2312 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2313 break;
2314 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2315 break;
2316 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2317 break;
2318 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2319 break;
2320 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2321 break;
2322 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2323 break;
2324 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2325 break;
2326 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2327 break;
2328 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2329 break;
2330 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2331 break;
2332 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2333 break;
2334 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2335 break;
2336 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2337 break;
2338 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2339 break;
2340 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2341 break;
2342 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2343 break;
2344 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2345 break;
2346 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2347 break;
2348 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2349 break;
2350 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2351 break;
2352 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2353 break;
2354 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2355 break;
2356 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2357 break;
2358 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2359 break;
2360 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2361 break;
2362 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2363 break;
2364 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2365 break;
2366 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2367 break;
2368 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2369 break;
2370 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2371 break;
2372 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2373 break;
2374 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2375 break;
2376 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2377 break;
2378 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2379 break;
2380 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2381 break;
2382 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2383 break;
2384 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2385 break;
2386 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2387 break;
2388 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2389 break;
2390 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2391 break;
2392 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2393 break;
2394 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2395 break;
2396 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2397 break;
2398 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2399 break;
2400 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2401 break;
2402 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2403 break;
2404 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2405 break;
2406 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2407 break;
2408 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2409 break;
2410 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2411 break;
2412 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2413 break;
2414 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2415 break;
2416 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2417 break;
2418 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2419 break;
2420 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2421 break;
2422 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2423 break;
2424 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2425 break;
2426 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2427 break;
2428 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2429 break;
2430 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2431 break;
2432 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2433 break;
2434 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2435 break;
2436 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2437 break;
2438 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2439 break;
2440 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2441 break;
2442 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2443 break;
2444 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2445 break;
2446 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2447 break;
2448 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2449 break;
2450 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2451 break;
2452 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2453 break;
2454 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2455 break;
2456 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2457 break;
2458 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2459 break;
2460 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2461 break;
2462 }
2463
2464 return ppc64_elf_howto_table[r];
2465 };
2466
2467 static reloc_howto_type *
2468 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2469 const char *r_name)
2470 {
2471 unsigned int i;
2472
2473 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2474 if (ppc64_elf_howto_raw[i].name != NULL
2475 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2476 return &ppc64_elf_howto_raw[i];
2477
2478 return NULL;
2479 }
2480
2481 /* Set the howto pointer for a PowerPC ELF reloc. */
2482
2483 static void
2484 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2485 Elf_Internal_Rela *dst)
2486 {
2487 unsigned int type;
2488
2489 /* Initialize howto table if needed. */
2490 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2491 ppc_howto_init ();
2492
2493 type = ELF64_R_TYPE (dst->r_info);
2494 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2495 {
2496 /* xgettext:c-format */
2497 _bfd_error_handler (_("%B: invalid relocation type %d"),
2498 abfd, (int) type);
2499 type = R_PPC64_NONE;
2500 }
2501 cache_ptr->howto = ppc64_elf_howto_table[type];
2502 }
2503
2504 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2505
2506 static bfd_reloc_status_type
2507 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2508 void *data, asection *input_section,
2509 bfd *output_bfd, char **error_message)
2510 {
2511 enum elf_ppc64_reloc_type r_type;
2512 long insn;
2513 bfd_size_type octets;
2514 bfd_vma value;
2515
2516 /* If this is a relocatable link (output_bfd test tells us), just
2517 call the generic function. Any adjustment will be done at final
2518 link time. */
2519 if (output_bfd != NULL)
2520 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2521 input_section, output_bfd, error_message);
2522
2523 /* Adjust the addend for sign extension of the low 16 bits.
2524 We won't actually be using the low 16 bits, so trashing them
2525 doesn't matter. */
2526 reloc_entry->addend += 0x8000;
2527 r_type = reloc_entry->howto->type;
2528 if (r_type != R_PPC64_REL16DX_HA)
2529 return bfd_reloc_continue;
2530
2531 value = 0;
2532 if (!bfd_is_com_section (symbol->section))
2533 value = symbol->value;
2534 value += (reloc_entry->addend
2535 + symbol->section->output_offset
2536 + symbol->section->output_section->vma);
2537 value -= (reloc_entry->address
2538 + input_section->output_offset
2539 + input_section->output_section->vma);
2540 value = (bfd_signed_vma) value >> 16;
2541
2542 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2543 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2544 insn &= ~0x1fffc1;
2545 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2546 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2547 if (value + 0x8000 > 0xffff)
2548 return bfd_reloc_overflow;
2549 return bfd_reloc_ok;
2550 }
2551
2552 static bfd_reloc_status_type
2553 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2554 void *data, asection *input_section,
2555 bfd *output_bfd, char **error_message)
2556 {
2557 if (output_bfd != NULL)
2558 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2559 input_section, output_bfd, error_message);
2560
2561 if (strcmp (symbol->section->name, ".opd") == 0
2562 && (symbol->section->owner->flags & DYNAMIC) == 0)
2563 {
2564 bfd_vma dest = opd_entry_value (symbol->section,
2565 symbol->value + reloc_entry->addend,
2566 NULL, NULL, FALSE);
2567 if (dest != (bfd_vma) -1)
2568 reloc_entry->addend = dest - (symbol->value
2569 + symbol->section->output_section->vma
2570 + symbol->section->output_offset);
2571 }
2572 else
2573 {
2574 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2575
2576 if (symbol->section->owner != abfd
2577 && symbol->section->owner != NULL
2578 && abiversion (symbol->section->owner) >= 2)
2579 {
2580 unsigned int i;
2581
2582 for (i = 0; i < symbol->section->owner->symcount; ++i)
2583 {
2584 asymbol *symdef = symbol->section->owner->outsymbols[i];
2585
2586 if (strcmp (symdef->name, symbol->name) == 0)
2587 {
2588 elfsym = (elf_symbol_type *) symdef;
2589 break;
2590 }
2591 }
2592 }
2593 reloc_entry->addend
2594 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2595 }
2596 return bfd_reloc_continue;
2597 }
2598
2599 static bfd_reloc_status_type
2600 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2601 void *data, asection *input_section,
2602 bfd *output_bfd, char **error_message)
2603 {
2604 long insn;
2605 enum elf_ppc64_reloc_type r_type;
2606 bfd_size_type octets;
2607 /* Assume 'at' branch hints. */
2608 bfd_boolean is_isa_v2 = TRUE;
2609
2610 /* If this is a relocatable link (output_bfd test tells us), just
2611 call the generic function. Any adjustment will be done at final
2612 link time. */
2613 if (output_bfd != NULL)
2614 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2615 input_section, output_bfd, error_message);
2616
2617 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2618 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2619 insn &= ~(0x01 << 21);
2620 r_type = reloc_entry->howto->type;
2621 if (r_type == R_PPC64_ADDR14_BRTAKEN
2622 || r_type == R_PPC64_REL14_BRTAKEN)
2623 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2624
2625 if (is_isa_v2)
2626 {
2627 /* Set 'a' bit. This is 0b00010 in BO field for branch
2628 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2629 for branch on CTR insns (BO == 1a00t or 1a01t). */
2630 if ((insn & (0x14 << 21)) == (0x04 << 21))
2631 insn |= 0x02 << 21;
2632 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2633 insn |= 0x08 << 21;
2634 else
2635 goto out;
2636 }
2637 else
2638 {
2639 bfd_vma target = 0;
2640 bfd_vma from;
2641
2642 if (!bfd_is_com_section (symbol->section))
2643 target = symbol->value;
2644 target += symbol->section->output_section->vma;
2645 target += symbol->section->output_offset;
2646 target += reloc_entry->addend;
2647
2648 from = (reloc_entry->address
2649 + input_section->output_offset
2650 + input_section->output_section->vma);
2651
2652 /* Invert 'y' bit if not the default. */
2653 if ((bfd_signed_vma) (target - from) < 0)
2654 insn ^= 0x01 << 21;
2655 }
2656 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2657 out:
2658 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2659 input_section, output_bfd, error_message);
2660 }
2661
2662 static bfd_reloc_status_type
2663 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2664 void *data, asection *input_section,
2665 bfd *output_bfd, char **error_message)
2666 {
2667 /* If this is a relocatable link (output_bfd test tells us), just
2668 call the generic function. Any adjustment will be done at final
2669 link time. */
2670 if (output_bfd != NULL)
2671 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2672 input_section, output_bfd, error_message);
2673
2674 /* Subtract the symbol section base address. */
2675 reloc_entry->addend -= symbol->section->output_section->vma;
2676 return bfd_reloc_continue;
2677 }
2678
2679 static bfd_reloc_status_type
2680 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2681 void *data, asection *input_section,
2682 bfd *output_bfd, char **error_message)
2683 {
2684 /* If this is a relocatable link (output_bfd test tells us), just
2685 call the generic function. Any adjustment will be done at final
2686 link time. */
2687 if (output_bfd != NULL)
2688 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2689 input_section, output_bfd, error_message);
2690
2691 /* Subtract the symbol section base address. */
2692 reloc_entry->addend -= symbol->section->output_section->vma;
2693
2694 /* Adjust the addend for sign extension of the low 16 bits. */
2695 reloc_entry->addend += 0x8000;
2696 return bfd_reloc_continue;
2697 }
2698
2699 static bfd_reloc_status_type
2700 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2701 void *data, asection *input_section,
2702 bfd *output_bfd, char **error_message)
2703 {
2704 bfd_vma TOCstart;
2705
2706 /* If this is a relocatable link (output_bfd test tells us), just
2707 call the generic function. Any adjustment will be done at final
2708 link time. */
2709 if (output_bfd != NULL)
2710 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2711 input_section, output_bfd, error_message);
2712
2713 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2714 if (TOCstart == 0)
2715 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2716
2717 /* Subtract the TOC base address. */
2718 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2719 return bfd_reloc_continue;
2720 }
2721
2722 static bfd_reloc_status_type
2723 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2724 void *data, asection *input_section,
2725 bfd *output_bfd, char **error_message)
2726 {
2727 bfd_vma TOCstart;
2728
2729 /* If this is a relocatable link (output_bfd test tells us), just
2730 call the generic function. Any adjustment will be done at final
2731 link time. */
2732 if (output_bfd != NULL)
2733 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2734 input_section, output_bfd, error_message);
2735
2736 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2737 if (TOCstart == 0)
2738 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2739
2740 /* Subtract the TOC base address. */
2741 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2742
2743 /* Adjust the addend for sign extension of the low 16 bits. */
2744 reloc_entry->addend += 0x8000;
2745 return bfd_reloc_continue;
2746 }
2747
2748 static bfd_reloc_status_type
2749 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2750 void *data, asection *input_section,
2751 bfd *output_bfd, char **error_message)
2752 {
2753 bfd_vma TOCstart;
2754 bfd_size_type octets;
2755
2756 /* If this is a relocatable link (output_bfd test tells us), just
2757 call the generic function. Any adjustment will be done at final
2758 link time. */
2759 if (output_bfd != NULL)
2760 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2761 input_section, output_bfd, error_message);
2762
2763 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2764 if (TOCstart == 0)
2765 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2766
2767 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2768 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2769 return bfd_reloc_ok;
2770 }
2771
2772 static bfd_reloc_status_type
2773 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2774 void *data, asection *input_section,
2775 bfd *output_bfd, char **error_message)
2776 {
2777 /* If this is a relocatable link (output_bfd test tells us), just
2778 call the generic function. Any adjustment will be done at final
2779 link time. */
2780 if (output_bfd != NULL)
2781 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2782 input_section, output_bfd, error_message);
2783
2784 if (error_message != NULL)
2785 {
2786 static char buf[60];
2787 sprintf (buf, "generic linker can't handle %s",
2788 reloc_entry->howto->name);
2789 *error_message = buf;
2790 }
2791 return bfd_reloc_dangerous;
2792 }
2793
2794 /* Track GOT entries needed for a given symbol. We might need more
2795 than one got entry per symbol. */
2796 struct got_entry
2797 {
2798 struct got_entry *next;
2799
2800 /* The symbol addend that we'll be placing in the GOT. */
2801 bfd_vma addend;
2802
2803 /* Unlike other ELF targets, we use separate GOT entries for the same
2804 symbol referenced from different input files. This is to support
2805 automatic multiple TOC/GOT sections, where the TOC base can vary
2806 from one input file to another. After partitioning into TOC groups
2807 we merge entries within the group.
2808
2809 Point to the BFD owning this GOT entry. */
2810 bfd *owner;
2811
2812 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2813 TLS_TPREL or TLS_DTPREL for tls entries. */
2814 unsigned char tls_type;
2815
2816 /* Non-zero if got.ent points to real entry. */
2817 unsigned char is_indirect;
2818
2819 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2820 union
2821 {
2822 bfd_signed_vma refcount;
2823 bfd_vma offset;
2824 struct got_entry *ent;
2825 } got;
2826 };
2827
2828 /* The same for PLT. */
2829 struct plt_entry
2830 {
2831 struct plt_entry *next;
2832
2833 bfd_vma addend;
2834
2835 union
2836 {
2837 bfd_signed_vma refcount;
2838 bfd_vma offset;
2839 } plt;
2840 };
2841
2842 struct ppc64_elf_obj_tdata
2843 {
2844 struct elf_obj_tdata elf;
2845
2846 /* Shortcuts to dynamic linker sections. */
2847 asection *got;
2848 asection *relgot;
2849
2850 /* Used during garbage collection. We attach global symbols defined
2851 on removed .opd entries to this section so that the sym is removed. */
2852 asection *deleted_section;
2853
2854 /* TLS local dynamic got entry handling. Support for multiple GOT
2855 sections means we potentially need one of these for each input bfd. */
2856 struct got_entry tlsld_got;
2857
2858 union {
2859 /* A copy of relocs before they are modified for --emit-relocs. */
2860 Elf_Internal_Rela *relocs;
2861
2862 /* Section contents. */
2863 bfd_byte *contents;
2864 } opd;
2865
2866 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2867 the reloc to be in the range -32768 to 32767. */
2868 unsigned int has_small_toc_reloc : 1;
2869
2870 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2871 instruction not one we handle. */
2872 unsigned int unexpected_toc_insn : 1;
2873 };
2874
2875 #define ppc64_elf_tdata(bfd) \
2876 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2877
2878 #define ppc64_tlsld_got(bfd) \
2879 (&ppc64_elf_tdata (bfd)->tlsld_got)
2880
2881 #define is_ppc64_elf(bfd) \
2882 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2883 && elf_object_id (bfd) == PPC64_ELF_DATA)
2884
2885 /* Override the generic function because we store some extras. */
2886
2887 static bfd_boolean
2888 ppc64_elf_mkobject (bfd *abfd)
2889 {
2890 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2891 PPC64_ELF_DATA);
2892 }
2893
2894 /* Fix bad default arch selected for a 64 bit input bfd when the
2895 default is 32 bit. Also select arch based on apuinfo. */
2896
2897 static bfd_boolean
2898 ppc64_elf_object_p (bfd *abfd)
2899 {
2900 if (!abfd->arch_info->the_default)
2901 return TRUE;
2902
2903 if (abfd->arch_info->bits_per_word == 32)
2904 {
2905 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2906
2907 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2908 {
2909 /* Relies on arch after 32 bit default being 64 bit default. */
2910 abfd->arch_info = abfd->arch_info->next;
2911 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2912 }
2913 }
2914 return _bfd_elf_ppc_set_arch (abfd);
2915 }
2916
2917 /* Support for core dump NOTE sections. */
2918
2919 static bfd_boolean
2920 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2921 {
2922 size_t offset, size;
2923
2924 if (note->descsz != 504)
2925 return FALSE;
2926
2927 /* pr_cursig */
2928 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2929
2930 /* pr_pid */
2931 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2932
2933 /* pr_reg */
2934 offset = 112;
2935 size = 384;
2936
2937 /* Make a ".reg/999" section. */
2938 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2939 size, note->descpos + offset);
2940 }
2941
2942 static bfd_boolean
2943 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2944 {
2945 if (note->descsz != 136)
2946 return FALSE;
2947
2948 elf_tdata (abfd)->core->pid
2949 = bfd_get_32 (abfd, note->descdata + 24);
2950 elf_tdata (abfd)->core->program
2951 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2952 elf_tdata (abfd)->core->command
2953 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2954
2955 return TRUE;
2956 }
2957
2958 static char *
2959 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2960 ...)
2961 {
2962 switch (note_type)
2963 {
2964 default:
2965 return NULL;
2966
2967 case NT_PRPSINFO:
2968 {
2969 char data[136];
2970 va_list ap;
2971
2972 va_start (ap, note_type);
2973 memset (data, 0, sizeof (data));
2974 strncpy (data + 40, va_arg (ap, const char *), 16);
2975 strncpy (data + 56, va_arg (ap, const char *), 80);
2976 va_end (ap);
2977 return elfcore_write_note (abfd, buf, bufsiz,
2978 "CORE", note_type, data, sizeof (data));
2979 }
2980
2981 case NT_PRSTATUS:
2982 {
2983 char data[504];
2984 va_list ap;
2985 long pid;
2986 int cursig;
2987 const void *greg;
2988
2989 va_start (ap, note_type);
2990 memset (data, 0, 112);
2991 pid = va_arg (ap, long);
2992 bfd_put_32 (abfd, pid, data + 32);
2993 cursig = va_arg (ap, int);
2994 bfd_put_16 (abfd, cursig, data + 12);
2995 greg = va_arg (ap, const void *);
2996 memcpy (data + 112, greg, 384);
2997 memset (data + 496, 0, 8);
2998 va_end (ap);
2999 return elfcore_write_note (abfd, buf, bufsiz,
3000 "CORE", note_type, data, sizeof (data));
3001 }
3002 }
3003 }
3004
3005 /* Add extra PPC sections. */
3006
3007 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3008 {
3009 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3010 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3011 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3012 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3013 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3014 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3015 { NULL, 0, 0, 0, 0 }
3016 };
3017
3018 enum _ppc64_sec_type {
3019 sec_normal = 0,
3020 sec_opd = 1,
3021 sec_toc = 2
3022 };
3023
3024 struct _ppc64_elf_section_data
3025 {
3026 struct bfd_elf_section_data elf;
3027
3028 union
3029 {
3030 /* An array with one entry for each opd function descriptor,
3031 and some spares since opd entries may be either 16 or 24 bytes. */
3032 #define OPD_NDX(OFF) ((OFF) >> 4)
3033 struct _opd_sec_data
3034 {
3035 /* Points to the function code section for local opd entries. */
3036 asection **func_sec;
3037
3038 /* After editing .opd, adjust references to opd local syms. */
3039 long *adjust;
3040 } opd;
3041
3042 /* An array for toc sections, indexed by offset/8. */
3043 struct _toc_sec_data
3044 {
3045 /* Specifies the relocation symbol index used at a given toc offset. */
3046 unsigned *symndx;
3047
3048 /* And the relocation addend. */
3049 bfd_vma *add;
3050 } toc;
3051 } u;
3052
3053 enum _ppc64_sec_type sec_type:2;
3054
3055 /* Flag set when small branches are detected. Used to
3056 select suitable defaults for the stub group size. */
3057 unsigned int has_14bit_branch:1;
3058 };
3059
3060 #define ppc64_elf_section_data(sec) \
3061 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3062
3063 static bfd_boolean
3064 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3065 {
3066 if (!sec->used_by_bfd)
3067 {
3068 struct _ppc64_elf_section_data *sdata;
3069 bfd_size_type amt = sizeof (*sdata);
3070
3071 sdata = bfd_zalloc (abfd, amt);
3072 if (sdata == NULL)
3073 return FALSE;
3074 sec->used_by_bfd = sdata;
3075 }
3076
3077 return _bfd_elf_new_section_hook (abfd, sec);
3078 }
3079
3080 static struct _opd_sec_data *
3081 get_opd_info (asection * sec)
3082 {
3083 if (sec != NULL
3084 && ppc64_elf_section_data (sec) != NULL
3085 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3086 return &ppc64_elf_section_data (sec)->u.opd;
3087 return NULL;
3088 }
3089 \f
3090 /* Parameters for the qsort hook. */
3091 static bfd_boolean synthetic_relocatable;
3092 static asection *synthetic_opd;
3093
3094 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3095
3096 static int
3097 compare_symbols (const void *ap, const void *bp)
3098 {
3099 const asymbol *a = * (const asymbol **) ap;
3100 const asymbol *b = * (const asymbol **) bp;
3101
3102 /* Section symbols first. */
3103 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3104 return -1;
3105 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3106 return 1;
3107
3108 /* then .opd symbols. */
3109 if (synthetic_opd != NULL)
3110 {
3111 if (strcmp (a->section->name, ".opd") == 0
3112 && strcmp (b->section->name, ".opd") != 0)
3113 return -1;
3114 if (strcmp (a->section->name, ".opd") != 0
3115 && strcmp (b->section->name, ".opd") == 0)
3116 return 1;
3117 }
3118
3119 /* then other code symbols. */
3120 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3121 == (SEC_CODE | SEC_ALLOC)
3122 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123 != (SEC_CODE | SEC_ALLOC))
3124 return -1;
3125
3126 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3127 != (SEC_CODE | SEC_ALLOC)
3128 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3129 == (SEC_CODE | SEC_ALLOC))
3130 return 1;
3131
3132 if (synthetic_relocatable)
3133 {
3134 if (a->section->id < b->section->id)
3135 return -1;
3136
3137 if (a->section->id > b->section->id)
3138 return 1;
3139 }
3140
3141 if (a->value + a->section->vma < b->value + b->section->vma)
3142 return -1;
3143
3144 if (a->value + a->section->vma > b->value + b->section->vma)
3145 return 1;
3146
3147 /* For syms with the same value, prefer strong dynamic global function
3148 syms over other syms. */
3149 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3150 return -1;
3151
3152 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3153 return 1;
3154
3155 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3156 return -1;
3157
3158 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3159 return 1;
3160
3161 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3162 return -1;
3163
3164 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3165 return 1;
3166
3167 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3168 return -1;
3169
3170 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3171 return 1;
3172
3173 return 0;
3174 }
3175
3176 /* Search SYMS for a symbol of the given VALUE. */
3177
3178 static asymbol *
3179 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3180 {
3181 long mid;
3182
3183 if (id == (unsigned) -1)
3184 {
3185 while (lo < hi)
3186 {
3187 mid = (lo + hi) >> 1;
3188 if (syms[mid]->value + syms[mid]->section->vma < value)
3189 lo = mid + 1;
3190 else if (syms[mid]->value + syms[mid]->section->vma > value)
3191 hi = mid;
3192 else
3193 return syms[mid];
3194 }
3195 }
3196 else
3197 {
3198 while (lo < hi)
3199 {
3200 mid = (lo + hi) >> 1;
3201 if (syms[mid]->section->id < id)
3202 lo = mid + 1;
3203 else if (syms[mid]->section->id > id)
3204 hi = mid;
3205 else if (syms[mid]->value < value)
3206 lo = mid + 1;
3207 else if (syms[mid]->value > value)
3208 hi = mid;
3209 else
3210 return syms[mid];
3211 }
3212 }
3213 return NULL;
3214 }
3215
3216 static bfd_boolean
3217 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3218 {
3219 bfd_vma vma = *(bfd_vma *) ptr;
3220 return ((section->flags & SEC_ALLOC) != 0
3221 && section->vma <= vma
3222 && vma < section->vma + section->size);
3223 }
3224
3225 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3226 entry syms. Also generate @plt symbols for the glink branch table.
3227 Returns count of synthetic symbols in RET or -1 on error. */
3228
3229 static long
3230 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3231 long static_count, asymbol **static_syms,
3232 long dyn_count, asymbol **dyn_syms,
3233 asymbol **ret)
3234 {
3235 asymbol *s;
3236 long i;
3237 long count;
3238 char *names;
3239 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3240 asection *opd = NULL;
3241 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3242 asymbol **syms;
3243 int abi = abiversion (abfd);
3244
3245 *ret = NULL;
3246
3247 if (abi < 2)
3248 {
3249 opd = bfd_get_section_by_name (abfd, ".opd");
3250 if (opd == NULL && abi == 1)
3251 return 0;
3252 }
3253
3254 symcount = static_count;
3255 if (!relocatable)
3256 symcount += dyn_count;
3257 if (symcount == 0)
3258 return 0;
3259
3260 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3261 if (syms == NULL)
3262 return -1;
3263
3264 if (!relocatable && static_count != 0 && dyn_count != 0)
3265 {
3266 /* Use both symbol tables. */
3267 memcpy (syms, static_syms, static_count * sizeof (*syms));
3268 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3269 }
3270 else if (!relocatable && static_count == 0)
3271 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3272 else
3273 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3274
3275 synthetic_relocatable = relocatable;
3276 synthetic_opd = opd;
3277 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3278
3279 if (!relocatable && symcount > 1)
3280 {
3281 long j;
3282 /* Trim duplicate syms, since we may have merged the normal and
3283 dynamic symbols. Actually, we only care about syms that have
3284 different values, so trim any with the same value. */
3285 for (i = 1, j = 1; i < symcount; ++i)
3286 if (syms[i - 1]->value + syms[i - 1]->section->vma
3287 != syms[i]->value + syms[i]->section->vma)
3288 syms[j++] = syms[i];
3289 symcount = j;
3290 }
3291
3292 i = 0;
3293 /* Note that here and in compare_symbols we can't compare opd and
3294 sym->section directly. With separate debug info files, the
3295 symbols will be extracted from the debug file while abfd passed
3296 to this function is the real binary. */
3297 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3298 ++i;
3299 codesecsym = 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 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3305 break;
3306 codesecsymend = i;
3307
3308 for (; i < symcount; ++i)
3309 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3310 break;
3311 secsymend = i;
3312
3313 if (opd != NULL)
3314 for (; i < symcount; ++i)
3315 if (strcmp (syms[i]->section->name, ".opd") != 0)
3316 break;
3317 opdsymend = i;
3318
3319 for (; i < symcount; ++i)
3320 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3321 != (SEC_CODE | SEC_ALLOC))
3322 break;
3323 symcount = i;
3324
3325 count = 0;
3326
3327 if (relocatable)
3328 {
3329 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3330 arelent *r;
3331 size_t size;
3332 long relcount;
3333
3334 if (opdsymend == secsymend)
3335 goto done;
3336
3337 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3338 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3339 if (relcount == 0)
3340 goto done;
3341
3342 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3343 {
3344 count = -1;
3345 goto done;
3346 }
3347
3348 size = 0;
3349 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3350 {
3351 asymbol *sym;
3352
3353 while (r < opd->relocation + relcount
3354 && r->address < syms[i]->value + opd->vma)
3355 ++r;
3356
3357 if (r == opd->relocation + relcount)
3358 break;
3359
3360 if (r->address != syms[i]->value + opd->vma)
3361 continue;
3362
3363 if (r->howto->type != R_PPC64_ADDR64)
3364 continue;
3365
3366 sym = *r->sym_ptr_ptr;
3367 if (!sym_exists_at (syms, opdsymend, symcount,
3368 sym->section->id, sym->value + r->addend))
3369 {
3370 ++count;
3371 size += sizeof (asymbol);
3372 size += strlen (syms[i]->name) + 2;
3373 }
3374 }
3375
3376 if (size == 0)
3377 goto done;
3378 s = *ret = bfd_malloc (size);
3379 if (s == NULL)
3380 {
3381 count = -1;
3382 goto done;
3383 }
3384
3385 names = (char *) (s + count);
3386
3387 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3388 {
3389 asymbol *sym;
3390
3391 while (r < opd->relocation + relcount
3392 && r->address < syms[i]->value + opd->vma)
3393 ++r;
3394
3395 if (r == opd->relocation + relcount)
3396 break;
3397
3398 if (r->address != syms[i]->value + opd->vma)
3399 continue;
3400
3401 if (r->howto->type != R_PPC64_ADDR64)
3402 continue;
3403
3404 sym = *r->sym_ptr_ptr;
3405 if (!sym_exists_at (syms, opdsymend, symcount,
3406 sym->section->id, sym->value + r->addend))
3407 {
3408 size_t len;
3409
3410 *s = *syms[i];
3411 s->flags |= BSF_SYNTHETIC;
3412 s->section = sym->section;
3413 s->value = sym->value + r->addend;
3414 s->name = names;
3415 *names++ = '.';
3416 len = strlen (syms[i]->name);
3417 memcpy (names, syms[i]->name, len + 1);
3418 names += len + 1;
3419 /* Have udata.p point back to the original symbol this
3420 synthetic symbol was derived from. */
3421 s->udata.p = syms[i];
3422 s++;
3423 }
3424 }
3425 }
3426 else
3427 {
3428 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3429 bfd_byte *contents = NULL;
3430 size_t size;
3431 long plt_count = 0;
3432 bfd_vma glink_vma = 0, resolv_vma = 0;
3433 asection *dynamic, *glink = NULL, *relplt = NULL;
3434 arelent *p;
3435
3436 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3437 {
3438 free_contents_and_exit_err:
3439 count = -1;
3440 free_contents_and_exit:
3441 if (contents)
3442 free (contents);
3443 goto done;
3444 }
3445
3446 size = 0;
3447 for (i = secsymend; i < opdsymend; ++i)
3448 {
3449 bfd_vma ent;
3450
3451 /* Ignore bogus symbols. */
3452 if (syms[i]->value > opd->size - 8)
3453 continue;
3454
3455 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3456 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3457 {
3458 ++count;
3459 size += sizeof (asymbol);
3460 size += strlen (syms[i]->name) + 2;
3461 }
3462 }
3463
3464 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3465 if (dyn_count != 0
3466 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3467 {
3468 bfd_byte *dynbuf, *extdyn, *extdynend;
3469 size_t extdynsize;
3470 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3471
3472 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3473 goto free_contents_and_exit_err;
3474
3475 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3476 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3477
3478 extdyn = dynbuf;
3479 extdynend = extdyn + dynamic->size;
3480 for (; extdyn < extdynend; extdyn += extdynsize)
3481 {
3482 Elf_Internal_Dyn dyn;
3483 (*swap_dyn_in) (abfd, extdyn, &dyn);
3484
3485 if (dyn.d_tag == DT_NULL)
3486 break;
3487
3488 if (dyn.d_tag == DT_PPC64_GLINK)
3489 {
3490 /* The first glink stub starts at offset 32; see
3491 comment in ppc64_elf_finish_dynamic_sections. */
3492 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3493 /* The .glink section usually does not survive the final
3494 link; search for the section (usually .text) where the
3495 glink stubs now reside. */
3496 glink = bfd_sections_find_if (abfd, section_covers_vma,
3497 &glink_vma);
3498 break;
3499 }
3500 }
3501
3502 free (dynbuf);
3503 }
3504
3505 if (glink != NULL)
3506 {
3507 /* Determine __glink trampoline by reading the relative branch
3508 from the first glink stub. */
3509 bfd_byte buf[4];
3510 unsigned int off = 0;
3511
3512 while (bfd_get_section_contents (abfd, glink, buf,
3513 glink_vma + off - glink->vma, 4))
3514 {
3515 unsigned int insn = bfd_get_32 (abfd, buf);
3516 insn ^= B_DOT;
3517 if ((insn & ~0x3fffffc) == 0)
3518 {
3519 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3520 break;
3521 }
3522 off += 4;
3523 if (off > 4)
3524 break;
3525 }
3526
3527 if (resolv_vma)
3528 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3529
3530 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3531 if (relplt != NULL)
3532 {
3533 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3534 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3535 goto free_contents_and_exit_err;
3536
3537 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3538 size += plt_count * sizeof (asymbol);
3539
3540 p = relplt->relocation;
3541 for (i = 0; i < plt_count; i++, p++)
3542 {
3543 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3544 if (p->addend != 0)
3545 size += sizeof ("+0x") - 1 + 16;
3546 }
3547 }
3548 }
3549
3550 if (size == 0)
3551 goto free_contents_and_exit;
3552 s = *ret = bfd_malloc (size);
3553 if (s == NULL)
3554 goto free_contents_and_exit_err;
3555
3556 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3557
3558 for (i = secsymend; i < opdsymend; ++i)
3559 {
3560 bfd_vma ent;
3561
3562 if (syms[i]->value > opd->size - 8)
3563 continue;
3564
3565 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3566 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3567 {
3568 long lo, hi;
3569 size_t len;
3570 asection *sec = abfd->sections;
3571
3572 *s = *syms[i];
3573 lo = codesecsym;
3574 hi = codesecsymend;
3575 while (lo < hi)
3576 {
3577 long mid = (lo + hi) >> 1;
3578 if (syms[mid]->section->vma < ent)
3579 lo = mid + 1;
3580 else if (syms[mid]->section->vma > ent)
3581 hi = mid;
3582 else
3583 {
3584 sec = syms[mid]->section;
3585 break;
3586 }
3587 }
3588
3589 if (lo >= hi && lo > codesecsym)
3590 sec = syms[lo - 1]->section;
3591
3592 for (; sec != NULL; sec = sec->next)
3593 {
3594 if (sec->vma > ent)
3595 break;
3596 /* SEC_LOAD may not be set if SEC is from a separate debug
3597 info file. */
3598 if ((sec->flags & SEC_ALLOC) == 0)
3599 break;
3600 if ((sec->flags & SEC_CODE) != 0)
3601 s->section = sec;
3602 }
3603 s->flags |= BSF_SYNTHETIC;
3604 s->value = ent - s->section->vma;
3605 s->name = names;
3606 *names++ = '.';
3607 len = strlen (syms[i]->name);
3608 memcpy (names, syms[i]->name, len + 1);
3609 names += len + 1;
3610 /* Have udata.p point back to the original symbol this
3611 synthetic symbol was derived from. */
3612 s->udata.p = syms[i];
3613 s++;
3614 }
3615 }
3616 free (contents);
3617
3618 if (glink != NULL && relplt != NULL)
3619 {
3620 if (resolv_vma)
3621 {
3622 /* Add a symbol for the main glink trampoline. */
3623 memset (s, 0, sizeof *s);
3624 s->the_bfd = abfd;
3625 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3626 s->section = glink;
3627 s->value = resolv_vma - glink->vma;
3628 s->name = names;
3629 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3630 names += sizeof ("__glink_PLTresolve");
3631 s++;
3632 count++;
3633 }
3634
3635 /* FIXME: It would be very much nicer to put sym@plt on the
3636 stub rather than on the glink branch table entry. The
3637 objdump disassembler would then use a sensible symbol
3638 name on plt calls. The difficulty in doing so is
3639 a) finding the stubs, and,
3640 b) matching stubs against plt entries, and,
3641 c) there can be multiple stubs for a given plt entry.
3642
3643 Solving (a) could be done by code scanning, but older
3644 ppc64 binaries used different stubs to current code.
3645 (b) is the tricky one since you need to known the toc
3646 pointer for at least one function that uses a pic stub to
3647 be able to calculate the plt address referenced.
3648 (c) means gdb would need to set multiple breakpoints (or
3649 find the glink branch itself) when setting breakpoints
3650 for pending shared library loads. */
3651 p = relplt->relocation;
3652 for (i = 0; i < plt_count; i++, p++)
3653 {
3654 size_t len;
3655
3656 *s = **p->sym_ptr_ptr;
3657 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3658 we are defining a symbol, ensure one of them is set. */
3659 if ((s->flags & BSF_LOCAL) == 0)
3660 s->flags |= BSF_GLOBAL;
3661 s->flags |= BSF_SYNTHETIC;
3662 s->section = glink;
3663 s->value = glink_vma - glink->vma;
3664 s->name = names;
3665 s->udata.p = NULL;
3666 len = strlen ((*p->sym_ptr_ptr)->name);
3667 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3668 names += len;
3669 if (p->addend != 0)
3670 {
3671 memcpy (names, "+0x", sizeof ("+0x") - 1);
3672 names += sizeof ("+0x") - 1;
3673 bfd_sprintf_vma (abfd, names, p->addend);
3674 names += strlen (names);
3675 }
3676 memcpy (names, "@plt", sizeof ("@plt"));
3677 names += sizeof ("@plt");
3678 s++;
3679 if (abi < 2)
3680 {
3681 glink_vma += 8;
3682 if (i >= 0x8000)
3683 glink_vma += 4;
3684 }
3685 else
3686 glink_vma += 4;
3687 }
3688 count += plt_count;
3689 }
3690 }
3691
3692 done:
3693 free (syms);
3694 return count;
3695 }
3696 \f
3697 /* The following functions are specific to the ELF linker, while
3698 functions above are used generally. Those named ppc64_elf_* are
3699 called by the main ELF linker code. They appear in this file more
3700 or less in the order in which they are called. eg.
3701 ppc64_elf_check_relocs is called early in the link process,
3702 ppc64_elf_finish_dynamic_sections is one of the last functions
3703 called.
3704
3705 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3706 functions have both a function code symbol and a function descriptor
3707 symbol. A call to foo in a relocatable object file looks like:
3708
3709 . .text
3710 . x:
3711 . bl .foo
3712 . nop
3713
3714 The function definition in another object file might be:
3715
3716 . .section .opd
3717 . foo: .quad .foo
3718 . .quad .TOC.@tocbase
3719 . .quad 0
3720 .
3721 . .text
3722 . .foo: blr
3723
3724 When the linker resolves the call during a static link, the branch
3725 unsurprisingly just goes to .foo and the .opd information is unused.
3726 If the function definition is in a shared library, things are a little
3727 different: The call goes via a plt call stub, the opd information gets
3728 copied to the plt, and the linker patches the nop.
3729
3730 . x:
3731 . bl .foo_stub
3732 . ld 2,40(1)
3733 .
3734 .
3735 . .foo_stub:
3736 . std 2,40(1) # in practice, the call stub
3737 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3738 . addi 11,11,Lfoo@toc@l # this is the general idea
3739 . ld 12,0(11)
3740 . ld 2,8(11)
3741 . mtctr 12
3742 . ld 11,16(11)
3743 . bctr
3744 .
3745 . .section .plt
3746 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3747
3748 The "reloc ()" notation is supposed to indicate that the linker emits
3749 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3750 copying.
3751
3752 What are the difficulties here? Well, firstly, the relocations
3753 examined by the linker in check_relocs are against the function code
3754 sym .foo, while the dynamic relocation in the plt is emitted against
3755 the function descriptor symbol, foo. Somewhere along the line, we need
3756 to carefully copy dynamic link information from one symbol to the other.
3757 Secondly, the generic part of the elf linker will make .foo a dynamic
3758 symbol as is normal for most other backends. We need foo dynamic
3759 instead, at least for an application final link. However, when
3760 creating a shared library containing foo, we need to have both symbols
3761 dynamic so that references to .foo are satisfied during the early
3762 stages of linking. Otherwise the linker might decide to pull in a
3763 definition from some other object, eg. a static library.
3764
3765 Update: As of August 2004, we support a new convention. Function
3766 calls may use the function descriptor symbol, ie. "bl foo". This
3767 behaves exactly as "bl .foo". */
3768
3769 /* Of those relocs that might be copied as dynamic relocs, this function
3770 selects those that must be copied when linking a shared library,
3771 even when the symbol is local. */
3772
3773 static int
3774 must_be_dyn_reloc (struct bfd_link_info *info,
3775 enum elf_ppc64_reloc_type r_type)
3776 {
3777 switch (r_type)
3778 {
3779 default:
3780 return 1;
3781
3782 case R_PPC64_REL32:
3783 case R_PPC64_REL64:
3784 case R_PPC64_REL30:
3785 return 0;
3786
3787 case R_PPC64_TPREL16:
3788 case R_PPC64_TPREL16_LO:
3789 case R_PPC64_TPREL16_HI:
3790 case R_PPC64_TPREL16_HA:
3791 case R_PPC64_TPREL16_DS:
3792 case R_PPC64_TPREL16_LO_DS:
3793 case R_PPC64_TPREL16_HIGH:
3794 case R_PPC64_TPREL16_HIGHA:
3795 case R_PPC64_TPREL16_HIGHER:
3796 case R_PPC64_TPREL16_HIGHERA:
3797 case R_PPC64_TPREL16_HIGHEST:
3798 case R_PPC64_TPREL16_HIGHESTA:
3799 case R_PPC64_TPREL64:
3800 return !bfd_link_executable (info);
3801 }
3802 }
3803
3804 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3805 copying dynamic variables from a shared lib into an app's dynbss
3806 section, and instead use a dynamic relocation to point into the
3807 shared lib. With code that gcc generates, it's vital that this be
3808 enabled; In the PowerPC64 ABI, the address of a function is actually
3809 the address of a function descriptor, which resides in the .opd
3810 section. gcc uses the descriptor directly rather than going via the
3811 GOT as some other ABI's do, which means that initialized function
3812 pointers must reference the descriptor. Thus, a function pointer
3813 initialized to the address of a function in a shared library will
3814 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3815 redefines the function descriptor symbol to point to the copy. This
3816 presents a problem as a plt entry for that function is also
3817 initialized from the function descriptor symbol and the copy reloc
3818 may not be initialized first. */
3819 #define ELIMINATE_COPY_RELOCS 1
3820
3821 /* Section name for stubs is the associated section name plus this
3822 string. */
3823 #define STUB_SUFFIX ".stub"
3824
3825 /* Linker stubs.
3826 ppc_stub_long_branch:
3827 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3828 destination, but a 24 bit branch in a stub section will reach.
3829 . b dest
3830
3831 ppc_stub_plt_branch:
3832 Similar to the above, but a 24 bit branch in the stub section won't
3833 reach its destination.
3834 . addis %r11,%r2,xxx@toc@ha
3835 . ld %r12,xxx@toc@l(%r11)
3836 . mtctr %r12
3837 . bctr
3838
3839 ppc_stub_plt_call:
3840 Used to call a function in a shared library. If it so happens that
3841 the plt entry referenced crosses a 64k boundary, then an extra
3842 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3843 . std %r2,40(%r1)
3844 . addis %r11,%r2,xxx@toc@ha
3845 . ld %r12,xxx+0@toc@l(%r11)
3846 . mtctr %r12
3847 . ld %r2,xxx+8@toc@l(%r11)
3848 . ld %r11,xxx+16@toc@l(%r11)
3849 . bctr
3850
3851 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3852 code to adjust the value and save r2 to support multiple toc sections.
3853 A ppc_stub_long_branch with an r2 offset looks like:
3854 . std %r2,40(%r1)
3855 . addis %r2,%r2,off@ha
3856 . addi %r2,%r2,off@l
3857 . b dest
3858
3859 A ppc_stub_plt_branch with an r2 offset looks like:
3860 . std %r2,40(%r1)
3861 . addis %r11,%r2,xxx@toc@ha
3862 . ld %r12,xxx@toc@l(%r11)
3863 . addis %r2,%r2,off@ha
3864 . addi %r2,%r2,off@l
3865 . mtctr %r12
3866 . bctr
3867
3868 In cases where the "addis" instruction would add zero, the "addis" is
3869 omitted and following instructions modified slightly in some cases.
3870 */
3871
3872 enum ppc_stub_type {
3873 ppc_stub_none,
3874 ppc_stub_long_branch,
3875 ppc_stub_long_branch_r2off,
3876 ppc_stub_plt_branch,
3877 ppc_stub_plt_branch_r2off,
3878 ppc_stub_plt_call,
3879 ppc_stub_plt_call_r2save,
3880 ppc_stub_global_entry,
3881 ppc_stub_save_res
3882 };
3883
3884 /* Information on stub grouping. */
3885 struct map_stub
3886 {
3887 /* The stub section. */
3888 asection *stub_sec;
3889 /* This is the section to which stubs in the group will be attached. */
3890 asection *link_sec;
3891 /* Next group. */
3892 struct map_stub *next;
3893 /* Whether to emit a copy of register save/restore functions in this
3894 group. */
3895 int needs_save_res;
3896 };
3897
3898 struct ppc_stub_hash_entry {
3899
3900 /* Base hash table entry structure. */
3901 struct bfd_hash_entry root;
3902
3903 enum ppc_stub_type stub_type;
3904
3905 /* Group information. */
3906 struct map_stub *group;
3907
3908 /* Offset within stub_sec of the beginning of this stub. */
3909 bfd_vma stub_offset;
3910
3911 /* Given the symbol's value and its section we can determine its final
3912 value when building the stubs (so the stub knows where to jump. */
3913 bfd_vma target_value;
3914 asection *target_section;
3915
3916 /* The symbol table entry, if any, that this was derived from. */
3917 struct ppc_link_hash_entry *h;
3918 struct plt_entry *plt_ent;
3919
3920 /* Symbol st_other. */
3921 unsigned char other;
3922 };
3923
3924 struct ppc_branch_hash_entry {
3925
3926 /* Base hash table entry structure. */
3927 struct bfd_hash_entry root;
3928
3929 /* Offset within branch lookup table. */
3930 unsigned int offset;
3931
3932 /* Generation marker. */
3933 unsigned int iter;
3934 };
3935
3936 /* Used to track dynamic relocations for local symbols. */
3937 struct ppc_dyn_relocs
3938 {
3939 struct ppc_dyn_relocs *next;
3940
3941 /* The input section of the reloc. */
3942 asection *sec;
3943
3944 /* Total number of relocs copied for the input section. */
3945 unsigned int count : 31;
3946
3947 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3948 unsigned int ifunc : 1;
3949 };
3950
3951 struct ppc_link_hash_entry
3952 {
3953 struct elf_link_hash_entry elf;
3954
3955 union {
3956 /* A pointer to the most recently used stub hash entry against this
3957 symbol. */
3958 struct ppc_stub_hash_entry *stub_cache;
3959
3960 /* A pointer to the next symbol starting with a '.' */
3961 struct ppc_link_hash_entry *next_dot_sym;
3962 } u;
3963
3964 /* Track dynamic relocs copied for this symbol. */
3965 struct elf_dyn_relocs *dyn_relocs;
3966
3967 /* Chain of aliases referring to a weakdef. */
3968 struct ppc_link_hash_entry *weakref;
3969
3970 /* Link between function code and descriptor symbols. */
3971 struct ppc_link_hash_entry *oh;
3972
3973 /* Flag function code and descriptor symbols. */
3974 unsigned int is_func:1;
3975 unsigned int is_func_descriptor:1;
3976 unsigned int fake:1;
3977
3978 /* Whether global opd/toc sym has been adjusted or not.
3979 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3980 should be set for all globals defined in any opd/toc section. */
3981 unsigned int adjust_done:1;
3982
3983 /* Set if this is an out-of-line register save/restore function,
3984 with non-standard calling convention. */
3985 unsigned int save_res:1;
3986
3987 /* Contexts in which symbol is used in the GOT (or TOC).
3988 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3989 corresponding relocs are encountered during check_relocs.
3990 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3991 indicate the corresponding GOT entry type is not needed.
3992 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3993 a TPREL one. We use a separate flag rather than setting TPREL
3994 just for convenience in distinguishing the two cases. */
3995 #define TLS_GD 1 /* GD reloc. */
3996 #define TLS_LD 2 /* LD reloc. */
3997 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3998 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3999 #define TLS_TLS 16 /* Any TLS reloc. */
4000 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4001 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4002 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4003 unsigned char tls_mask;
4004 };
4005
4006 /* ppc64 ELF linker hash table. */
4007
4008 struct ppc_link_hash_table
4009 {
4010 struct elf_link_hash_table elf;
4011
4012 /* The stub hash table. */
4013 struct bfd_hash_table stub_hash_table;
4014
4015 /* Another hash table for plt_branch stubs. */
4016 struct bfd_hash_table branch_hash_table;
4017
4018 /* Hash table for function prologue tocsave. */
4019 htab_t tocsave_htab;
4020
4021 /* Various options and other info passed from the linker. */
4022 struct ppc64_elf_params *params;
4023
4024 /* The size of sec_info below. */
4025 unsigned int sec_info_arr_size;
4026
4027 /* Per-section array of extra section info. Done this way rather
4028 than as part of ppc64_elf_section_data so we have the info for
4029 non-ppc64 sections. */
4030 struct
4031 {
4032 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4033 bfd_vma toc_off;
4034
4035 union
4036 {
4037 /* The section group that this section belongs to. */
4038 struct map_stub *group;
4039 /* A temp section list pointer. */
4040 asection *list;
4041 } u;
4042 } *sec_info;
4043
4044 /* Linked list of groups. */
4045 struct map_stub *group;
4046
4047 /* Temp used when calculating TOC pointers. */
4048 bfd_vma toc_curr;
4049 bfd *toc_bfd;
4050 asection *toc_first_sec;
4051
4052 /* Used when adding symbols. */
4053 struct ppc_link_hash_entry *dot_syms;
4054
4055 /* Shortcuts to get to dynamic linker sections. */
4056 asection *dynbss;
4057 asection *relbss;
4058 asection *glink;
4059 asection *sfpr;
4060 asection *brlt;
4061 asection *relbrlt;
4062 asection *glink_eh_frame;
4063
4064 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4065 struct ppc_link_hash_entry *tls_get_addr;
4066 struct ppc_link_hash_entry *tls_get_addr_fd;
4067
4068 /* The size of reliplt used by got entry relocs. */
4069 bfd_size_type got_reli_size;
4070
4071 /* Statistics. */
4072 unsigned long stub_count[ppc_stub_global_entry];
4073
4074 /* Number of stubs against global syms. */
4075 unsigned long stub_globals;
4076
4077 /* Set if we're linking code with function descriptors. */
4078 unsigned int opd_abi:1;
4079
4080 /* Support for multiple toc sections. */
4081 unsigned int do_multi_toc:1;
4082 unsigned int multi_toc_needed:1;
4083 unsigned int second_toc_pass:1;
4084 unsigned int do_toc_opt:1;
4085
4086 /* Set on error. */
4087 unsigned int stub_error:1;
4088
4089 /* Whether func_desc_adjust needs to be run over symbols. */
4090 unsigned int need_func_desc_adj:1;
4091
4092 /* Incremented every time we size stubs. */
4093 unsigned int stub_iteration;
4094
4095 /* Small local sym cache. */
4096 struct sym_cache sym_cache;
4097 };
4098
4099 /* Rename some of the generic section flags to better document how they
4100 are used here. */
4101
4102 /* Nonzero if this section has TLS related relocations. */
4103 #define has_tls_reloc sec_flg0
4104
4105 /* Nonzero if this section has a call to __tls_get_addr. */
4106 #define has_tls_get_addr_call sec_flg1
4107
4108 /* Nonzero if this section has any toc or got relocs. */
4109 #define has_toc_reloc sec_flg2
4110
4111 /* Nonzero if this section has a call to another section that uses
4112 the toc or got. */
4113 #define makes_toc_func_call sec_flg3
4114
4115 /* Recursion protection when determining above flag. */
4116 #define call_check_in_progress sec_flg4
4117 #define call_check_done sec_flg5
4118
4119 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4120
4121 #define ppc_hash_table(p) \
4122 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4123 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4124
4125 #define ppc_stub_hash_lookup(table, string, create, copy) \
4126 ((struct ppc_stub_hash_entry *) \
4127 bfd_hash_lookup ((table), (string), (create), (copy)))
4128
4129 #define ppc_branch_hash_lookup(table, string, create, copy) \
4130 ((struct ppc_branch_hash_entry *) \
4131 bfd_hash_lookup ((table), (string), (create), (copy)))
4132
4133 /* Create an entry in the stub hash table. */
4134
4135 static struct bfd_hash_entry *
4136 stub_hash_newfunc (struct bfd_hash_entry *entry,
4137 struct bfd_hash_table *table,
4138 const char *string)
4139 {
4140 /* Allocate the structure if it has not already been allocated by a
4141 subclass. */
4142 if (entry == NULL)
4143 {
4144 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4145 if (entry == NULL)
4146 return entry;
4147 }
4148
4149 /* Call the allocation method of the superclass. */
4150 entry = bfd_hash_newfunc (entry, table, string);
4151 if (entry != NULL)
4152 {
4153 struct ppc_stub_hash_entry *eh;
4154
4155 /* Initialize the local fields. */
4156 eh = (struct ppc_stub_hash_entry *) entry;
4157 eh->stub_type = ppc_stub_none;
4158 eh->group = NULL;
4159 eh->stub_offset = 0;
4160 eh->target_value = 0;
4161 eh->target_section = NULL;
4162 eh->h = NULL;
4163 eh->plt_ent = NULL;
4164 eh->other = 0;
4165 }
4166
4167 return entry;
4168 }
4169
4170 /* Create an entry in the branch hash table. */
4171
4172 static struct bfd_hash_entry *
4173 branch_hash_newfunc (struct bfd_hash_entry *entry,
4174 struct bfd_hash_table *table,
4175 const char *string)
4176 {
4177 /* Allocate the structure if it has not already been allocated by a
4178 subclass. */
4179 if (entry == NULL)
4180 {
4181 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4182 if (entry == NULL)
4183 return entry;
4184 }
4185
4186 /* Call the allocation method of the superclass. */
4187 entry = bfd_hash_newfunc (entry, table, string);
4188 if (entry != NULL)
4189 {
4190 struct ppc_branch_hash_entry *eh;
4191
4192 /* Initialize the local fields. */
4193 eh = (struct ppc_branch_hash_entry *) entry;
4194 eh->offset = 0;
4195 eh->iter = 0;
4196 }
4197
4198 return entry;
4199 }
4200
4201 /* Create an entry in a ppc64 ELF linker hash table. */
4202
4203 static struct bfd_hash_entry *
4204 link_hash_newfunc (struct bfd_hash_entry *entry,
4205 struct bfd_hash_table *table,
4206 const char *string)
4207 {
4208 /* Allocate the structure if it has not already been allocated by a
4209 subclass. */
4210 if (entry == NULL)
4211 {
4212 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4213 if (entry == NULL)
4214 return entry;
4215 }
4216
4217 /* Call the allocation method of the superclass. */
4218 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4219 if (entry != NULL)
4220 {
4221 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4222
4223 memset (&eh->u.stub_cache, 0,
4224 (sizeof (struct ppc_link_hash_entry)
4225 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4226
4227 /* When making function calls, old ABI code references function entry
4228 points (dot symbols), while new ABI code references the function
4229 descriptor symbol. We need to make any combination of reference and
4230 definition work together, without breaking archive linking.
4231
4232 For a defined function "foo" and an undefined call to "bar":
4233 An old object defines "foo" and ".foo", references ".bar" (possibly
4234 "bar" too).
4235 A new object defines "foo" and references "bar".
4236
4237 A new object thus has no problem with its undefined symbols being
4238 satisfied by definitions in an old object. On the other hand, the
4239 old object won't have ".bar" satisfied by a new object.
4240
4241 Keep a list of newly added dot-symbols. */
4242
4243 if (string[0] == '.')
4244 {
4245 struct ppc_link_hash_table *htab;
4246
4247 htab = (struct ppc_link_hash_table *) table;
4248 eh->u.next_dot_sym = htab->dot_syms;
4249 htab->dot_syms = eh;
4250 }
4251 }
4252
4253 return entry;
4254 }
4255
4256 struct tocsave_entry {
4257 asection *sec;
4258 bfd_vma offset;
4259 };
4260
4261 static hashval_t
4262 tocsave_htab_hash (const void *p)
4263 {
4264 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4265 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4266 }
4267
4268 static int
4269 tocsave_htab_eq (const void *p1, const void *p2)
4270 {
4271 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4272 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4273 return e1->sec == e2->sec && e1->offset == e2->offset;
4274 }
4275
4276 /* Destroy a ppc64 ELF linker hash table. */
4277
4278 static void
4279 ppc64_elf_link_hash_table_free (bfd *obfd)
4280 {
4281 struct ppc_link_hash_table *htab;
4282
4283 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4284 if (htab->tocsave_htab)
4285 htab_delete (htab->tocsave_htab);
4286 bfd_hash_table_free (&htab->branch_hash_table);
4287 bfd_hash_table_free (&htab->stub_hash_table);
4288 _bfd_elf_link_hash_table_free (obfd);
4289 }
4290
4291 /* Create a ppc64 ELF linker hash table. */
4292
4293 static struct bfd_link_hash_table *
4294 ppc64_elf_link_hash_table_create (bfd *abfd)
4295 {
4296 struct ppc_link_hash_table *htab;
4297 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4298
4299 htab = bfd_zmalloc (amt);
4300 if (htab == NULL)
4301 return NULL;
4302
4303 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4304 sizeof (struct ppc_link_hash_entry),
4305 PPC64_ELF_DATA))
4306 {
4307 free (htab);
4308 return NULL;
4309 }
4310
4311 /* Init the stub hash table too. */
4312 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4313 sizeof (struct ppc_stub_hash_entry)))
4314 {
4315 _bfd_elf_link_hash_table_free (abfd);
4316 return NULL;
4317 }
4318
4319 /* And the branch hash table. */
4320 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4321 sizeof (struct ppc_branch_hash_entry)))
4322 {
4323 bfd_hash_table_free (&htab->stub_hash_table);
4324 _bfd_elf_link_hash_table_free (abfd);
4325 return NULL;
4326 }
4327
4328 htab->tocsave_htab = htab_try_create (1024,
4329 tocsave_htab_hash,
4330 tocsave_htab_eq,
4331 NULL);
4332 if (htab->tocsave_htab == NULL)
4333 {
4334 ppc64_elf_link_hash_table_free (abfd);
4335 return NULL;
4336 }
4337 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4338
4339 /* Initializing two fields of the union is just cosmetic. We really
4340 only care about glist, but when compiled on a 32-bit host the
4341 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4342 debugger inspection of these fields look nicer. */
4343 htab->elf.init_got_refcount.refcount = 0;
4344 htab->elf.init_got_refcount.glist = NULL;
4345 htab->elf.init_plt_refcount.refcount = 0;
4346 htab->elf.init_plt_refcount.glist = NULL;
4347 htab->elf.init_got_offset.offset = 0;
4348 htab->elf.init_got_offset.glist = NULL;
4349 htab->elf.init_plt_offset.offset = 0;
4350 htab->elf.init_plt_offset.glist = NULL;
4351
4352 return &htab->elf.root;
4353 }
4354
4355 /* Create sections for linker generated code. */
4356
4357 static bfd_boolean
4358 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4359 {
4360 struct ppc_link_hash_table *htab;
4361 flagword flags;
4362
4363 htab = ppc_hash_table (info);
4364
4365 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4366 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4367 if (htab->params->save_restore_funcs)
4368 {
4369 /* Create .sfpr for code to save and restore fp regs. */
4370 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4371 flags);
4372 if (htab->sfpr == NULL
4373 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4374 return FALSE;
4375 }
4376
4377 if (bfd_link_relocatable (info))
4378 return TRUE;
4379
4380 /* Create .glink for lazy dynamic linking support. */
4381 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4382 flags);
4383 if (htab->glink == NULL
4384 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4385 return FALSE;
4386
4387 if (!info->no_ld_generated_unwind_info)
4388 {
4389 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4390 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4391 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4392 ".eh_frame",
4393 flags);
4394 if (htab->glink_eh_frame == NULL
4395 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4396 return FALSE;
4397 }
4398
4399 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4400 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4401 if (htab->elf.iplt == NULL
4402 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4403 return FALSE;
4404
4405 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4406 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4407 htab->elf.irelplt
4408 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4409 if (htab->elf.irelplt == NULL
4410 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4411 return FALSE;
4412
4413 /* Create branch lookup table for plt_branch stubs. */
4414 flags = (SEC_ALLOC | SEC_LOAD
4415 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4416 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4417 flags);
4418 if (htab->brlt == NULL
4419 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4420 return FALSE;
4421
4422 if (!bfd_link_pic (info))
4423 return TRUE;
4424
4425 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4426 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4427 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4428 ".rela.branch_lt",
4429 flags);
4430 if (htab->relbrlt == NULL
4431 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4432 return FALSE;
4433
4434 return TRUE;
4435 }
4436
4437 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4438
4439 bfd_boolean
4440 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4441 struct ppc64_elf_params *params)
4442 {
4443 struct ppc_link_hash_table *htab;
4444
4445 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4446
4447 /* Always hook our dynamic sections into the first bfd, which is the
4448 linker created stub bfd. This ensures that the GOT header is at
4449 the start of the output TOC section. */
4450 htab = ppc_hash_table (info);
4451 htab->elf.dynobj = params->stub_bfd;
4452 htab->params = params;
4453
4454 return create_linkage_sections (htab->elf.dynobj, info);
4455 }
4456
4457 /* Build a name for an entry in the stub hash table. */
4458
4459 static char *
4460 ppc_stub_name (const asection *input_section,
4461 const asection *sym_sec,
4462 const struct ppc_link_hash_entry *h,
4463 const Elf_Internal_Rela *rel)
4464 {
4465 char *stub_name;
4466 ssize_t len;
4467
4468 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4469 offsets from a sym as a branch target? In fact, we could
4470 probably assume the addend is always zero. */
4471 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4472
4473 if (h)
4474 {
4475 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4476 stub_name = bfd_malloc (len);
4477 if (stub_name == NULL)
4478 return stub_name;
4479
4480 len = sprintf (stub_name, "%08x.%s+%x",
4481 input_section->id & 0xffffffff,
4482 h->elf.root.root.string,
4483 (int) rel->r_addend & 0xffffffff);
4484 }
4485 else
4486 {
4487 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4488 stub_name = bfd_malloc (len);
4489 if (stub_name == NULL)
4490 return stub_name;
4491
4492 len = sprintf (stub_name, "%08x.%x:%x+%x",
4493 input_section->id & 0xffffffff,
4494 sym_sec->id & 0xffffffff,
4495 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4496 (int) rel->r_addend & 0xffffffff);
4497 }
4498 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4499 stub_name[len - 2] = 0;
4500 return stub_name;
4501 }
4502
4503 /* Look up an entry in the stub hash. Stub entries are cached because
4504 creating the stub name takes a bit of time. */
4505
4506 static struct ppc_stub_hash_entry *
4507 ppc_get_stub_entry (const asection *input_section,
4508 const asection *sym_sec,
4509 struct ppc_link_hash_entry *h,
4510 const Elf_Internal_Rela *rel,
4511 struct ppc_link_hash_table *htab)
4512 {
4513 struct ppc_stub_hash_entry *stub_entry;
4514 struct map_stub *group;
4515
4516 /* If this input section is part of a group of sections sharing one
4517 stub section, then use the id of the first section in the group.
4518 Stub names need to include a section id, as there may well be
4519 more than one stub used to reach say, printf, and we need to
4520 distinguish between them. */
4521 group = htab->sec_info[input_section->id].u.group;
4522 if (group == NULL)
4523 return NULL;
4524
4525 if (h != NULL && h->u.stub_cache != NULL
4526 && h->u.stub_cache->h == h
4527 && h->u.stub_cache->group == group)
4528 {
4529 stub_entry = h->u.stub_cache;
4530 }
4531 else
4532 {
4533 char *stub_name;
4534
4535 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4536 if (stub_name == NULL)
4537 return NULL;
4538
4539 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4540 stub_name, FALSE, FALSE);
4541 if (h != NULL)
4542 h->u.stub_cache = stub_entry;
4543
4544 free (stub_name);
4545 }
4546
4547 return stub_entry;
4548 }
4549
4550 /* Add a new stub entry to the stub hash. Not all fields of the new
4551 stub entry are initialised. */
4552
4553 static struct ppc_stub_hash_entry *
4554 ppc_add_stub (const char *stub_name,
4555 asection *section,
4556 struct bfd_link_info *info)
4557 {
4558 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4559 struct map_stub *group;
4560 asection *link_sec;
4561 asection *stub_sec;
4562 struct ppc_stub_hash_entry *stub_entry;
4563
4564 group = htab->sec_info[section->id].u.group;
4565 link_sec = group->link_sec;
4566 stub_sec = group->stub_sec;
4567 if (stub_sec == NULL)
4568 {
4569 size_t namelen;
4570 bfd_size_type len;
4571 char *s_name;
4572
4573 namelen = strlen (link_sec->name);
4574 len = namelen + sizeof (STUB_SUFFIX);
4575 s_name = bfd_alloc (htab->params->stub_bfd, len);
4576 if (s_name == NULL)
4577 return NULL;
4578
4579 memcpy (s_name, link_sec->name, namelen);
4580 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4581 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4582 if (stub_sec == NULL)
4583 return NULL;
4584 group->stub_sec = stub_sec;
4585 }
4586
4587 /* Enter this entry into the linker stub hash table. */
4588 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4589 TRUE, FALSE);
4590 if (stub_entry == NULL)
4591 {
4592 /* xgettext:c-format */
4593 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4594 section->owner, stub_name);
4595 return NULL;
4596 }
4597
4598 stub_entry->group = group;
4599 stub_entry->stub_offset = 0;
4600 return stub_entry;
4601 }
4602
4603 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4604 not already done. */
4605
4606 static bfd_boolean
4607 create_got_section (bfd *abfd, struct bfd_link_info *info)
4608 {
4609 asection *got, *relgot;
4610 flagword flags;
4611 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4612
4613 if (!is_ppc64_elf (abfd))
4614 return FALSE;
4615 if (htab == NULL)
4616 return FALSE;
4617
4618 if (!htab->elf.sgot
4619 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4620 return FALSE;
4621
4622 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4623 | SEC_LINKER_CREATED);
4624
4625 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4626 if (!got
4627 || !bfd_set_section_alignment (abfd, got, 3))
4628 return FALSE;
4629
4630 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4631 flags | SEC_READONLY);
4632 if (!relgot
4633 || ! bfd_set_section_alignment (abfd, relgot, 3))
4634 return FALSE;
4635
4636 ppc64_elf_tdata (abfd)->got = got;
4637 ppc64_elf_tdata (abfd)->relgot = relgot;
4638 return TRUE;
4639 }
4640
4641 /* Create the dynamic sections, and set up shortcuts. */
4642
4643 static bfd_boolean
4644 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4645 {
4646 struct ppc_link_hash_table *htab;
4647
4648 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4649 return FALSE;
4650
4651 htab = ppc_hash_table (info);
4652 if (htab == NULL)
4653 return FALSE;
4654
4655 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4656 if (!bfd_link_pic (info))
4657 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4658
4659 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4660 || (!bfd_link_pic (info) && !htab->relbss))
4661 abort ();
4662
4663 return TRUE;
4664 }
4665
4666 /* Follow indirect and warning symbol links. */
4667
4668 static inline struct bfd_link_hash_entry *
4669 follow_link (struct bfd_link_hash_entry *h)
4670 {
4671 while (h->type == bfd_link_hash_indirect
4672 || h->type == bfd_link_hash_warning)
4673 h = h->u.i.link;
4674 return h;
4675 }
4676
4677 static inline struct elf_link_hash_entry *
4678 elf_follow_link (struct elf_link_hash_entry *h)
4679 {
4680 return (struct elf_link_hash_entry *) follow_link (&h->root);
4681 }
4682
4683 static inline struct ppc_link_hash_entry *
4684 ppc_follow_link (struct ppc_link_hash_entry *h)
4685 {
4686 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4687 }
4688
4689 /* Merge PLT info on FROM with that on TO. */
4690
4691 static void
4692 move_plt_plist (struct ppc_link_hash_entry *from,
4693 struct ppc_link_hash_entry *to)
4694 {
4695 if (from->elf.plt.plist != NULL)
4696 {
4697 if (to->elf.plt.plist != NULL)
4698 {
4699 struct plt_entry **entp;
4700 struct plt_entry *ent;
4701
4702 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4703 {
4704 struct plt_entry *dent;
4705
4706 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4707 if (dent->addend == ent->addend)
4708 {
4709 dent->plt.refcount += ent->plt.refcount;
4710 *entp = ent->next;
4711 break;
4712 }
4713 if (dent == NULL)
4714 entp = &ent->next;
4715 }
4716 *entp = to->elf.plt.plist;
4717 }
4718
4719 to->elf.plt.plist = from->elf.plt.plist;
4720 from->elf.plt.plist = NULL;
4721 }
4722 }
4723
4724 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4725
4726 static void
4727 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4728 struct elf_link_hash_entry *dir,
4729 struct elf_link_hash_entry *ind)
4730 {
4731 struct ppc_link_hash_entry *edir, *eind;
4732
4733 edir = (struct ppc_link_hash_entry *) dir;
4734 eind = (struct ppc_link_hash_entry *) ind;
4735
4736 edir->is_func |= eind->is_func;
4737 edir->is_func_descriptor |= eind->is_func_descriptor;
4738 edir->tls_mask |= eind->tls_mask;
4739 if (eind->oh != NULL)
4740 edir->oh = ppc_follow_link (eind->oh);
4741
4742 if (edir->elf.versioned != versioned_hidden)
4743 {
4744 /* If called to transfer flags for a weakdef during processing
4745 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4746 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4747 if (!(ELIMINATE_COPY_RELOCS
4748 && eind->elf.root.type != bfd_link_hash_indirect
4749 && edir->elf.dynamic_adjusted))
4750 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4751
4752 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4753 edir->elf.ref_regular |= eind->elf.ref_regular;
4754 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4755 edir->elf.needs_plt |= eind->elf.needs_plt;
4756 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4757 }
4758
4759 /* If we were called to copy over info for a weak sym, don't copy
4760 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4761 in order to simplify readonly_dynrelocs and save a field in the
4762 symbol hash entry, but that means dyn_relocs can't be used in any
4763 tests about a specific symbol, or affect other symbol flags which
4764 are then tested.
4765 Chain weakdefs so we can get from the weakdef back to an alias.
4766 The list is circular so that we don't need to use u.weakdef as
4767 well as this list to look at all aliases. */
4768 if (eind->elf.root.type != bfd_link_hash_indirect)
4769 {
4770 struct ppc_link_hash_entry *cur, *add, *next;
4771
4772 add = eind;
4773 do
4774 {
4775 cur = edir->weakref;
4776 if (cur != NULL)
4777 {
4778 do
4779 {
4780 /* We can be called twice for the same symbols.
4781 Don't make multiple loops. */
4782 if (cur == add)
4783 return;
4784 cur = cur->weakref;
4785 } while (cur != edir);
4786 }
4787 next = add->weakref;
4788 if (cur != add)
4789 {
4790 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4791 edir->weakref = add;
4792 }
4793 add = next;
4794 } while (add != NULL && add != eind);
4795 return;
4796 }
4797
4798 /* Copy over any dynamic relocs we may have on the indirect sym. */
4799 if (eind->dyn_relocs != NULL)
4800 {
4801 if (edir->dyn_relocs != NULL)
4802 {
4803 struct elf_dyn_relocs **pp;
4804 struct elf_dyn_relocs *p;
4805
4806 /* Add reloc counts against the indirect sym to the direct sym
4807 list. Merge any entries against the same section. */
4808 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4809 {
4810 struct elf_dyn_relocs *q;
4811
4812 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4813 if (q->sec == p->sec)
4814 {
4815 q->pc_count += p->pc_count;
4816 q->count += p->count;
4817 *pp = p->next;
4818 break;
4819 }
4820 if (q == NULL)
4821 pp = &p->next;
4822 }
4823 *pp = edir->dyn_relocs;
4824 }
4825
4826 edir->dyn_relocs = eind->dyn_relocs;
4827 eind->dyn_relocs = NULL;
4828 }
4829
4830 /* Copy over got entries that we may have already seen to the
4831 symbol which just became indirect. */
4832 if (eind->elf.got.glist != NULL)
4833 {
4834 if (edir->elf.got.glist != NULL)
4835 {
4836 struct got_entry **entp;
4837 struct got_entry *ent;
4838
4839 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4840 {
4841 struct got_entry *dent;
4842
4843 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4844 if (dent->addend == ent->addend
4845 && dent->owner == ent->owner
4846 && dent->tls_type == ent->tls_type)
4847 {
4848 dent->got.refcount += ent->got.refcount;
4849 *entp = ent->next;
4850 break;
4851 }
4852 if (dent == NULL)
4853 entp = &ent->next;
4854 }
4855 *entp = edir->elf.got.glist;
4856 }
4857
4858 edir->elf.got.glist = eind->elf.got.glist;
4859 eind->elf.got.glist = NULL;
4860 }
4861
4862 /* And plt entries. */
4863 move_plt_plist (eind, edir);
4864
4865 if (eind->elf.dynindx != -1)
4866 {
4867 if (edir->elf.dynindx != -1)
4868 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4869 edir->elf.dynstr_index);
4870 edir->elf.dynindx = eind->elf.dynindx;
4871 edir->elf.dynstr_index = eind->elf.dynstr_index;
4872 eind->elf.dynindx = -1;
4873 eind->elf.dynstr_index = 0;
4874 }
4875 }
4876
4877 /* Find the function descriptor hash entry from the given function code
4878 hash entry FH. Link the entries via their OH fields. */
4879
4880 static struct ppc_link_hash_entry *
4881 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4882 {
4883 struct ppc_link_hash_entry *fdh = fh->oh;
4884
4885 if (fdh == NULL)
4886 {
4887 const char *fd_name = fh->elf.root.root.string + 1;
4888
4889 fdh = (struct ppc_link_hash_entry *)
4890 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4891 if (fdh == NULL)
4892 return fdh;
4893
4894 fdh->is_func_descriptor = 1;
4895 fdh->oh = fh;
4896 fh->is_func = 1;
4897 fh->oh = fdh;
4898 }
4899
4900 fdh = ppc_follow_link (fdh);
4901 fdh->is_func_descriptor = 1;
4902 fdh->oh = fh;
4903 return fdh;
4904 }
4905
4906 /* Make a fake function descriptor sym for the undefined code sym FH. */
4907
4908 static struct ppc_link_hash_entry *
4909 make_fdh (struct bfd_link_info *info,
4910 struct ppc_link_hash_entry *fh)
4911 {
4912 bfd *abfd = fh->elf.root.u.undef.abfd;
4913 struct bfd_link_hash_entry *bh = NULL;
4914 struct ppc_link_hash_entry *fdh;
4915 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4916 ? BSF_WEAK
4917 : BSF_GLOBAL);
4918
4919 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4920 fh->elf.root.root.string + 1,
4921 flags, bfd_und_section_ptr, 0,
4922 NULL, FALSE, FALSE, &bh))
4923 return NULL;
4924
4925 fdh = (struct ppc_link_hash_entry *) bh;
4926 fdh->elf.non_elf = 0;
4927 fdh->fake = 1;
4928 fdh->is_func_descriptor = 1;
4929 fdh->oh = fh;
4930 fh->is_func = 1;
4931 fh->oh = fdh;
4932 return fdh;
4933 }
4934
4935 /* Fix function descriptor symbols defined in .opd sections to be
4936 function type. */
4937
4938 static bfd_boolean
4939 ppc64_elf_add_symbol_hook (bfd *ibfd,
4940 struct bfd_link_info *info,
4941 Elf_Internal_Sym *isym,
4942 const char **name,
4943 flagword *flags ATTRIBUTE_UNUSED,
4944 asection **sec,
4945 bfd_vma *value)
4946 {
4947 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4948 && (ibfd->flags & DYNAMIC) == 0
4949 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4950 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4951
4952 if (*sec != NULL
4953 && strcmp ((*sec)->name, ".opd") == 0)
4954 {
4955 asection *code_sec;
4956
4957 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4958 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4959 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4960
4961 /* If the symbol is a function defined in .opd, and the function
4962 code is in a discarded group, let it appear to be undefined. */
4963 if (!bfd_link_relocatable (info)
4964 && (*sec)->reloc_count != 0
4965 && opd_entry_value (*sec, *value, &code_sec, NULL,
4966 FALSE) != (bfd_vma) -1
4967 && discarded_section (code_sec))
4968 {
4969 *sec = bfd_und_section_ptr;
4970 isym->st_shndx = SHN_UNDEF;
4971 }
4972 }
4973 else if (*sec != NULL
4974 && strcmp ((*sec)->name, ".toc") == 0
4975 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4976 {
4977 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4978 if (htab != NULL)
4979 htab->params->object_in_toc = 1;
4980 }
4981
4982 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4983 {
4984 if (abiversion (ibfd) == 0)
4985 set_abiversion (ibfd, 2);
4986 else if (abiversion (ibfd) == 1)
4987 {
4988 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4989 " for ABI version 1\n"), name);
4990 bfd_set_error (bfd_error_bad_value);
4991 return FALSE;
4992 }
4993 }
4994
4995 return TRUE;
4996 }
4997
4998 /* Merge non-visibility st_other attributes: local entry point. */
4999
5000 static void
5001 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5002 const Elf_Internal_Sym *isym,
5003 bfd_boolean definition,
5004 bfd_boolean dynamic)
5005 {
5006 if (definition && !dynamic)
5007 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5008 | ELF_ST_VISIBILITY (h->other));
5009 }
5010
5011 /* Hook called on merging a symbol. We use this to clear "fake" since
5012 we now have a real symbol. */
5013
5014 static bfd_boolean
5015 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5016 const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5017 asection **psec ATTRIBUTE_UNUSED,
5018 bfd_boolean newdef ATTRIBUTE_UNUSED,
5019 bfd_boolean olddef ATTRIBUTE_UNUSED,
5020 bfd *oldbfd ATTRIBUTE_UNUSED,
5021 const asection *oldsec ATTRIBUTE_UNUSED)
5022 {
5023 ((struct ppc_link_hash_entry *) h)->fake = 0;
5024 return TRUE;
5025 }
5026
5027 /* This function makes an old ABI object reference to ".bar" cause the
5028 inclusion of a new ABI object archive that defines "bar".
5029 NAME is a symbol defined in an archive. Return a symbol in the hash
5030 table that might be satisfied by the archive symbols. */
5031
5032 static struct elf_link_hash_entry *
5033 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5034 struct bfd_link_info *info,
5035 const char *name)
5036 {
5037 struct elf_link_hash_entry *h;
5038 char *dot_name;
5039 size_t len;
5040
5041 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5042 if (h != NULL
5043 /* Don't return this sym if it is a fake function descriptor
5044 created by add_symbol_adjust. */
5045 && !((struct ppc_link_hash_entry *) h)->fake)
5046 return h;
5047
5048 if (name[0] == '.')
5049 return h;
5050
5051 len = strlen (name);
5052 dot_name = bfd_alloc (abfd, len + 2);
5053 if (dot_name == NULL)
5054 return (struct elf_link_hash_entry *) 0 - 1;
5055 dot_name[0] = '.';
5056 memcpy (dot_name + 1, name, len + 1);
5057 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5058 bfd_release (abfd, dot_name);
5059 return h;
5060 }
5061
5062 /* This function satisfies all old ABI object references to ".bar" if a
5063 new ABI object defines "bar". Well, at least, undefined dot symbols
5064 are made weak. This stops later archive searches from including an
5065 object if we already have a function descriptor definition. It also
5066 prevents the linker complaining about undefined symbols.
5067 We also check and correct mismatched symbol visibility here. The
5068 most restrictive visibility of the function descriptor and the
5069 function entry symbol is used. */
5070
5071 static bfd_boolean
5072 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5073 {
5074 struct ppc_link_hash_table *htab;
5075 struct ppc_link_hash_entry *fdh;
5076
5077 if (eh->elf.root.type == bfd_link_hash_warning)
5078 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5079
5080 if (eh->elf.root.type == bfd_link_hash_indirect)
5081 return TRUE;
5082
5083 if (eh->elf.root.root.string[0] != '.')
5084 abort ();
5085
5086 htab = ppc_hash_table (info);
5087 if (htab == NULL)
5088 return FALSE;
5089
5090 fdh = lookup_fdh (eh, htab);
5091 if (fdh == NULL
5092 && !bfd_link_relocatable (info)
5093 && (eh->elf.root.type == bfd_link_hash_undefined
5094 || eh->elf.root.type == bfd_link_hash_undefweak)
5095 && eh->elf.ref_regular)
5096 {
5097 /* Make an undefined function descriptor sym, in order to
5098 pull in an --as-needed shared lib. Archives are handled
5099 elsewhere. */
5100 fdh = make_fdh (info, eh);
5101 if (fdh == NULL)
5102 return FALSE;
5103 }
5104
5105 if (fdh != NULL)
5106 {
5107 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5108 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5109
5110 /* Make both descriptor and entry symbol have the most
5111 constraining visibility of either symbol. */
5112 if (entry_vis < descr_vis)
5113 fdh->elf.other += entry_vis - descr_vis;
5114 else if (entry_vis > descr_vis)
5115 eh->elf.other += descr_vis - entry_vis;
5116
5117 /* Propagate reference flags from entry symbol to function
5118 descriptor symbol. */
5119 fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5120 fdh->elf.ref_regular |= eh->elf.ref_regular;
5121 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5122
5123 if (!fdh->elf.forced_local
5124 && fdh->elf.dynindx == -1
5125 && fdh->elf.versioned != versioned_hidden
5126 && (bfd_link_dll (info)
5127 || fdh->elf.def_dynamic
5128 || fdh->elf.ref_dynamic)
5129 && (eh->elf.ref_regular
5130 || eh->elf.def_regular))
5131 {
5132 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5133 return FALSE;
5134 }
5135 }
5136
5137 return TRUE;
5138 }
5139
5140 /* Set up opd section info and abiversion for IBFD, and process list
5141 of dot-symbols we made in link_hash_newfunc. */
5142
5143 static bfd_boolean
5144 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5145 {
5146 struct ppc_link_hash_table *htab;
5147 struct ppc_link_hash_entry **p, *eh;
5148 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5149
5150 if (opd != NULL && opd->size != 0)
5151 {
5152 if (abiversion (ibfd) == 0)
5153 set_abiversion (ibfd, 1);
5154 else if (abiversion (ibfd) >= 2)
5155 {
5156 /* xgettext:c-format */
5157 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5158 " version %d\n"),
5159 ibfd, abiversion (ibfd));
5160 bfd_set_error (bfd_error_bad_value);
5161 return FALSE;
5162 }
5163
5164 if ((ibfd->flags & DYNAMIC) == 0
5165 && (opd->flags & SEC_RELOC) != 0
5166 && opd->reloc_count != 0
5167 && !bfd_is_abs_section (opd->output_section))
5168 {
5169 /* Garbage collection needs some extra help with .opd sections.
5170 We don't want to necessarily keep everything referenced by
5171 relocs in .opd, as that would keep all functions. Instead,
5172 if we reference an .opd symbol (a function descriptor), we
5173 want to keep the function code symbol's section. This is
5174 easy for global symbols, but for local syms we need to keep
5175 information about the associated function section. */
5176 bfd_size_type amt;
5177 asection **opd_sym_map;
5178
5179 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5180 opd_sym_map = bfd_zalloc (ibfd, amt);
5181 if (opd_sym_map == NULL)
5182 return FALSE;
5183 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5184 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5185 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5186 }
5187 }
5188
5189 if (!is_ppc64_elf (info->output_bfd))
5190 return TRUE;
5191 htab = ppc_hash_table (info);
5192 if (htab == NULL)
5193 return FALSE;
5194
5195 /* For input files without an explicit abiversion in e_flags
5196 we should have flagged any with symbol st_other bits set
5197 as ELFv1 and above flagged those with .opd as ELFv2.
5198 Set the output abiversion if not yet set, and for any input
5199 still ambiguous, take its abiversion from the output.
5200 Differences in ABI are reported later. */
5201 if (abiversion (info->output_bfd) == 0)
5202 set_abiversion (info->output_bfd, abiversion (ibfd));
5203 else if (abiversion (ibfd) == 0)
5204 set_abiversion (ibfd, abiversion (info->output_bfd));
5205
5206 p = &htab->dot_syms;
5207 while ((eh = *p) != NULL)
5208 {
5209 *p = NULL;
5210 if (&eh->elf == htab->elf.hgot)
5211 ;
5212 else if (htab->elf.hgot == NULL
5213 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5214 htab->elf.hgot = &eh->elf;
5215 else if (abiversion (ibfd) <= 1)
5216 {
5217 htab->need_func_desc_adj = 1;
5218 if (!add_symbol_adjust (eh, info))
5219 return FALSE;
5220 }
5221 p = &eh->u.next_dot_sym;
5222 }
5223 return TRUE;
5224 }
5225
5226 /* Undo hash table changes when an --as-needed input file is determined
5227 not to be needed. */
5228
5229 static bfd_boolean
5230 ppc64_elf_notice_as_needed (bfd *ibfd,
5231 struct bfd_link_info *info,
5232 enum notice_asneeded_action act)
5233 {
5234 if (act == notice_not_needed)
5235 {
5236 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5237
5238 if (htab == NULL)
5239 return FALSE;
5240
5241 htab->dot_syms = NULL;
5242 }
5243 return _bfd_elf_notice_as_needed (ibfd, info, act);
5244 }
5245
5246 /* If --just-symbols against a final linked binary, then assume we need
5247 toc adjusting stubs when calling functions defined there. */
5248
5249 static void
5250 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5251 {
5252 if ((sec->flags & SEC_CODE) != 0
5253 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5254 && is_ppc64_elf (sec->owner))
5255 {
5256 if (abiversion (sec->owner) >= 2
5257 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5258 sec->has_toc_reloc = 1;
5259 }
5260 _bfd_elf_link_just_syms (sec, info);
5261 }
5262
5263 static struct plt_entry **
5264 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5265 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5266 {
5267 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5268 struct plt_entry **local_plt;
5269 unsigned char *local_got_tls_masks;
5270
5271 if (local_got_ents == NULL)
5272 {
5273 bfd_size_type size = symtab_hdr->sh_info;
5274
5275 size *= (sizeof (*local_got_ents)
5276 + sizeof (*local_plt)
5277 + sizeof (*local_got_tls_masks));
5278 local_got_ents = bfd_zalloc (abfd, size);
5279 if (local_got_ents == NULL)
5280 return NULL;
5281 elf_local_got_ents (abfd) = local_got_ents;
5282 }
5283
5284 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5285 {
5286 struct got_entry *ent;
5287
5288 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5289 if (ent->addend == r_addend
5290 && ent->owner == abfd
5291 && ent->tls_type == tls_type)
5292 break;
5293 if (ent == NULL)
5294 {
5295 bfd_size_type amt = sizeof (*ent);
5296 ent = bfd_alloc (abfd, amt);
5297 if (ent == NULL)
5298 return FALSE;
5299 ent->next = local_got_ents[r_symndx];
5300 ent->addend = r_addend;
5301 ent->owner = abfd;
5302 ent->tls_type = tls_type;
5303 ent->is_indirect = FALSE;
5304 ent->got.refcount = 0;
5305 local_got_ents[r_symndx] = ent;
5306 }
5307 ent->got.refcount += 1;
5308 }
5309
5310 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5311 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5312 local_got_tls_masks[r_symndx] |= tls_type;
5313
5314 return local_plt + r_symndx;
5315 }
5316
5317 static bfd_boolean
5318 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5319 {
5320 struct plt_entry *ent;
5321
5322 for (ent = *plist; ent != NULL; ent = ent->next)
5323 if (ent->addend == addend)
5324 break;
5325 if (ent == NULL)
5326 {
5327 bfd_size_type amt = sizeof (*ent);
5328 ent = bfd_alloc (abfd, amt);
5329 if (ent == NULL)
5330 return FALSE;
5331 ent->next = *plist;
5332 ent->addend = addend;
5333 ent->plt.refcount = 0;
5334 *plist = ent;
5335 }
5336 ent->plt.refcount += 1;
5337 return TRUE;
5338 }
5339
5340 static bfd_boolean
5341 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5342 {
5343 return (r_type == R_PPC64_REL24
5344 || r_type == R_PPC64_REL14
5345 || r_type == R_PPC64_REL14_BRTAKEN
5346 || r_type == R_PPC64_REL14_BRNTAKEN
5347 || r_type == R_PPC64_ADDR24
5348 || r_type == R_PPC64_ADDR14
5349 || r_type == R_PPC64_ADDR14_BRTAKEN
5350 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5351 }
5352
5353 /* Look through the relocs for a section during the first phase, and
5354 calculate needed space in the global offset table, procedure
5355 linkage table, and dynamic reloc sections. */
5356
5357 static bfd_boolean
5358 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5359 asection *sec, const Elf_Internal_Rela *relocs)
5360 {
5361 struct ppc_link_hash_table *htab;
5362 Elf_Internal_Shdr *symtab_hdr;
5363 struct elf_link_hash_entry **sym_hashes;
5364 const Elf_Internal_Rela *rel;
5365 const Elf_Internal_Rela *rel_end;
5366 asection *sreloc;
5367 asection **opd_sym_map;
5368 struct elf_link_hash_entry *tga, *dottga;
5369
5370 if (bfd_link_relocatable (info))
5371 return TRUE;
5372
5373 /* Don't do anything special with non-loaded, non-alloced sections.
5374 In particular, any relocs in such sections should not affect GOT
5375 and PLT reference counting (ie. we don't allow them to create GOT
5376 or PLT entries), there's no possibility or desire to optimize TLS
5377 relocs, and there's not much point in propagating relocs to shared
5378 libs that the dynamic linker won't relocate. */
5379 if ((sec->flags & SEC_ALLOC) == 0)
5380 return TRUE;
5381
5382 BFD_ASSERT (is_ppc64_elf (abfd));
5383
5384 htab = ppc_hash_table (info);
5385 if (htab == NULL)
5386 return FALSE;
5387
5388 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5389 FALSE, FALSE, TRUE);
5390 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5391 FALSE, FALSE, TRUE);
5392 symtab_hdr = &elf_symtab_hdr (abfd);
5393 sym_hashes = elf_sym_hashes (abfd);
5394 sreloc = NULL;
5395 opd_sym_map = NULL;
5396 if (ppc64_elf_section_data (sec) != NULL
5397 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5398 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5399
5400 rel_end = relocs + sec->reloc_count;
5401 for (rel = relocs; rel < rel_end; rel++)
5402 {
5403 unsigned long r_symndx;
5404 struct elf_link_hash_entry *h;
5405 enum elf_ppc64_reloc_type r_type;
5406 int tls_type;
5407 struct _ppc64_elf_section_data *ppc64_sec;
5408 struct plt_entry **ifunc, **plt_list;
5409
5410 r_symndx = ELF64_R_SYM (rel->r_info);
5411 if (r_symndx < symtab_hdr->sh_info)
5412 h = NULL;
5413 else
5414 {
5415 struct ppc_link_hash_entry *eh;
5416
5417 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5418 h = elf_follow_link (h);
5419 eh = (struct ppc_link_hash_entry *) h;
5420
5421 /* PR15323, ref flags aren't set for references in the same
5422 object. */
5423 h->root.non_ir_ref = 1;
5424 if (eh->is_func && eh->oh != NULL)
5425 eh->oh->elf.root.non_ir_ref = 1;
5426
5427 if (h == htab->elf.hgot)
5428 sec->has_toc_reloc = 1;
5429 }
5430
5431 tls_type = 0;
5432 ifunc = NULL;
5433 if (h != NULL)
5434 {
5435 if (h->type == STT_GNU_IFUNC)
5436 {
5437 h->needs_plt = 1;
5438 ifunc = &h->plt.plist;
5439 }
5440 }
5441 else
5442 {
5443 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5444 abfd, r_symndx);
5445 if (isym == NULL)
5446 return FALSE;
5447
5448 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5449 {
5450 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5451 rel->r_addend, PLT_IFUNC);
5452 if (ifunc == NULL)
5453 return FALSE;
5454 }
5455 }
5456
5457 r_type = ELF64_R_TYPE (rel->r_info);
5458 switch (r_type)
5459 {
5460 case R_PPC64_TLSGD:
5461 case R_PPC64_TLSLD:
5462 /* These special tls relocs tie a call to __tls_get_addr with
5463 its parameter symbol. */
5464 break;
5465
5466 case R_PPC64_GOT_TLSLD16:
5467 case R_PPC64_GOT_TLSLD16_LO:
5468 case R_PPC64_GOT_TLSLD16_HI:
5469 case R_PPC64_GOT_TLSLD16_HA:
5470 tls_type = TLS_TLS | TLS_LD;
5471 goto dogottls;
5472
5473 case R_PPC64_GOT_TLSGD16:
5474 case R_PPC64_GOT_TLSGD16_LO:
5475 case R_PPC64_GOT_TLSGD16_HI:
5476 case R_PPC64_GOT_TLSGD16_HA:
5477 tls_type = TLS_TLS | TLS_GD;
5478 goto dogottls;
5479
5480 case R_PPC64_GOT_TPREL16_DS:
5481 case R_PPC64_GOT_TPREL16_LO_DS:
5482 case R_PPC64_GOT_TPREL16_HI:
5483 case R_PPC64_GOT_TPREL16_HA:
5484 if (bfd_link_pic (info))
5485 info->flags |= DF_STATIC_TLS;
5486 tls_type = TLS_TLS | TLS_TPREL;
5487 goto dogottls;
5488
5489 case R_PPC64_GOT_DTPREL16_DS:
5490 case R_PPC64_GOT_DTPREL16_LO_DS:
5491 case R_PPC64_GOT_DTPREL16_HI:
5492 case R_PPC64_GOT_DTPREL16_HA:
5493 tls_type = TLS_TLS | TLS_DTPREL;
5494 dogottls:
5495 sec->has_tls_reloc = 1;
5496 /* Fall through */
5497
5498 case R_PPC64_GOT16:
5499 case R_PPC64_GOT16_DS:
5500 case R_PPC64_GOT16_HA:
5501 case R_PPC64_GOT16_HI:
5502 case R_PPC64_GOT16_LO:
5503 case R_PPC64_GOT16_LO_DS:
5504 /* This symbol requires a global offset table entry. */
5505 sec->has_toc_reloc = 1;
5506 if (r_type == R_PPC64_GOT_TLSLD16
5507 || r_type == R_PPC64_GOT_TLSGD16
5508 || r_type == R_PPC64_GOT_TPREL16_DS
5509 || r_type == R_PPC64_GOT_DTPREL16_DS
5510 || r_type == R_PPC64_GOT16
5511 || r_type == R_PPC64_GOT16_DS)
5512 {
5513 htab->do_multi_toc = 1;
5514 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5515 }
5516
5517 if (ppc64_elf_tdata (abfd)->got == NULL
5518 && !create_got_section (abfd, info))
5519 return FALSE;
5520
5521 if (h != NULL)
5522 {
5523 struct ppc_link_hash_entry *eh;
5524 struct got_entry *ent;
5525
5526 eh = (struct ppc_link_hash_entry *) h;
5527 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5528 if (ent->addend == rel->r_addend
5529 && ent->owner == abfd
5530 && ent->tls_type == tls_type)
5531 break;
5532 if (ent == NULL)
5533 {
5534 bfd_size_type amt = sizeof (*ent);
5535 ent = bfd_alloc (abfd, amt);
5536 if (ent == NULL)
5537 return FALSE;
5538 ent->next = eh->elf.got.glist;
5539 ent->addend = rel->r_addend;
5540 ent->owner = abfd;
5541 ent->tls_type = tls_type;
5542 ent->is_indirect = FALSE;
5543 ent->got.refcount = 0;
5544 eh->elf.got.glist = ent;
5545 }
5546 ent->got.refcount += 1;
5547 eh->tls_mask |= tls_type;
5548 }
5549 else
5550 /* This is a global offset table entry for a local symbol. */
5551 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5552 rel->r_addend, tls_type))
5553 return FALSE;
5554
5555 /* We may also need a plt entry if the symbol turns out to be
5556 an ifunc. */
5557 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5558 {
5559 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5560 return FALSE;
5561 }
5562 break;
5563
5564 case R_PPC64_PLT16_HA:
5565 case R_PPC64_PLT16_HI:
5566 case R_PPC64_PLT16_LO:
5567 case R_PPC64_PLT32:
5568 case R_PPC64_PLT64:
5569 /* This symbol requires a procedure linkage table entry. */
5570 plt_list = ifunc;
5571 if (h != NULL)
5572 {
5573 h->needs_plt = 1;
5574 if (h->root.root.string[0] == '.'
5575 && h->root.root.string[1] != '\0')
5576 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5577 plt_list = &h->plt.plist;
5578 }
5579 if (plt_list == NULL)
5580 {
5581 /* It does not make sense to have a procedure linkage
5582 table entry for a non-ifunc local symbol. */
5583 info->callbacks->einfo
5584 /* xgettext:c-format */
5585 (_("%P: %H: %s reloc against local symbol\n"),
5586 abfd, sec, rel->r_offset,
5587 ppc64_elf_howto_table[r_type]->name);
5588 bfd_set_error (bfd_error_bad_value);
5589 return FALSE;
5590 }
5591 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5592 return FALSE;
5593 break;
5594
5595 /* The following relocations don't need to propagate the
5596 relocation if linking a shared object since they are
5597 section relative. */
5598 case R_PPC64_SECTOFF:
5599 case R_PPC64_SECTOFF_LO:
5600 case R_PPC64_SECTOFF_HI:
5601 case R_PPC64_SECTOFF_HA:
5602 case R_PPC64_SECTOFF_DS:
5603 case R_PPC64_SECTOFF_LO_DS:
5604 case R_PPC64_DTPREL16:
5605 case R_PPC64_DTPREL16_LO:
5606 case R_PPC64_DTPREL16_HI:
5607 case R_PPC64_DTPREL16_HA:
5608 case R_PPC64_DTPREL16_DS:
5609 case R_PPC64_DTPREL16_LO_DS:
5610 case R_PPC64_DTPREL16_HIGH:
5611 case R_PPC64_DTPREL16_HIGHA:
5612 case R_PPC64_DTPREL16_HIGHER:
5613 case R_PPC64_DTPREL16_HIGHERA:
5614 case R_PPC64_DTPREL16_HIGHEST:
5615 case R_PPC64_DTPREL16_HIGHESTA:
5616 break;
5617
5618 /* Nor do these. */
5619 case R_PPC64_REL16:
5620 case R_PPC64_REL16_LO:
5621 case R_PPC64_REL16_HI:
5622 case R_PPC64_REL16_HA:
5623 case R_PPC64_REL16DX_HA:
5624 break;
5625
5626 /* Not supported as a dynamic relocation. */
5627 case R_PPC64_ADDR64_LOCAL:
5628 if (bfd_link_pic (info))
5629 {
5630 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5631 ppc_howto_init ();
5632 /* xgettext:c-format */
5633 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5634 "in shared libraries and PIEs.\n"),
5635 abfd, sec, rel->r_offset,
5636 ppc64_elf_howto_table[r_type]->name);
5637 bfd_set_error (bfd_error_bad_value);
5638 return FALSE;
5639 }
5640 break;
5641
5642 case R_PPC64_TOC16:
5643 case R_PPC64_TOC16_DS:
5644 htab->do_multi_toc = 1;
5645 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5646 /* Fall through. */
5647 case R_PPC64_TOC16_LO:
5648 case R_PPC64_TOC16_HI:
5649 case R_PPC64_TOC16_HA:
5650 case R_PPC64_TOC16_LO_DS:
5651 sec->has_toc_reloc = 1;
5652 break;
5653
5654 /* Marker reloc. */
5655 case R_PPC64_ENTRY:
5656 break;
5657
5658 /* This relocation describes the C++ object vtable hierarchy.
5659 Reconstruct it for later use during GC. */
5660 case R_PPC64_GNU_VTINHERIT:
5661 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5662 return FALSE;
5663 break;
5664
5665 /* This relocation describes which C++ vtable entries are actually
5666 used. Record for later use during GC. */
5667 case R_PPC64_GNU_VTENTRY:
5668 BFD_ASSERT (h != NULL);
5669 if (h != NULL
5670 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5671 return FALSE;
5672 break;
5673
5674 case R_PPC64_REL14:
5675 case R_PPC64_REL14_BRTAKEN:
5676 case R_PPC64_REL14_BRNTAKEN:
5677 {
5678 asection *dest = NULL;
5679
5680 /* Heuristic: If jumping outside our section, chances are
5681 we are going to need a stub. */
5682 if (h != NULL)
5683 {
5684 /* If the sym is weak it may be overridden later, so
5685 don't assume we know where a weak sym lives. */
5686 if (h->root.type == bfd_link_hash_defined)
5687 dest = h->root.u.def.section;
5688 }
5689 else
5690 {
5691 Elf_Internal_Sym *isym;
5692
5693 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5694 abfd, r_symndx);
5695 if (isym == NULL)
5696 return FALSE;
5697
5698 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5699 }
5700
5701 if (dest != sec)
5702 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5703 }
5704 /* Fall through. */
5705
5706 case R_PPC64_REL24:
5707 plt_list = ifunc;
5708 if (h != NULL)
5709 {
5710 h->needs_plt = 1;
5711 if (h->root.root.string[0] == '.'
5712 && h->root.root.string[1] != '\0')
5713 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5714
5715 if (h == tga || h == dottga)
5716 {
5717 sec->has_tls_reloc = 1;
5718 if (rel != relocs
5719 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5720 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5721 /* We have a new-style __tls_get_addr call with
5722 a marker reloc. */
5723 ;
5724 else
5725 /* Mark this section as having an old-style call. */
5726 sec->has_tls_get_addr_call = 1;
5727 }
5728 plt_list = &h->plt.plist;
5729 }
5730
5731 /* We may need a .plt entry if the function this reloc
5732 refers to is in a shared lib. */
5733 if (plt_list
5734 && !update_plt_info (abfd, plt_list, rel->r_addend))
5735 return FALSE;
5736 break;
5737
5738 case R_PPC64_ADDR14:
5739 case R_PPC64_ADDR14_BRNTAKEN:
5740 case R_PPC64_ADDR14_BRTAKEN:
5741 case R_PPC64_ADDR24:
5742 goto dodyn;
5743
5744 case R_PPC64_TPREL64:
5745 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5746 if (bfd_link_pic (info))
5747 info->flags |= DF_STATIC_TLS;
5748 goto dotlstoc;
5749
5750 case R_PPC64_DTPMOD64:
5751 if (rel + 1 < rel_end
5752 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5753 && rel[1].r_offset == rel->r_offset + 8)
5754 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5755 else
5756 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5757 goto dotlstoc;
5758
5759 case R_PPC64_DTPREL64:
5760 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5761 if (rel != relocs
5762 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5763 && rel[-1].r_offset == rel->r_offset - 8)
5764 /* This is the second reloc of a dtpmod, dtprel pair.
5765 Don't mark with TLS_DTPREL. */
5766 goto dodyn;
5767
5768 dotlstoc:
5769 sec->has_tls_reloc = 1;
5770 if (h != NULL)
5771 {
5772 struct ppc_link_hash_entry *eh;
5773 eh = (struct ppc_link_hash_entry *) h;
5774 eh->tls_mask |= tls_type;
5775 }
5776 else
5777 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5778 rel->r_addend, tls_type))
5779 return FALSE;
5780
5781 ppc64_sec = ppc64_elf_section_data (sec);
5782 if (ppc64_sec->sec_type != sec_toc)
5783 {
5784 bfd_size_type amt;
5785
5786 /* One extra to simplify get_tls_mask. */
5787 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5788 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5789 if (ppc64_sec->u.toc.symndx == NULL)
5790 return FALSE;
5791 amt = sec->size * sizeof (bfd_vma) / 8;
5792 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5793 if (ppc64_sec->u.toc.add == NULL)
5794 return FALSE;
5795 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5796 ppc64_sec->sec_type = sec_toc;
5797 }
5798 BFD_ASSERT (rel->r_offset % 8 == 0);
5799 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5800 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5801
5802 /* Mark the second slot of a GD or LD entry.
5803 -1 to indicate GD and -2 to indicate LD. */
5804 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5805 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5806 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5807 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5808 goto dodyn;
5809
5810 case R_PPC64_TPREL16:
5811 case R_PPC64_TPREL16_LO:
5812 case R_PPC64_TPREL16_HI:
5813 case R_PPC64_TPREL16_HA:
5814 case R_PPC64_TPREL16_DS:
5815 case R_PPC64_TPREL16_LO_DS:
5816 case R_PPC64_TPREL16_HIGH:
5817 case R_PPC64_TPREL16_HIGHA:
5818 case R_PPC64_TPREL16_HIGHER:
5819 case R_PPC64_TPREL16_HIGHERA:
5820 case R_PPC64_TPREL16_HIGHEST:
5821 case R_PPC64_TPREL16_HIGHESTA:
5822 if (bfd_link_pic (info))
5823 {
5824 info->flags |= DF_STATIC_TLS;
5825 goto dodyn;
5826 }
5827 break;
5828
5829 case R_PPC64_ADDR64:
5830 if (opd_sym_map != NULL
5831 && rel + 1 < rel_end
5832 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5833 {
5834 if (h != NULL)
5835 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5836 else
5837 {
5838 asection *s;
5839 Elf_Internal_Sym *isym;
5840
5841 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5842 abfd, r_symndx);
5843 if (isym == NULL)
5844 return FALSE;
5845
5846 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5847 if (s != NULL && s != sec)
5848 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5849 }
5850 }
5851 /* Fall through. */
5852
5853 case R_PPC64_ADDR16:
5854 case R_PPC64_ADDR16_DS:
5855 case R_PPC64_ADDR16_HA:
5856 case R_PPC64_ADDR16_HI:
5857 case R_PPC64_ADDR16_HIGH:
5858 case R_PPC64_ADDR16_HIGHA:
5859 case R_PPC64_ADDR16_HIGHER:
5860 case R_PPC64_ADDR16_HIGHERA:
5861 case R_PPC64_ADDR16_HIGHEST:
5862 case R_PPC64_ADDR16_HIGHESTA:
5863 case R_PPC64_ADDR16_LO:
5864 case R_PPC64_ADDR16_LO_DS:
5865 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5866 && rel->r_addend == 0)
5867 {
5868 /* We may need a .plt entry if this reloc refers to a
5869 function in a shared lib. */
5870 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5871 return FALSE;
5872 h->pointer_equality_needed = 1;
5873 }
5874 /* Fall through. */
5875
5876 case R_PPC64_REL30:
5877 case R_PPC64_REL32:
5878 case R_PPC64_REL64:
5879 case R_PPC64_ADDR32:
5880 case R_PPC64_UADDR16:
5881 case R_PPC64_UADDR32:
5882 case R_PPC64_UADDR64:
5883 case R_PPC64_TOC:
5884 if (h != NULL && !bfd_link_pic (info))
5885 /* We may need a copy reloc. */
5886 h->non_got_ref = 1;
5887
5888 /* Don't propagate .opd relocs. */
5889 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5890 break;
5891
5892 /* If we are creating a shared library, and this is a reloc
5893 against a global symbol, or a non PC relative reloc
5894 against a local symbol, then we need to copy the reloc
5895 into the shared library. However, if we are linking with
5896 -Bsymbolic, we do not need to copy a reloc against a
5897 global symbol which is defined in an object we are
5898 including in the link (i.e., DEF_REGULAR is set). At
5899 this point we have not seen all the input files, so it is
5900 possible that DEF_REGULAR is not set now but will be set
5901 later (it is never cleared). In case of a weak definition,
5902 DEF_REGULAR may be cleared later by a strong definition in
5903 a shared library. We account for that possibility below by
5904 storing information in the dyn_relocs field of the hash
5905 table entry. A similar situation occurs when creating
5906 shared libraries and symbol visibility changes render the
5907 symbol local.
5908
5909 If on the other hand, we are creating an executable, we
5910 may need to keep relocations for symbols satisfied by a
5911 dynamic library if we manage to avoid copy relocs for the
5912 symbol. */
5913 dodyn:
5914 if ((bfd_link_pic (info)
5915 && (must_be_dyn_reloc (info, r_type)
5916 || (h != NULL
5917 && (!SYMBOLIC_BIND (info, h)
5918 || h->root.type == bfd_link_hash_defweak
5919 || !h->def_regular))))
5920 || (ELIMINATE_COPY_RELOCS
5921 && !bfd_link_pic (info)
5922 && h != NULL
5923 && (h->root.type == bfd_link_hash_defweak
5924 || !h->def_regular))
5925 || (!bfd_link_pic (info)
5926 && ifunc != NULL))
5927 {
5928 /* We must copy these reloc types into the output file.
5929 Create a reloc section in dynobj and make room for
5930 this reloc. */
5931 if (sreloc == NULL)
5932 {
5933 sreloc = _bfd_elf_make_dynamic_reloc_section
5934 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5935
5936 if (sreloc == NULL)
5937 return FALSE;
5938 }
5939
5940 /* If this is a global symbol, we count the number of
5941 relocations we need for this symbol. */
5942 if (h != NULL)
5943 {
5944 struct elf_dyn_relocs *p;
5945 struct elf_dyn_relocs **head;
5946
5947 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5948 p = *head;
5949 if (p == NULL || p->sec != sec)
5950 {
5951 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5952 if (p == NULL)
5953 return FALSE;
5954 p->next = *head;
5955 *head = p;
5956 p->sec = sec;
5957 p->count = 0;
5958 p->pc_count = 0;
5959 }
5960 p->count += 1;
5961 if (!must_be_dyn_reloc (info, r_type))
5962 p->pc_count += 1;
5963 }
5964 else
5965 {
5966 /* Track dynamic relocs needed for local syms too.
5967 We really need local syms available to do this
5968 easily. Oh well. */
5969 struct ppc_dyn_relocs *p;
5970 struct ppc_dyn_relocs **head;
5971 bfd_boolean is_ifunc;
5972 asection *s;
5973 void *vpp;
5974 Elf_Internal_Sym *isym;
5975
5976 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5977 abfd, r_symndx);
5978 if (isym == NULL)
5979 return FALSE;
5980
5981 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5982 if (s == NULL)
5983 s = sec;
5984
5985 vpp = &elf_section_data (s)->local_dynrel;
5986 head = (struct ppc_dyn_relocs **) vpp;
5987 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5988 p = *head;
5989 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5990 p = p->next;
5991 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5992 {
5993 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5994 if (p == NULL)
5995 return FALSE;
5996 p->next = *head;
5997 *head = p;
5998 p->sec = sec;
5999 p->ifunc = is_ifunc;
6000 p->count = 0;
6001 }
6002 p->count += 1;
6003 }
6004 }
6005 break;
6006
6007 default:
6008 break;
6009 }
6010 }
6011
6012 return TRUE;
6013 }
6014
6015 /* Merge backend specific data from an object file to the output
6016 object file when linking. */
6017
6018 static bfd_boolean
6019 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6020 {
6021 bfd *obfd = info->output_bfd;
6022 unsigned long iflags, oflags;
6023
6024 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6025 return TRUE;
6026
6027 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6028 return TRUE;
6029
6030 if (!_bfd_generic_verify_endian_match (ibfd, info))
6031 return FALSE;
6032
6033 iflags = elf_elfheader (ibfd)->e_flags;
6034 oflags = elf_elfheader (obfd)->e_flags;
6035
6036 if (iflags & ~EF_PPC64_ABI)
6037 {
6038 _bfd_error_handler
6039 /* xgettext:c-format */
6040 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6041 bfd_set_error (bfd_error_bad_value);
6042 return FALSE;
6043 }
6044 else if (iflags != oflags && iflags != 0)
6045 {
6046 _bfd_error_handler
6047 /* xgettext:c-format */
6048 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6049 ibfd, iflags, oflags);
6050 bfd_set_error (bfd_error_bad_value);
6051 return FALSE;
6052 }
6053
6054 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6055
6056 /* Merge Tag_compatibility attributes and any common GNU ones. */
6057 _bfd_elf_merge_object_attributes (ibfd, info);
6058
6059 return TRUE;
6060 }
6061
6062 static bfd_boolean
6063 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6064 {
6065 /* Print normal ELF private data. */
6066 _bfd_elf_print_private_bfd_data (abfd, ptr);
6067
6068 if (elf_elfheader (abfd)->e_flags != 0)
6069 {
6070 FILE *file = ptr;
6071
6072 fprintf (file, _("private flags = 0x%lx:"),
6073 elf_elfheader (abfd)->e_flags);
6074
6075 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6076 fprintf (file, _(" [abiv%ld]"),
6077 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6078 fputc ('\n', file);
6079 }
6080
6081 return TRUE;
6082 }
6083
6084 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6085 of the code entry point, and its section, which must be in the same
6086 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6087
6088 static bfd_vma
6089 opd_entry_value (asection *opd_sec,
6090 bfd_vma offset,
6091 asection **code_sec,
6092 bfd_vma *code_off,
6093 bfd_boolean in_code_sec)
6094 {
6095 bfd *opd_bfd = opd_sec->owner;
6096 Elf_Internal_Rela *relocs;
6097 Elf_Internal_Rela *lo, *hi, *look;
6098 bfd_vma val;
6099
6100 /* No relocs implies we are linking a --just-symbols object, or looking
6101 at a final linked executable with addr2line or somesuch. */
6102 if (opd_sec->reloc_count == 0)
6103 {
6104 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6105
6106 if (contents == NULL)
6107 {
6108 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6109 return (bfd_vma) -1;
6110 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6111 }
6112
6113 /* PR 17512: file: 64b9dfbb. */
6114 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6115 return (bfd_vma) -1;
6116
6117 val = bfd_get_64 (opd_bfd, contents + offset);
6118 if (code_sec != NULL)
6119 {
6120 asection *sec, *likely = NULL;
6121
6122 if (in_code_sec)
6123 {
6124 sec = *code_sec;
6125 if (sec->vma <= val
6126 && val < sec->vma + sec->size)
6127 likely = sec;
6128 else
6129 val = -1;
6130 }
6131 else
6132 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6133 if (sec->vma <= val
6134 && (sec->flags & SEC_LOAD) != 0
6135 && (sec->flags & SEC_ALLOC) != 0)
6136 likely = sec;
6137 if (likely != NULL)
6138 {
6139 *code_sec = likely;
6140 if (code_off != NULL)
6141 *code_off = val - likely->vma;
6142 }
6143 }
6144 return val;
6145 }
6146
6147 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6148
6149 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6150 if (relocs == NULL)
6151 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6152 /* PR 17512: file: df8e1fd6. */
6153 if (relocs == NULL)
6154 return (bfd_vma) -1;
6155
6156 /* Go find the opd reloc at the sym address. */
6157 lo = relocs;
6158 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6159 val = (bfd_vma) -1;
6160 while (lo < hi)
6161 {
6162 look = lo + (hi - lo) / 2;
6163 if (look->r_offset < offset)
6164 lo = look + 1;
6165 else if (look->r_offset > offset)
6166 hi = look;
6167 else
6168 {
6169 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6170
6171 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6172 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6173 {
6174 unsigned long symndx = ELF64_R_SYM (look->r_info);
6175 asection *sec = NULL;
6176
6177 if (symndx >= symtab_hdr->sh_info
6178 && elf_sym_hashes (opd_bfd) != NULL)
6179 {
6180 struct elf_link_hash_entry **sym_hashes;
6181 struct elf_link_hash_entry *rh;
6182
6183 sym_hashes = elf_sym_hashes (opd_bfd);
6184 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6185 if (rh != NULL)
6186 {
6187 rh = elf_follow_link (rh);
6188 if (rh->root.type != bfd_link_hash_defined
6189 && rh->root.type != bfd_link_hash_defweak)
6190 break;
6191 if (rh->root.u.def.section->owner == opd_bfd)
6192 {
6193 val = rh->root.u.def.value;
6194 sec = rh->root.u.def.section;
6195 }
6196 }
6197 }
6198
6199 if (sec == NULL)
6200 {
6201 Elf_Internal_Sym *sym;
6202
6203 if (symndx < symtab_hdr->sh_info)
6204 {
6205 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6206 if (sym == NULL)
6207 {
6208 size_t symcnt = symtab_hdr->sh_info;
6209 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6210 symcnt, 0,
6211 NULL, NULL, NULL);
6212 if (sym == NULL)
6213 break;
6214 symtab_hdr->contents = (bfd_byte *) sym;
6215 }
6216 sym += symndx;
6217 }
6218 else
6219 {
6220 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6221 1, symndx,
6222 NULL, NULL, NULL);
6223 if (sym == NULL)
6224 break;
6225 }
6226 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6227 if (sec == NULL)
6228 break;
6229 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6230 val = sym->st_value;
6231 }
6232
6233 val += look->r_addend;
6234 if (code_off != NULL)
6235 *code_off = val;
6236 if (code_sec != NULL)
6237 {
6238 if (in_code_sec && *code_sec != sec)
6239 return -1;
6240 else
6241 *code_sec = sec;
6242 }
6243 if (sec->output_section != NULL)
6244 val += sec->output_section->vma + sec->output_offset;
6245 }
6246 break;
6247 }
6248 }
6249
6250 return val;
6251 }
6252
6253 /* If the ELF symbol SYM might be a function in SEC, return the
6254 function size and set *CODE_OFF to the function's entry point,
6255 otherwise return zero. */
6256
6257 static bfd_size_type
6258 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6259 bfd_vma *code_off)
6260 {
6261 bfd_size_type size;
6262
6263 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6264 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6265 return 0;
6266
6267 size = 0;
6268 if (!(sym->flags & BSF_SYNTHETIC))
6269 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6270
6271 if (strcmp (sym->section->name, ".opd") == 0)
6272 {
6273 struct _opd_sec_data *opd = get_opd_info (sym->section);
6274 bfd_vma symval = sym->value;
6275
6276 if (opd != NULL
6277 && opd->adjust != NULL
6278 && elf_section_data (sym->section)->relocs != NULL)
6279 {
6280 /* opd_entry_value will use cached relocs that have been
6281 adjusted, but with raw symbols. That means both local
6282 and global symbols need adjusting. */
6283 long adjust = opd->adjust[OPD_NDX (symval)];
6284 if (adjust == -1)
6285 return 0;
6286 symval += adjust;
6287 }
6288
6289 if (opd_entry_value (sym->section, symval,
6290 &sec, code_off, TRUE) == (bfd_vma) -1)
6291 return 0;
6292 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6293 symbol. This size has nothing to do with the code size of the
6294 function, which is what we're supposed to return, but the
6295 code size isn't available without looking up the dot-sym.
6296 However, doing that would be a waste of time particularly
6297 since elf_find_function will look at the dot-sym anyway.
6298 Now, elf_find_function will keep the largest size of any
6299 function sym found at the code address of interest, so return
6300 1 here to avoid it incorrectly caching a larger function size
6301 for a small function. This does mean we return the wrong
6302 size for a new-ABI function of size 24, but all that does is
6303 disable caching for such functions. */
6304 if (size == 24)
6305 size = 1;
6306 }
6307 else
6308 {
6309 if (sym->section != sec)
6310 return 0;
6311 *code_off = sym->value;
6312 }
6313 if (size == 0)
6314 size = 1;
6315 return size;
6316 }
6317
6318 /* Return true if symbol is defined in a regular object file. */
6319
6320 static bfd_boolean
6321 is_static_defined (struct elf_link_hash_entry *h)
6322 {
6323 return ((h->root.type == bfd_link_hash_defined
6324 || h->root.type == bfd_link_hash_defweak)
6325 && h->root.u.def.section != NULL
6326 && h->root.u.def.section->output_section != NULL);
6327 }
6328
6329 /* If FDH is a function descriptor symbol, return the associated code
6330 entry symbol if it is defined. Return NULL otherwise. */
6331
6332 static struct ppc_link_hash_entry *
6333 defined_code_entry (struct ppc_link_hash_entry *fdh)
6334 {
6335 if (fdh->is_func_descriptor)
6336 {
6337 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6338 if (fh->elf.root.type == bfd_link_hash_defined
6339 || fh->elf.root.type == bfd_link_hash_defweak)
6340 return fh;
6341 }
6342 return NULL;
6343 }
6344
6345 /* If FH is a function code entry symbol, return the associated
6346 function descriptor symbol if it is defined. Return NULL otherwise. */
6347
6348 static struct ppc_link_hash_entry *
6349 defined_func_desc (struct ppc_link_hash_entry *fh)
6350 {
6351 if (fh->oh != NULL
6352 && fh->oh->is_func_descriptor)
6353 {
6354 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6355 if (fdh->elf.root.type == bfd_link_hash_defined
6356 || fdh->elf.root.type == bfd_link_hash_defweak)
6357 return fdh;
6358 }
6359 return NULL;
6360 }
6361
6362 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6363
6364 /* Garbage collect sections, after first dealing with dot-symbols. */
6365
6366 static bfd_boolean
6367 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6368 {
6369 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6370
6371 if (htab != NULL && htab->need_func_desc_adj)
6372 {
6373 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6374 htab->need_func_desc_adj = 0;
6375 }
6376 return bfd_elf_gc_sections (abfd, info);
6377 }
6378
6379 /* Mark all our entry sym sections, both opd and code section. */
6380
6381 static void
6382 ppc64_elf_gc_keep (struct bfd_link_info *info)
6383 {
6384 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6385 struct bfd_sym_chain *sym;
6386
6387 if (htab == NULL)
6388 return;
6389
6390 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6391 {
6392 struct ppc_link_hash_entry *eh, *fh;
6393 asection *sec;
6394
6395 eh = (struct ppc_link_hash_entry *)
6396 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6397 if (eh == NULL)
6398 continue;
6399 if (eh->elf.root.type != bfd_link_hash_defined
6400 && eh->elf.root.type != bfd_link_hash_defweak)
6401 continue;
6402
6403 fh = defined_code_entry (eh);
6404 if (fh != NULL)
6405 {
6406 sec = fh->elf.root.u.def.section;
6407 sec->flags |= SEC_KEEP;
6408 }
6409 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6410 && opd_entry_value (eh->elf.root.u.def.section,
6411 eh->elf.root.u.def.value,
6412 &sec, NULL, FALSE) != (bfd_vma) -1)
6413 sec->flags |= SEC_KEEP;
6414
6415 sec = eh->elf.root.u.def.section;
6416 sec->flags |= SEC_KEEP;
6417 }
6418 }
6419
6420 /* Mark sections containing dynamically referenced symbols. When
6421 building shared libraries, we must assume that any visible symbol is
6422 referenced. */
6423
6424 static bfd_boolean
6425 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6426 {
6427 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6428 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6429 struct ppc_link_hash_entry *fdh;
6430 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6431
6432 /* Dynamic linking info is on the func descriptor sym. */
6433 fdh = defined_func_desc (eh);
6434 if (fdh != NULL)
6435 eh = fdh;
6436
6437 if ((eh->elf.root.type == bfd_link_hash_defined
6438 || eh->elf.root.type == bfd_link_hash_defweak)
6439 && (eh->elf.ref_dynamic
6440 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6441 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6442 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6443 && (!bfd_link_executable (info)
6444 || info->export_dynamic
6445 || (eh->elf.dynamic
6446 && d != NULL
6447 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6448 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6449 || !bfd_hide_sym_by_version (info->version_info,
6450 eh->elf.root.root.string)))))
6451 {
6452 asection *code_sec;
6453 struct ppc_link_hash_entry *fh;
6454
6455 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6456
6457 /* Function descriptor syms cause the associated
6458 function code sym section to be marked. */
6459 fh = defined_code_entry (eh);
6460 if (fh != NULL)
6461 {
6462 code_sec = fh->elf.root.u.def.section;
6463 code_sec->flags |= SEC_KEEP;
6464 }
6465 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6466 && opd_entry_value (eh->elf.root.u.def.section,
6467 eh->elf.root.u.def.value,
6468 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6469 code_sec->flags |= SEC_KEEP;
6470 }
6471
6472 return TRUE;
6473 }
6474
6475 /* Return the section that should be marked against GC for a given
6476 relocation. */
6477
6478 static asection *
6479 ppc64_elf_gc_mark_hook (asection *sec,
6480 struct bfd_link_info *info,
6481 Elf_Internal_Rela *rel,
6482 struct elf_link_hash_entry *h,
6483 Elf_Internal_Sym *sym)
6484 {
6485 asection *rsec;
6486
6487 /* Syms return NULL if we're marking .opd, so we avoid marking all
6488 function sections, as all functions are referenced in .opd. */
6489 rsec = NULL;
6490 if (get_opd_info (sec) != NULL)
6491 return rsec;
6492
6493 if (h != NULL)
6494 {
6495 enum elf_ppc64_reloc_type r_type;
6496 struct ppc_link_hash_entry *eh, *fh, *fdh;
6497
6498 r_type = ELF64_R_TYPE (rel->r_info);
6499 switch (r_type)
6500 {
6501 case R_PPC64_GNU_VTINHERIT:
6502 case R_PPC64_GNU_VTENTRY:
6503 break;
6504
6505 default:
6506 switch (h->root.type)
6507 {
6508 case bfd_link_hash_defined:
6509 case bfd_link_hash_defweak:
6510 eh = (struct ppc_link_hash_entry *) h;
6511 fdh = defined_func_desc (eh);
6512 if (fdh != NULL)
6513 {
6514 /* -mcall-aixdesc code references the dot-symbol on
6515 a call reloc. Mark the function descriptor too
6516 against garbage collection. */
6517 fdh->elf.mark = 1;
6518 if (fdh->elf.u.weakdef != NULL)
6519 fdh->elf.u.weakdef->mark = 1;
6520 eh = fdh;
6521 }
6522
6523 /* Function descriptor syms cause the associated
6524 function code sym section to be marked. */
6525 fh = defined_code_entry (eh);
6526 if (fh != NULL)
6527 {
6528 /* They also mark their opd section. */
6529 eh->elf.root.u.def.section->gc_mark = 1;
6530
6531 rsec = fh->elf.root.u.def.section;
6532 }
6533 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6534 && opd_entry_value (eh->elf.root.u.def.section,
6535 eh->elf.root.u.def.value,
6536 &rsec, NULL, FALSE) != (bfd_vma) -1)
6537 eh->elf.root.u.def.section->gc_mark = 1;
6538 else
6539 rsec = h->root.u.def.section;
6540 break;
6541
6542 case bfd_link_hash_common:
6543 rsec = h->root.u.c.p->section;
6544 break;
6545
6546 default:
6547 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6548 }
6549 }
6550 }
6551 else
6552 {
6553 struct _opd_sec_data *opd;
6554
6555 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6556 opd = get_opd_info (rsec);
6557 if (opd != NULL && opd->func_sec != NULL)
6558 {
6559 rsec->gc_mark = 1;
6560
6561 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6562 }
6563 }
6564
6565 return rsec;
6566 }
6567
6568 /* Update the .got, .plt. and dynamic reloc reference counts for the
6569 section being removed. */
6570
6571 static bfd_boolean
6572 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6573 asection *sec, const Elf_Internal_Rela *relocs)
6574 {
6575 struct ppc_link_hash_table *htab;
6576 Elf_Internal_Shdr *symtab_hdr;
6577 struct elf_link_hash_entry **sym_hashes;
6578 struct got_entry **local_got_ents;
6579 const Elf_Internal_Rela *rel, *relend;
6580
6581 if (bfd_link_relocatable (info))
6582 return TRUE;
6583
6584 if ((sec->flags & SEC_ALLOC) == 0)
6585 return TRUE;
6586
6587 elf_section_data (sec)->local_dynrel = NULL;
6588
6589 htab = ppc_hash_table (info);
6590 if (htab == NULL)
6591 return FALSE;
6592
6593 symtab_hdr = &elf_symtab_hdr (abfd);
6594 sym_hashes = elf_sym_hashes (abfd);
6595 local_got_ents = elf_local_got_ents (abfd);
6596
6597 relend = relocs + sec->reloc_count;
6598 for (rel = relocs; rel < relend; rel++)
6599 {
6600 unsigned long r_symndx;
6601 enum elf_ppc64_reloc_type r_type;
6602 struct elf_link_hash_entry *h = NULL;
6603 struct plt_entry **plt_list;
6604 unsigned char tls_type = 0;
6605
6606 r_symndx = ELF64_R_SYM (rel->r_info);
6607 r_type = ELF64_R_TYPE (rel->r_info);
6608 if (r_symndx >= symtab_hdr->sh_info)
6609 {
6610 struct ppc_link_hash_entry *eh;
6611 struct elf_dyn_relocs **pp;
6612 struct elf_dyn_relocs *p;
6613
6614 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6615 h = elf_follow_link (h);
6616 eh = (struct ppc_link_hash_entry *) h;
6617
6618 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6619 if (p->sec == sec)
6620 {
6621 /* Everything must go for SEC. */
6622 *pp = p->next;
6623 break;
6624 }
6625 }
6626
6627 switch (r_type)
6628 {
6629 case R_PPC64_GOT_TLSLD16:
6630 case R_PPC64_GOT_TLSLD16_LO:
6631 case R_PPC64_GOT_TLSLD16_HI:
6632 case R_PPC64_GOT_TLSLD16_HA:
6633 tls_type = TLS_TLS | TLS_LD;
6634 goto dogot;
6635
6636 case R_PPC64_GOT_TLSGD16:
6637 case R_PPC64_GOT_TLSGD16_LO:
6638 case R_PPC64_GOT_TLSGD16_HI:
6639 case R_PPC64_GOT_TLSGD16_HA:
6640 tls_type = TLS_TLS | TLS_GD;
6641 goto dogot;
6642
6643 case R_PPC64_GOT_TPREL16_DS:
6644 case R_PPC64_GOT_TPREL16_LO_DS:
6645 case R_PPC64_GOT_TPREL16_HI:
6646 case R_PPC64_GOT_TPREL16_HA:
6647 tls_type = TLS_TLS | TLS_TPREL;
6648 goto dogot;
6649
6650 case R_PPC64_GOT_DTPREL16_DS:
6651 case R_PPC64_GOT_DTPREL16_LO_DS:
6652 case R_PPC64_GOT_DTPREL16_HI:
6653 case R_PPC64_GOT_DTPREL16_HA:
6654 tls_type = TLS_TLS | TLS_DTPREL;
6655 goto dogot;
6656
6657 case R_PPC64_GOT16:
6658 case R_PPC64_GOT16_DS:
6659 case R_PPC64_GOT16_HA:
6660 case R_PPC64_GOT16_HI:
6661 case R_PPC64_GOT16_LO:
6662 case R_PPC64_GOT16_LO_DS:
6663 dogot:
6664 {
6665 struct got_entry *ent;
6666
6667 if (h != NULL)
6668 ent = h->got.glist;
6669 else
6670 ent = local_got_ents[r_symndx];
6671
6672 for (; ent != NULL; ent = ent->next)
6673 if (ent->addend == rel->r_addend
6674 && ent->owner == abfd
6675 && ent->tls_type == tls_type)
6676 break;
6677 if (ent == NULL)
6678 abort ();
6679 if (ent->got.refcount > 0)
6680 ent->got.refcount -= 1;
6681 }
6682 break;
6683
6684 case R_PPC64_PLT16_HA:
6685 case R_PPC64_PLT16_HI:
6686 case R_PPC64_PLT16_LO:
6687 case R_PPC64_PLT32:
6688 case R_PPC64_PLT64:
6689 case R_PPC64_REL14:
6690 case R_PPC64_REL14_BRNTAKEN:
6691 case R_PPC64_REL14_BRTAKEN:
6692 case R_PPC64_REL24:
6693 plt_list = NULL;
6694 if (h != NULL)
6695 plt_list = &h->plt.plist;
6696 else if (local_got_ents != NULL)
6697 {
6698 struct plt_entry **local_plt = (struct plt_entry **)
6699 (local_got_ents + symtab_hdr->sh_info);
6700 unsigned char *local_got_tls_masks = (unsigned char *)
6701 (local_plt + symtab_hdr->sh_info);
6702 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6703 plt_list = local_plt + r_symndx;
6704 }
6705 if (plt_list)
6706 {
6707 struct plt_entry *ent;
6708
6709 for (ent = *plt_list; ent != NULL; ent = ent->next)
6710 if (ent->addend == rel->r_addend)
6711 break;
6712 if (ent != NULL && ent->plt.refcount > 0)
6713 ent->plt.refcount -= 1;
6714 }
6715 break;
6716
6717 default:
6718 break;
6719 }
6720 }
6721 return TRUE;
6722 }
6723
6724 /* The maximum size of .sfpr. */
6725 #define SFPR_MAX (218*4)
6726
6727 struct sfpr_def_parms
6728 {
6729 const char name[12];
6730 unsigned char lo, hi;
6731 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6732 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6733 };
6734
6735 /* Auto-generate _save*, _rest* functions in .sfpr.
6736 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6737 instead. */
6738
6739 static bfd_boolean
6740 sfpr_define (struct bfd_link_info *info,
6741 const struct sfpr_def_parms *parm,
6742 asection *stub_sec)
6743 {
6744 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6745 unsigned int i;
6746 size_t len = strlen (parm->name);
6747 bfd_boolean writing = FALSE;
6748 char sym[16];
6749
6750 if (htab == NULL)
6751 return FALSE;
6752
6753 memcpy (sym, parm->name, len);
6754 sym[len + 2] = 0;
6755
6756 for (i = parm->lo; i <= parm->hi; i++)
6757 {
6758 struct ppc_link_hash_entry *h;
6759
6760 sym[len + 0] = i / 10 + '0';
6761 sym[len + 1] = i % 10 + '0';
6762 h = (struct ppc_link_hash_entry *)
6763 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6764 if (stub_sec != NULL)
6765 {
6766 if (h != NULL
6767 && h->elf.root.type == bfd_link_hash_defined
6768 && h->elf.root.u.def.section == htab->sfpr)
6769 {
6770 struct elf_link_hash_entry *s;
6771 char buf[32];
6772 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6773 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6774 if (s == NULL)
6775 return FALSE;
6776 if (s->root.type == bfd_link_hash_new
6777 || (s->root.type = bfd_link_hash_defined
6778 && s->root.u.def.section == stub_sec))
6779 {
6780 s->root.type = bfd_link_hash_defined;
6781 s->root.u.def.section = stub_sec;
6782 s->root.u.def.value = (stub_sec->size
6783 + h->elf.root.u.def.value);
6784 s->ref_regular = 1;
6785 s->def_regular = 1;
6786 s->ref_regular_nonweak = 1;
6787 s->forced_local = 1;
6788 s->non_elf = 0;
6789 s->root.linker_def = 1;
6790 }
6791 }
6792 continue;
6793 }
6794 if (h != NULL)
6795 {
6796 h->save_res = 1;
6797 if (!h->elf.def_regular)
6798 {
6799 h->elf.root.type = bfd_link_hash_defined;
6800 h->elf.root.u.def.section = htab->sfpr;
6801 h->elf.root.u.def.value = htab->sfpr->size;
6802 h->elf.type = STT_FUNC;
6803 h->elf.def_regular = 1;
6804 h->elf.non_elf = 0;
6805 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6806 writing = TRUE;
6807 if (htab->sfpr->contents == NULL)
6808 {
6809 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6810 if (htab->sfpr->contents == NULL)
6811 return FALSE;
6812 }
6813 }
6814 }
6815 if (writing)
6816 {
6817 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6818 if (i != parm->hi)
6819 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6820 else
6821 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6822 htab->sfpr->size = p - htab->sfpr->contents;
6823 }
6824 }
6825
6826 return TRUE;
6827 }
6828
6829 static bfd_byte *
6830 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6831 {
6832 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6833 return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6838 {
6839 p = savegpr0 (abfd, p, r);
6840 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6841 p = p + 4;
6842 bfd_put_32 (abfd, BLR, p);
6843 return p + 4;
6844 }
6845
6846 static bfd_byte *
6847 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6848 {
6849 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6850 return p + 4;
6851 }
6852
6853 static bfd_byte *
6854 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6855 {
6856 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6857 p = p + 4;
6858 p = restgpr0 (abfd, p, r);
6859 bfd_put_32 (abfd, MTLR_R0, p);
6860 p = p + 4;
6861 if (r == 29)
6862 {
6863 p = restgpr0 (abfd, p, 30);
6864 p = restgpr0 (abfd, p, 31);
6865 }
6866 bfd_put_32 (abfd, BLR, p);
6867 return p + 4;
6868 }
6869
6870 static bfd_byte *
6871 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6872 {
6873 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6874 return p + 4;
6875 }
6876
6877 static bfd_byte *
6878 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6879 {
6880 p = savegpr1 (abfd, p, r);
6881 bfd_put_32 (abfd, BLR, p);
6882 return p + 4;
6883 }
6884
6885 static bfd_byte *
6886 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6887 {
6888 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6889 return p + 4;
6890 }
6891
6892 static bfd_byte *
6893 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6894 {
6895 p = restgpr1 (abfd, p, r);
6896 bfd_put_32 (abfd, BLR, p);
6897 return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 savefpr (bfd *abfd, bfd_byte *p, int r)
6902 {
6903 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6904 return p + 4;
6905 }
6906
6907 static bfd_byte *
6908 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6909 {
6910 p = savefpr (abfd, p, r);
6911 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6912 p = p + 4;
6913 bfd_put_32 (abfd, BLR, p);
6914 return p + 4;
6915 }
6916
6917 static bfd_byte *
6918 restfpr (bfd *abfd, bfd_byte *p, int r)
6919 {
6920 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6921 return p + 4;
6922 }
6923
6924 static bfd_byte *
6925 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6926 {
6927 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6928 p = p + 4;
6929 p = restfpr (abfd, p, r);
6930 bfd_put_32 (abfd, MTLR_R0, p);
6931 p = p + 4;
6932 if (r == 29)
6933 {
6934 p = restfpr (abfd, p, 30);
6935 p = restfpr (abfd, p, 31);
6936 }
6937 bfd_put_32 (abfd, BLR, p);
6938 return p + 4;
6939 }
6940
6941 static bfd_byte *
6942 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6943 {
6944 p = savefpr (abfd, p, r);
6945 bfd_put_32 (abfd, BLR, p);
6946 return p + 4;
6947 }
6948
6949 static bfd_byte *
6950 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6951 {
6952 p = restfpr (abfd, p, r);
6953 bfd_put_32 (abfd, BLR, p);
6954 return p + 4;
6955 }
6956
6957 static bfd_byte *
6958 savevr (bfd *abfd, bfd_byte *p, int r)
6959 {
6960 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6961 p = p + 4;
6962 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6963 return p + 4;
6964 }
6965
6966 static bfd_byte *
6967 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6968 {
6969 p = savevr (abfd, p, r);
6970 bfd_put_32 (abfd, BLR, p);
6971 return p + 4;
6972 }
6973
6974 static bfd_byte *
6975 restvr (bfd *abfd, bfd_byte *p, int r)
6976 {
6977 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6978 p = p + 4;
6979 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6980 return p + 4;
6981 }
6982
6983 static bfd_byte *
6984 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6985 {
6986 p = restvr (abfd, p, r);
6987 bfd_put_32 (abfd, BLR, p);
6988 return p + 4;
6989 }
6990
6991 /* Called via elf_link_hash_traverse to transfer dynamic linking
6992 information on function code symbol entries to their corresponding
6993 function descriptor symbol entries. */
6994
6995 static bfd_boolean
6996 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6997 {
6998 struct bfd_link_info *info;
6999 struct ppc_link_hash_table *htab;
7000 struct ppc_link_hash_entry *fh;
7001 struct ppc_link_hash_entry *fdh;
7002 bfd_boolean force_local;
7003
7004 fh = (struct ppc_link_hash_entry *) h;
7005 if (fh->elf.root.type == bfd_link_hash_indirect)
7006 return TRUE;
7007
7008 if (!fh->is_func)
7009 return TRUE;
7010
7011 if (fh->elf.root.root.string[0] != '.'
7012 || fh->elf.root.root.string[1] == '\0')
7013 return TRUE;
7014
7015 info = inf;
7016 htab = ppc_hash_table (info);
7017 if (htab == NULL)
7018 return FALSE;
7019
7020 /* Find the corresponding function descriptor symbol. */
7021 fdh = lookup_fdh (fh, htab);
7022
7023 /* Resolve undefined references to dot-symbols as the value
7024 in the function descriptor, if we have one in a regular object.
7025 This is to satisfy cases like ".quad .foo". Calls to functions
7026 in dynamic objects are handled elsewhere. */
7027 if ((fh->elf.root.type == bfd_link_hash_undefined
7028 || fh->elf.root.type == bfd_link_hash_undefweak)
7029 && (fdh->elf.root.type == bfd_link_hash_defined
7030 || fdh->elf.root.type == bfd_link_hash_defweak)
7031 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7032 && opd_entry_value (fdh->elf.root.u.def.section,
7033 fdh->elf.root.u.def.value,
7034 &fh->elf.root.u.def.section,
7035 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7036 {
7037 fh->elf.root.type = fdh->elf.root.type;
7038 fh->elf.forced_local = 1;
7039 fh->elf.def_regular = fdh->elf.def_regular;
7040 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7041 }
7042
7043 if (!fh->elf.dynamic)
7044 {
7045 struct plt_entry *ent;
7046
7047 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7048 if (ent->plt.refcount > 0)
7049 break;
7050 if (ent == NULL)
7051 return TRUE;
7052 }
7053
7054 /* Create a descriptor as undefined if necessary. */
7055 if (fdh == NULL
7056 && !bfd_link_executable (info)
7057 && (fh->elf.root.type == bfd_link_hash_undefined
7058 || fh->elf.root.type == bfd_link_hash_undefweak))
7059 {
7060 fdh = make_fdh (info, fh);
7061 if (fdh == NULL)
7062 return FALSE;
7063 }
7064
7065 /* We can't support overriding of symbols on a fake descriptor. */
7066 if (fdh != NULL
7067 && fdh->fake
7068 && (fh->elf.root.type == bfd_link_hash_defined
7069 || fh->elf.root.type == bfd_link_hash_defweak))
7070 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7071
7072 /* Transfer dynamic linking information to the function descriptor. */
7073 if (fdh != NULL)
7074 {
7075 fdh->elf.ref_regular |= fh->elf.ref_regular;
7076 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7077 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7078 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7079 fdh->elf.dynamic |= fh->elf.dynamic;
7080 fdh->elf.needs_plt |= (fh->elf.needs_plt
7081 || fh->elf.type == STT_FUNC
7082 || fh->elf.type == STT_GNU_IFUNC);
7083 move_plt_plist (fh, fdh);
7084
7085 if (!fdh->elf.forced_local
7086 && fh->elf.dynindx != -1)
7087 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7088 return FALSE;
7089 }
7090
7091 /* Now that the info is on the function descriptor, clear the
7092 function code sym info. Any function code syms for which we
7093 don't have a definition in a regular file, we force local.
7094 This prevents a shared library from exporting syms that have
7095 been imported from another library. Function code syms that
7096 are really in the library we must leave global to prevent the
7097 linker dragging in a definition from a static library. */
7098 force_local = (!fh->elf.def_regular
7099 || fdh == NULL
7100 || !fdh->elf.def_regular
7101 || fdh->elf.forced_local);
7102 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7103
7104 return TRUE;
7105 }
7106
7107 static const struct sfpr_def_parms save_res_funcs[] =
7108 {
7109 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7110 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7111 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7112 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7113 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7114 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7115 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7116 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7117 { "._savef", 14, 31, savefpr, savefpr1_tail },
7118 { "._restf", 14, 31, restfpr, restfpr1_tail },
7119 { "_savevr_", 20, 31, savevr, savevr_tail },
7120 { "_restvr_", 20, 31, restvr, restvr_tail }
7121 };
7122
7123 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7124 this hook to a) provide some gcc support functions, and b) transfer
7125 dynamic linking information gathered so far on function code symbol
7126 entries, to their corresponding function descriptor symbol entries. */
7127
7128 static bfd_boolean
7129 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7130 struct bfd_link_info *info)
7131 {
7132 struct ppc_link_hash_table *htab;
7133
7134 htab = ppc_hash_table (info);
7135 if (htab == NULL)
7136 return FALSE;
7137
7138 /* Provide any missing _save* and _rest* functions. */
7139 if (htab->sfpr != NULL)
7140 {
7141 unsigned int i;
7142
7143 htab->sfpr->size = 0;
7144 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7145 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7146 return FALSE;
7147 if (htab->sfpr->size == 0)
7148 htab->sfpr->flags |= SEC_EXCLUDE;
7149 }
7150
7151 if (bfd_link_relocatable (info))
7152 return TRUE;
7153
7154 if (htab->elf.hgot != NULL)
7155 {
7156 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7157 /* Make .TOC. defined so as to prevent it being made dynamic.
7158 The wrong value here is fixed later in ppc64_elf_set_toc. */
7159 if (!htab->elf.hgot->def_regular
7160 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7161 {
7162 htab->elf.hgot->root.type = bfd_link_hash_defined;
7163 htab->elf.hgot->root.u.def.value = 0;
7164 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7165 htab->elf.hgot->def_regular = 1;
7166 htab->elf.hgot->root.linker_def = 1;
7167 }
7168 htab->elf.hgot->type = STT_OBJECT;
7169 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7170 | STV_HIDDEN);
7171 }
7172
7173 if (htab->need_func_desc_adj)
7174 {
7175 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7176 htab->need_func_desc_adj = 0;
7177 }
7178
7179 return TRUE;
7180 }
7181
7182 /* Return true if we have dynamic relocs against H that apply to
7183 read-only sections. */
7184
7185 static bfd_boolean
7186 readonly_dynrelocs (struct elf_link_hash_entry *h)
7187 {
7188 struct ppc_link_hash_entry *eh;
7189 struct elf_dyn_relocs *p;
7190
7191 eh = (struct ppc_link_hash_entry *) h;
7192 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7193 {
7194 asection *s = p->sec->output_section;
7195
7196 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7197 return TRUE;
7198 }
7199 return FALSE;
7200 }
7201
7202 /* Return true if we have dynamic relocs against H or any of its weak
7203 aliases, that apply to read-only sections. */
7204
7205 static bfd_boolean
7206 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7207 {
7208 struct ppc_link_hash_entry *eh;
7209
7210 eh = (struct ppc_link_hash_entry *) h;
7211 do
7212 {
7213 if (readonly_dynrelocs (&eh->elf))
7214 return TRUE;
7215 eh = eh->weakref;
7216 } while (eh != NULL && &eh->elf != h);
7217
7218 return FALSE;
7219 }
7220
7221 /* Return whether EH has pc-relative dynamic relocs. */
7222
7223 static bfd_boolean
7224 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7225 {
7226 struct elf_dyn_relocs *p;
7227
7228 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7229 if (p->pc_count != 0)
7230 return TRUE;
7231 return FALSE;
7232 }
7233
7234 /* Return true if a global entry stub will be created for H. Valid
7235 for ELFv2 before plt entries have been allocated. */
7236
7237 static bfd_boolean
7238 global_entry_stub (struct elf_link_hash_entry *h)
7239 {
7240 struct plt_entry *pent;
7241
7242 if (!h->pointer_equality_needed
7243 || h->def_regular)
7244 return FALSE;
7245
7246 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7247 if (pent->plt.refcount > 0
7248 && pent->addend == 0)
7249 return TRUE;
7250
7251 return FALSE;
7252 }
7253
7254 /* Adjust a symbol defined by a dynamic object and referenced by a
7255 regular object. The current definition is in some section of the
7256 dynamic object, but we're not including those sections. We have to
7257 change the definition to something the rest of the link can
7258 understand. */
7259
7260 static bfd_boolean
7261 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7262 struct elf_link_hash_entry *h)
7263 {
7264 struct ppc_link_hash_table *htab;
7265 asection *s;
7266
7267 htab = ppc_hash_table (info);
7268 if (htab == NULL)
7269 return FALSE;
7270
7271 /* Deal with function syms. */
7272 if (h->type == STT_FUNC
7273 || h->type == STT_GNU_IFUNC
7274 || h->needs_plt)
7275 {
7276 /* Clear procedure linkage table information for any symbol that
7277 won't need a .plt entry. */
7278 struct plt_entry *ent;
7279 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7280 if (ent->plt.refcount > 0)
7281 break;
7282 if (ent == NULL
7283 || (h->type != STT_GNU_IFUNC
7284 && (SYMBOL_CALLS_LOCAL (info, h)
7285 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7286 && h->root.type == bfd_link_hash_undefweak)))
7287 || ((struct ppc_link_hash_entry *) h)->save_res)
7288 {
7289 h->plt.plist = NULL;
7290 h->needs_plt = 0;
7291 h->pointer_equality_needed = 0;
7292 }
7293 else if (abiversion (info->output_bfd) >= 2)
7294 {
7295 /* Taking a function's address in a read/write section
7296 doesn't require us to define the function symbol in the
7297 executable on a global entry stub. A dynamic reloc can
7298 be used instead. The reason we prefer a few more dynamic
7299 relocs is that calling via a global entry stub costs a
7300 few more instructions, and pointer_equality_needed causes
7301 extra work in ld.so when resolving these symbols. */
7302 if (global_entry_stub (h)
7303 && !alias_readonly_dynrelocs (h))
7304 {
7305 h->pointer_equality_needed = 0;
7306 /* After adjust_dynamic_symbol, non_got_ref set in
7307 the non-pic case means that dyn_relocs for this
7308 symbol should be discarded. */
7309 h->non_got_ref = 0;
7310 }
7311
7312 /* If making a plt entry, then we don't need copy relocs. */
7313 return TRUE;
7314 }
7315 }
7316 else
7317 h->plt.plist = NULL;
7318
7319 /* If this is a weak symbol, and there is a real definition, the
7320 processor independent code will have arranged for us to see the
7321 real definition first, and we can just use the same value. */
7322 if (h->u.weakdef != NULL)
7323 {
7324 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7325 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7326 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7327 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7328 if (ELIMINATE_COPY_RELOCS)
7329 h->non_got_ref = h->u.weakdef->non_got_ref;
7330 return TRUE;
7331 }
7332
7333 /* If we are creating a shared library, we must presume that the
7334 only references to the symbol are via the global offset table.
7335 For such cases we need not do anything here; the relocations will
7336 be handled correctly by relocate_section. */
7337 if (bfd_link_pic (info))
7338 return TRUE;
7339
7340 /* If there are no references to this symbol that do not use the
7341 GOT, we don't need to generate a copy reloc. */
7342 if (!h->non_got_ref)
7343 return TRUE;
7344
7345 /* Don't generate a copy reloc for symbols defined in the executable. */
7346 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7347
7348 /* If -z nocopyreloc was given, don't generate them either. */
7349 || info->nocopyreloc
7350
7351 /* If we didn't find any dynamic relocs in read-only sections, then
7352 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7353 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7354
7355 /* Protected variables do not work with .dynbss. The copy in
7356 .dynbss won't be used by the shared library with the protected
7357 definition for the variable. Text relocations are preferable
7358 to an incorrect program. */
7359 || h->protected_def)
7360 {
7361 h->non_got_ref = 0;
7362 return TRUE;
7363 }
7364
7365 if (h->plt.plist != NULL)
7366 {
7367 /* We should never get here, but unfortunately there are versions
7368 of gcc out there that improperly (for this ABI) put initialized
7369 function pointers, vtable refs and suchlike in read-only
7370 sections. Allow them to proceed, but warn that this might
7371 break at runtime. */
7372 info->callbacks->einfo
7373 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7374 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7375 h->root.root.string);
7376 }
7377
7378 /* This is a reference to a symbol defined by a dynamic object which
7379 is not a function. */
7380
7381 /* We must allocate the symbol in our .dynbss section, which will
7382 become part of the .bss section of the executable. There will be
7383 an entry for this symbol in the .dynsym section. The dynamic
7384 object will contain position independent code, so all references
7385 from the dynamic object to this symbol will go through the global
7386 offset table. The dynamic linker will use the .dynsym entry to
7387 determine the address it must put in the global offset table, so
7388 both the dynamic object and the regular object will refer to the
7389 same memory location for the variable. */
7390
7391 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7392 to copy the initial value out of the dynamic object and into the
7393 runtime process image. We need to remember the offset into the
7394 .rela.bss section we are going to use. */
7395 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7396 {
7397 htab->relbss->size += sizeof (Elf64_External_Rela);
7398 h->needs_copy = 1;
7399 }
7400
7401 s = htab->dynbss;
7402
7403 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7404 }
7405
7406 /* If given a function descriptor symbol, hide both the function code
7407 sym and the descriptor. */
7408 static void
7409 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7410 struct elf_link_hash_entry *h,
7411 bfd_boolean force_local)
7412 {
7413 struct ppc_link_hash_entry *eh;
7414 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7415
7416 eh = (struct ppc_link_hash_entry *) h;
7417 if (eh->is_func_descriptor)
7418 {
7419 struct ppc_link_hash_entry *fh = eh->oh;
7420
7421 if (fh == NULL)
7422 {
7423 const char *p, *q;
7424 struct elf_link_hash_table *htab = elf_hash_table (info);
7425 char save;
7426
7427 /* We aren't supposed to use alloca in BFD because on
7428 systems which do not have alloca the version in libiberty
7429 calls xmalloc, which might cause the program to crash
7430 when it runs out of memory. This function doesn't have a
7431 return status, so there's no way to gracefully return an
7432 error. So cheat. We know that string[-1] can be safely
7433 accessed; It's either a string in an ELF string table,
7434 or allocated in an objalloc structure. */
7435
7436 p = eh->elf.root.root.string - 1;
7437 save = *p;
7438 *(char *) p = '.';
7439 fh = (struct ppc_link_hash_entry *)
7440 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7441 *(char *) p = save;
7442
7443 /* Unfortunately, if it so happens that the string we were
7444 looking for was allocated immediately before this string,
7445 then we overwrote the string terminator. That's the only
7446 reason the lookup should fail. */
7447 if (fh == NULL)
7448 {
7449 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7450 while (q >= eh->elf.root.root.string && *q == *p)
7451 --q, --p;
7452 if (q < eh->elf.root.root.string && *p == '.')
7453 fh = (struct ppc_link_hash_entry *)
7454 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7455 }
7456 if (fh != NULL)
7457 {
7458 eh->oh = fh;
7459 fh->oh = eh;
7460 }
7461 }
7462 if (fh != NULL)
7463 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7464 }
7465 }
7466
7467 static bfd_boolean
7468 get_sym_h (struct elf_link_hash_entry **hp,
7469 Elf_Internal_Sym **symp,
7470 asection **symsecp,
7471 unsigned char **tls_maskp,
7472 Elf_Internal_Sym **locsymsp,
7473 unsigned long r_symndx,
7474 bfd *ibfd)
7475 {
7476 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7477
7478 if (r_symndx >= symtab_hdr->sh_info)
7479 {
7480 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7481 struct elf_link_hash_entry *h;
7482
7483 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7484 h = elf_follow_link (h);
7485
7486 if (hp != NULL)
7487 *hp = h;
7488
7489 if (symp != NULL)
7490 *symp = NULL;
7491
7492 if (symsecp != NULL)
7493 {
7494 asection *symsec = NULL;
7495 if (h->root.type == bfd_link_hash_defined
7496 || h->root.type == bfd_link_hash_defweak)
7497 symsec = h->root.u.def.section;
7498 *symsecp = symsec;
7499 }
7500
7501 if (tls_maskp != NULL)
7502 {
7503 struct ppc_link_hash_entry *eh;
7504
7505 eh = (struct ppc_link_hash_entry *) h;
7506 *tls_maskp = &eh->tls_mask;
7507 }
7508 }
7509 else
7510 {
7511 Elf_Internal_Sym *sym;
7512 Elf_Internal_Sym *locsyms = *locsymsp;
7513
7514 if (locsyms == NULL)
7515 {
7516 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7517 if (locsyms == NULL)
7518 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7519 symtab_hdr->sh_info,
7520 0, NULL, NULL, NULL);
7521 if (locsyms == NULL)
7522 return FALSE;
7523 *locsymsp = locsyms;
7524 }
7525 sym = locsyms + r_symndx;
7526
7527 if (hp != NULL)
7528 *hp = NULL;
7529
7530 if (symp != NULL)
7531 *symp = sym;
7532
7533 if (symsecp != NULL)
7534 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7535
7536 if (tls_maskp != NULL)
7537 {
7538 struct got_entry **lgot_ents;
7539 unsigned char *tls_mask;
7540
7541 tls_mask = NULL;
7542 lgot_ents = elf_local_got_ents (ibfd);
7543 if (lgot_ents != NULL)
7544 {
7545 struct plt_entry **local_plt = (struct plt_entry **)
7546 (lgot_ents + symtab_hdr->sh_info);
7547 unsigned char *lgot_masks = (unsigned char *)
7548 (local_plt + symtab_hdr->sh_info);
7549 tls_mask = &lgot_masks[r_symndx];
7550 }
7551 *tls_maskp = tls_mask;
7552 }
7553 }
7554 return TRUE;
7555 }
7556
7557 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7558 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7559 type suitable for optimization, and 1 otherwise. */
7560
7561 static int
7562 get_tls_mask (unsigned char **tls_maskp,
7563 unsigned long *toc_symndx,
7564 bfd_vma *toc_addend,
7565 Elf_Internal_Sym **locsymsp,
7566 const Elf_Internal_Rela *rel,
7567 bfd *ibfd)
7568 {
7569 unsigned long r_symndx;
7570 int next_r;
7571 struct elf_link_hash_entry *h;
7572 Elf_Internal_Sym *sym;
7573 asection *sec;
7574 bfd_vma off;
7575
7576 r_symndx = ELF64_R_SYM (rel->r_info);
7577 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7578 return 0;
7579
7580 if ((*tls_maskp != NULL && **tls_maskp != 0)
7581 || sec == NULL
7582 || ppc64_elf_section_data (sec) == NULL
7583 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7584 return 1;
7585
7586 /* Look inside a TOC section too. */
7587 if (h != NULL)
7588 {
7589 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7590 off = h->root.u.def.value;
7591 }
7592 else
7593 off = sym->st_value;
7594 off += rel->r_addend;
7595 BFD_ASSERT (off % 8 == 0);
7596 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7597 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7598 if (toc_symndx != NULL)
7599 *toc_symndx = r_symndx;
7600 if (toc_addend != NULL)
7601 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7602 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7603 return 0;
7604 if ((h == NULL || is_static_defined (h))
7605 && (next_r == -1 || next_r == -2))
7606 return 1 - next_r;
7607 return 1;
7608 }
7609
7610 /* Find (or create) an entry in the tocsave hash table. */
7611
7612 static struct tocsave_entry *
7613 tocsave_find (struct ppc_link_hash_table *htab,
7614 enum insert_option insert,
7615 Elf_Internal_Sym **local_syms,
7616 const Elf_Internal_Rela *irela,
7617 bfd *ibfd)
7618 {
7619 unsigned long r_indx;
7620 struct elf_link_hash_entry *h;
7621 Elf_Internal_Sym *sym;
7622 struct tocsave_entry ent, *p;
7623 hashval_t hash;
7624 struct tocsave_entry **slot;
7625
7626 r_indx = ELF64_R_SYM (irela->r_info);
7627 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7628 return NULL;
7629 if (ent.sec == NULL || ent.sec->output_section == NULL)
7630 {
7631 _bfd_error_handler
7632 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7633 return NULL;
7634 }
7635
7636 if (h != NULL)
7637 ent.offset = h->root.u.def.value;
7638 else
7639 ent.offset = sym->st_value;
7640 ent.offset += irela->r_addend;
7641
7642 hash = tocsave_htab_hash (&ent);
7643 slot = ((struct tocsave_entry **)
7644 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7645 if (slot == NULL)
7646 return NULL;
7647
7648 if (*slot == NULL)
7649 {
7650 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7651 if (p == NULL)
7652 return NULL;
7653 *p = ent;
7654 *slot = p;
7655 }
7656 return *slot;
7657 }
7658
7659 /* Adjust all global syms defined in opd sections. In gcc generated
7660 code for the old ABI, these will already have been done. */
7661
7662 static bfd_boolean
7663 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7664 {
7665 struct ppc_link_hash_entry *eh;
7666 asection *sym_sec;
7667 struct _opd_sec_data *opd;
7668
7669 if (h->root.type == bfd_link_hash_indirect)
7670 return TRUE;
7671
7672 if (h->root.type != bfd_link_hash_defined
7673 && h->root.type != bfd_link_hash_defweak)
7674 return TRUE;
7675
7676 eh = (struct ppc_link_hash_entry *) h;
7677 if (eh->adjust_done)
7678 return TRUE;
7679
7680 sym_sec = eh->elf.root.u.def.section;
7681 opd = get_opd_info (sym_sec);
7682 if (opd != NULL && opd->adjust != NULL)
7683 {
7684 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7685 if (adjust == -1)
7686 {
7687 /* This entry has been deleted. */
7688 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7689 if (dsec == NULL)
7690 {
7691 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7692 if (discarded_section (dsec))
7693 {
7694 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7695 break;
7696 }
7697 }
7698 eh->elf.root.u.def.value = 0;
7699 eh->elf.root.u.def.section = dsec;
7700 }
7701 else
7702 eh->elf.root.u.def.value += adjust;
7703 eh->adjust_done = 1;
7704 }
7705 return TRUE;
7706 }
7707
7708 /* Handles decrementing dynamic reloc counts for the reloc specified by
7709 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7710 have already been determined. */
7711
7712 static bfd_boolean
7713 dec_dynrel_count (bfd_vma r_info,
7714 asection *sec,
7715 struct bfd_link_info *info,
7716 Elf_Internal_Sym **local_syms,
7717 struct elf_link_hash_entry *h,
7718 Elf_Internal_Sym *sym)
7719 {
7720 enum elf_ppc64_reloc_type r_type;
7721 asection *sym_sec = NULL;
7722
7723 /* Can this reloc be dynamic? This switch, and later tests here
7724 should be kept in sync with the code in check_relocs. */
7725 r_type = ELF64_R_TYPE (r_info);
7726 switch (r_type)
7727 {
7728 default:
7729 return TRUE;
7730
7731 case R_PPC64_TPREL16:
7732 case R_PPC64_TPREL16_LO:
7733 case R_PPC64_TPREL16_HI:
7734 case R_PPC64_TPREL16_HA:
7735 case R_PPC64_TPREL16_DS:
7736 case R_PPC64_TPREL16_LO_DS:
7737 case R_PPC64_TPREL16_HIGH:
7738 case R_PPC64_TPREL16_HIGHA:
7739 case R_PPC64_TPREL16_HIGHER:
7740 case R_PPC64_TPREL16_HIGHERA:
7741 case R_PPC64_TPREL16_HIGHEST:
7742 case R_PPC64_TPREL16_HIGHESTA:
7743 if (!bfd_link_pic (info))
7744 return TRUE;
7745
7746 case R_PPC64_TPREL64:
7747 case R_PPC64_DTPMOD64:
7748 case R_PPC64_DTPREL64:
7749 case R_PPC64_ADDR64:
7750 case R_PPC64_REL30:
7751 case R_PPC64_REL32:
7752 case R_PPC64_REL64:
7753 case R_PPC64_ADDR14:
7754 case R_PPC64_ADDR14_BRNTAKEN:
7755 case R_PPC64_ADDR14_BRTAKEN:
7756 case R_PPC64_ADDR16:
7757 case R_PPC64_ADDR16_DS:
7758 case R_PPC64_ADDR16_HA:
7759 case R_PPC64_ADDR16_HI:
7760 case R_PPC64_ADDR16_HIGH:
7761 case R_PPC64_ADDR16_HIGHA:
7762 case R_PPC64_ADDR16_HIGHER:
7763 case R_PPC64_ADDR16_HIGHERA:
7764 case R_PPC64_ADDR16_HIGHEST:
7765 case R_PPC64_ADDR16_HIGHESTA:
7766 case R_PPC64_ADDR16_LO:
7767 case R_PPC64_ADDR16_LO_DS:
7768 case R_PPC64_ADDR24:
7769 case R_PPC64_ADDR32:
7770 case R_PPC64_UADDR16:
7771 case R_PPC64_UADDR32:
7772 case R_PPC64_UADDR64:
7773 case R_PPC64_TOC:
7774 break;
7775 }
7776
7777 if (local_syms != NULL)
7778 {
7779 unsigned long r_symndx;
7780 bfd *ibfd = sec->owner;
7781
7782 r_symndx = ELF64_R_SYM (r_info);
7783 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7784 return FALSE;
7785 }
7786
7787 if ((bfd_link_pic (info)
7788 && (must_be_dyn_reloc (info, r_type)
7789 || (h != NULL
7790 && (!SYMBOLIC_BIND (info, h)
7791 || h->root.type == bfd_link_hash_defweak
7792 || !h->def_regular))))
7793 || (ELIMINATE_COPY_RELOCS
7794 && !bfd_link_pic (info)
7795 && h != NULL
7796 && (h->root.type == bfd_link_hash_defweak
7797 || !h->def_regular)))
7798 ;
7799 else
7800 return TRUE;
7801
7802 if (h != NULL)
7803 {
7804 struct elf_dyn_relocs *p;
7805 struct elf_dyn_relocs **pp;
7806 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7807
7808 /* elf_gc_sweep may have already removed all dyn relocs associated
7809 with local syms for a given section. Also, symbol flags are
7810 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7811 report a dynreloc miscount. */
7812 if (*pp == NULL && info->gc_sections)
7813 return TRUE;
7814
7815 while ((p = *pp) != NULL)
7816 {
7817 if (p->sec == sec)
7818 {
7819 if (!must_be_dyn_reloc (info, r_type))
7820 p->pc_count -= 1;
7821 p->count -= 1;
7822 if (p->count == 0)
7823 *pp = p->next;
7824 return TRUE;
7825 }
7826 pp = &p->next;
7827 }
7828 }
7829 else
7830 {
7831 struct ppc_dyn_relocs *p;
7832 struct ppc_dyn_relocs **pp;
7833 void *vpp;
7834 bfd_boolean is_ifunc;
7835
7836 if (local_syms == NULL)
7837 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7838 if (sym_sec == NULL)
7839 sym_sec = sec;
7840
7841 vpp = &elf_section_data (sym_sec)->local_dynrel;
7842 pp = (struct ppc_dyn_relocs **) vpp;
7843
7844 if (*pp == NULL && info->gc_sections)
7845 return TRUE;
7846
7847 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7848 while ((p = *pp) != NULL)
7849 {
7850 if (p->sec == sec && p->ifunc == is_ifunc)
7851 {
7852 p->count -= 1;
7853 if (p->count == 0)
7854 *pp = p->next;
7855 return TRUE;
7856 }
7857 pp = &p->next;
7858 }
7859 }
7860
7861 /* xgettext:c-format */
7862 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7863 sec->owner, sec);
7864 bfd_set_error (bfd_error_bad_value);
7865 return FALSE;
7866 }
7867
7868 /* Remove unused Official Procedure Descriptor entries. Currently we
7869 only remove those associated with functions in discarded link-once
7870 sections, or weakly defined functions that have been overridden. It
7871 would be possible to remove many more entries for statically linked
7872 applications. */
7873
7874 bfd_boolean
7875 ppc64_elf_edit_opd (struct bfd_link_info *info)
7876 {
7877 bfd *ibfd;
7878 bfd_boolean some_edited = FALSE;
7879 asection *need_pad = NULL;
7880 struct ppc_link_hash_table *htab;
7881
7882 htab = ppc_hash_table (info);
7883 if (htab == NULL)
7884 return FALSE;
7885
7886 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7887 {
7888 asection *sec;
7889 Elf_Internal_Rela *relstart, *rel, *relend;
7890 Elf_Internal_Shdr *symtab_hdr;
7891 Elf_Internal_Sym *local_syms;
7892 struct _opd_sec_data *opd;
7893 bfd_boolean need_edit, add_aux_fields, broken;
7894 bfd_size_type cnt_16b = 0;
7895
7896 if (!is_ppc64_elf (ibfd))
7897 continue;
7898
7899 sec = bfd_get_section_by_name (ibfd, ".opd");
7900 if (sec == NULL || sec->size == 0)
7901 continue;
7902
7903 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7904 continue;
7905
7906 if (sec->output_section == bfd_abs_section_ptr)
7907 continue;
7908
7909 /* Look through the section relocs. */
7910 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7911 continue;
7912
7913 local_syms = NULL;
7914 symtab_hdr = &elf_symtab_hdr (ibfd);
7915
7916 /* Read the relocations. */
7917 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7918 info->keep_memory);
7919 if (relstart == NULL)
7920 return FALSE;
7921
7922 /* First run through the relocs to check they are sane, and to
7923 determine whether we need to edit this opd section. */
7924 need_edit = FALSE;
7925 broken = FALSE;
7926 need_pad = sec;
7927 relend = relstart + sec->reloc_count;
7928 for (rel = relstart; rel < relend; )
7929 {
7930 enum elf_ppc64_reloc_type r_type;
7931 unsigned long r_symndx;
7932 asection *sym_sec;
7933 struct elf_link_hash_entry *h;
7934 Elf_Internal_Sym *sym;
7935 bfd_vma offset;
7936
7937 /* .opd contains an array of 16 or 24 byte entries. We're
7938 only interested in the reloc pointing to a function entry
7939 point. */
7940 offset = rel->r_offset;
7941 if (rel + 1 == relend
7942 || rel[1].r_offset != offset + 8)
7943 {
7944 /* If someone messes with .opd alignment then after a
7945 "ld -r" we might have padding in the middle of .opd.
7946 Also, there's nothing to prevent someone putting
7947 something silly in .opd with the assembler. No .opd
7948 optimization for them! */
7949 broken_opd:
7950 _bfd_error_handler
7951 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7952 broken = TRUE;
7953 break;
7954 }
7955
7956 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7957 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7958 {
7959 _bfd_error_handler
7960 /* xgettext:c-format */
7961 (_("%B: unexpected reloc type %u in .opd section"),
7962 ibfd, r_type);
7963 broken = TRUE;
7964 break;
7965 }
7966
7967 r_symndx = ELF64_R_SYM (rel->r_info);
7968 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7969 r_symndx, ibfd))
7970 goto error_ret;
7971
7972 if (sym_sec == NULL || sym_sec->owner == NULL)
7973 {
7974 const char *sym_name;
7975 if (h != NULL)
7976 sym_name = h->root.root.string;
7977 else
7978 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7979 sym_sec);
7980
7981 _bfd_error_handler
7982 /* xgettext:c-format */
7983 (_("%B: undefined sym `%s' in .opd section"),
7984 ibfd, sym_name);
7985 broken = TRUE;
7986 break;
7987 }
7988
7989 /* opd entries are always for functions defined in the
7990 current input bfd. If the symbol isn't defined in the
7991 input bfd, then we won't be using the function in this
7992 bfd; It must be defined in a linkonce section in another
7993 bfd, or is weak. It's also possible that we are
7994 discarding the function due to a linker script /DISCARD/,
7995 which we test for via the output_section. */
7996 if (sym_sec->owner != ibfd
7997 || sym_sec->output_section == bfd_abs_section_ptr)
7998 need_edit = TRUE;
7999
8000 rel += 2;
8001 if (rel + 1 == relend
8002 || (rel + 2 < relend
8003 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8004 ++rel;
8005
8006 if (rel == relend)
8007 {
8008 if (sec->size == offset + 24)
8009 {
8010 need_pad = NULL;
8011 break;
8012 }
8013 if (sec->size == offset + 16)
8014 {
8015 cnt_16b++;
8016 break;
8017 }
8018 goto broken_opd;
8019 }
8020 else if (rel + 1 < relend
8021 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8022 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8023 {
8024 if (rel[0].r_offset == offset + 16)
8025 cnt_16b++;
8026 else if (rel[0].r_offset != offset + 24)
8027 goto broken_opd;
8028 }
8029 else
8030 goto broken_opd;
8031 }
8032
8033 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8034
8035 if (!broken && (need_edit || add_aux_fields))
8036 {
8037 Elf_Internal_Rela *write_rel;
8038 Elf_Internal_Shdr *rel_hdr;
8039 bfd_byte *rptr, *wptr;
8040 bfd_byte *new_contents;
8041 bfd_size_type amt;
8042
8043 new_contents = NULL;
8044 amt = OPD_NDX (sec->size) * sizeof (long);
8045 opd = &ppc64_elf_section_data (sec)->u.opd;
8046 opd->adjust = bfd_zalloc (sec->owner, amt);
8047 if (opd->adjust == NULL)
8048 return FALSE;
8049 ppc64_elf_section_data (sec)->sec_type = sec_opd;
8050
8051 /* This seems a waste of time as input .opd sections are all
8052 zeros as generated by gcc, but I suppose there's no reason
8053 this will always be so. We might start putting something in
8054 the third word of .opd entries. */
8055 if ((sec->flags & SEC_IN_MEMORY) == 0)
8056 {
8057 bfd_byte *loc;
8058 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8059 {
8060 if (loc != NULL)
8061 free (loc);
8062 error_ret:
8063 if (local_syms != NULL
8064 && symtab_hdr->contents != (unsigned char *) local_syms)
8065 free (local_syms);
8066 if (elf_section_data (sec)->relocs != relstart)
8067 free (relstart);
8068 return FALSE;
8069 }
8070 sec->contents = loc;
8071 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8072 }
8073
8074 elf_section_data (sec)->relocs = relstart;
8075
8076 new_contents = sec->contents;
8077 if (add_aux_fields)
8078 {
8079 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8080 if (new_contents == NULL)
8081 return FALSE;
8082 need_pad = NULL;
8083 }
8084 wptr = new_contents;
8085 rptr = sec->contents;
8086 write_rel = relstart;
8087 for (rel = relstart; rel < relend; )
8088 {
8089 unsigned long r_symndx;
8090 asection *sym_sec;
8091 struct elf_link_hash_entry *h;
8092 struct ppc_link_hash_entry *fdh = NULL;
8093 Elf_Internal_Sym *sym;
8094 long opd_ent_size;
8095 Elf_Internal_Rela *next_rel;
8096 bfd_boolean skip;
8097
8098 r_symndx = ELF64_R_SYM (rel->r_info);
8099 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8100 r_symndx, ibfd))
8101 goto error_ret;
8102
8103 next_rel = rel + 2;
8104 if (next_rel + 1 == relend
8105 || (next_rel + 2 < relend
8106 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8107 ++next_rel;
8108
8109 /* See if the .opd entry is full 24 byte or
8110 16 byte (with fd_aux entry overlapped with next
8111 fd_func). */
8112 opd_ent_size = 24;
8113 if (next_rel == relend)
8114 {
8115 if (sec->size == rel->r_offset + 16)
8116 opd_ent_size = 16;
8117 }
8118 else if (next_rel->r_offset == rel->r_offset + 16)
8119 opd_ent_size = 16;
8120
8121 if (h != NULL
8122 && h->root.root.string[0] == '.')
8123 {
8124 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8125 if (fdh != NULL)
8126 {
8127 fdh = ppc_follow_link (fdh);
8128 if (fdh->elf.root.type != bfd_link_hash_defined
8129 && fdh->elf.root.type != bfd_link_hash_defweak)
8130 fdh = NULL;
8131 }
8132 }
8133
8134 skip = (sym_sec->owner != ibfd
8135 || sym_sec->output_section == bfd_abs_section_ptr);
8136 if (skip)
8137 {
8138 if (fdh != NULL && sym_sec->owner == ibfd)
8139 {
8140 /* Arrange for the function descriptor sym
8141 to be dropped. */
8142 fdh->elf.root.u.def.value = 0;
8143 fdh->elf.root.u.def.section = sym_sec;
8144 }
8145 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8146
8147 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8148 rel = next_rel;
8149 else
8150 while (1)
8151 {
8152 if (!dec_dynrel_count (rel->r_info, sec, info,
8153 NULL, h, sym))
8154 goto error_ret;
8155
8156 if (++rel == next_rel)
8157 break;
8158
8159 r_symndx = ELF64_R_SYM (rel->r_info);
8160 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8161 r_symndx, ibfd))
8162 goto error_ret;
8163 }
8164 }
8165 else
8166 {
8167 /* We'll be keeping this opd entry. */
8168 long adjust;
8169
8170 if (fdh != NULL)
8171 {
8172 /* Redefine the function descriptor symbol to
8173 this location in the opd section. It is
8174 necessary to update the value here rather
8175 than using an array of adjustments as we do
8176 for local symbols, because various places
8177 in the generic ELF code use the value
8178 stored in u.def.value. */
8179 fdh->elf.root.u.def.value = wptr - new_contents;
8180 fdh->adjust_done = 1;
8181 }
8182
8183 /* Local syms are a bit tricky. We could
8184 tweak them as they can be cached, but
8185 we'd need to look through the local syms
8186 for the function descriptor sym which we
8187 don't have at the moment. So keep an
8188 array of adjustments. */
8189 adjust = (wptr - new_contents) - (rptr - sec->contents);
8190 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8191
8192 if (wptr != rptr)
8193 memcpy (wptr, rptr, opd_ent_size);
8194 wptr += opd_ent_size;
8195 if (add_aux_fields && opd_ent_size == 16)
8196 {
8197 memset (wptr, '\0', 8);
8198 wptr += 8;
8199 }
8200
8201 /* We need to adjust any reloc offsets to point to the
8202 new opd entries. */
8203 for ( ; rel != next_rel; ++rel)
8204 {
8205 rel->r_offset += adjust;
8206 if (write_rel != rel)
8207 memcpy (write_rel, rel, sizeof (*rel));
8208 ++write_rel;
8209 }
8210 }
8211
8212 rptr += opd_ent_size;
8213 }
8214
8215 sec->size = wptr - new_contents;
8216 sec->reloc_count = write_rel - relstart;
8217 if (add_aux_fields)
8218 {
8219 free (sec->contents);
8220 sec->contents = new_contents;
8221 }
8222
8223 /* Fudge the header size too, as this is used later in
8224 elf_bfd_final_link if we are emitting relocs. */
8225 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8226 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8227 some_edited = TRUE;
8228 }
8229 else if (elf_section_data (sec)->relocs != relstart)
8230 free (relstart);
8231
8232 if (local_syms != NULL
8233 && symtab_hdr->contents != (unsigned char *) local_syms)
8234 {
8235 if (!info->keep_memory)
8236 free (local_syms);
8237 else
8238 symtab_hdr->contents = (unsigned char *) local_syms;
8239 }
8240 }
8241
8242 if (some_edited)
8243 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8244
8245 /* If we are doing a final link and the last .opd entry is just 16 byte
8246 long, add a 8 byte padding after it. */
8247 if (need_pad != NULL && !bfd_link_relocatable (info))
8248 {
8249 bfd_byte *p;
8250
8251 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8252 {
8253 BFD_ASSERT (need_pad->size > 0);
8254
8255 p = bfd_malloc (need_pad->size + 8);
8256 if (p == NULL)
8257 return FALSE;
8258
8259 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8260 p, 0, need_pad->size))
8261 return FALSE;
8262
8263 need_pad->contents = p;
8264 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8265 }
8266 else
8267 {
8268 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8269 if (p == NULL)
8270 return FALSE;
8271
8272 need_pad->contents = p;
8273 }
8274
8275 memset (need_pad->contents + need_pad->size, 0, 8);
8276 need_pad->size += 8;
8277 }
8278
8279 return TRUE;
8280 }
8281
8282 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8283
8284 asection *
8285 ppc64_elf_tls_setup (struct bfd_link_info *info)
8286 {
8287 struct ppc_link_hash_table *htab;
8288
8289 htab = ppc_hash_table (info);
8290 if (htab == NULL)
8291 return NULL;
8292
8293 if (abiversion (info->output_bfd) == 1)
8294 htab->opd_abi = 1;
8295
8296 if (htab->params->no_multi_toc)
8297 htab->do_multi_toc = 0;
8298 else if (!htab->do_multi_toc)
8299 htab->params->no_multi_toc = 1;
8300
8301 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8302 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8303 FALSE, FALSE, TRUE));
8304 /* Move dynamic linking info to the function descriptor sym. */
8305 if (htab->tls_get_addr != NULL)
8306 func_desc_adjust (&htab->tls_get_addr->elf, info);
8307 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8308 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8309 FALSE, FALSE, TRUE));
8310 if (htab->params->tls_get_addr_opt)
8311 {
8312 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8313
8314 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8315 FALSE, FALSE, TRUE);
8316 if (opt != NULL)
8317 func_desc_adjust (opt, info);
8318 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8319 FALSE, FALSE, TRUE);
8320 if (opt_fd != NULL
8321 && (opt_fd->root.type == bfd_link_hash_defined
8322 || opt_fd->root.type == bfd_link_hash_defweak))
8323 {
8324 /* If glibc supports an optimized __tls_get_addr call stub,
8325 signalled by the presence of __tls_get_addr_opt, and we'll
8326 be calling __tls_get_addr via a plt call stub, then
8327 make __tls_get_addr point to __tls_get_addr_opt. */
8328 tga_fd = &htab->tls_get_addr_fd->elf;
8329 if (htab->elf.dynamic_sections_created
8330 && tga_fd != NULL
8331 && (tga_fd->type == STT_FUNC
8332 || tga_fd->needs_plt)
8333 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8334 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8335 && tga_fd->root.type == bfd_link_hash_undefweak)))
8336 {
8337 struct plt_entry *ent;
8338
8339 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8340 if (ent->plt.refcount > 0)
8341 break;
8342 if (ent != NULL)
8343 {
8344 tga_fd->root.type = bfd_link_hash_indirect;
8345 tga_fd->root.u.i.link = &opt_fd->root;
8346 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8347 opt_fd->forced_local = 0;
8348 if (opt_fd->dynindx != -1)
8349 {
8350 /* Use __tls_get_addr_opt in dynamic relocations. */
8351 opt_fd->dynindx = -1;
8352 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8353 opt_fd->dynstr_index);
8354 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8355 return NULL;
8356 }
8357 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8358 tga = &htab->tls_get_addr->elf;
8359 if (opt != NULL && tga != NULL)
8360 {
8361 tga->root.type = bfd_link_hash_indirect;
8362 tga->root.u.i.link = &opt->root;
8363 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8364 opt->forced_local = 0;
8365 _bfd_elf_link_hash_hide_symbol (info, opt,
8366 tga->forced_local);
8367 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8368 }
8369 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8370 htab->tls_get_addr_fd->is_func_descriptor = 1;
8371 if (htab->tls_get_addr != NULL)
8372 {
8373 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8374 htab->tls_get_addr->is_func = 1;
8375 }
8376 }
8377 }
8378 }
8379 else if (htab->params->tls_get_addr_opt < 0)
8380 htab->params->tls_get_addr_opt = 0;
8381 }
8382 return _bfd_elf_tls_setup (info->output_bfd, info);
8383 }
8384
8385 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8386 HASH1 or HASH2. */
8387
8388 static bfd_boolean
8389 branch_reloc_hash_match (const bfd *ibfd,
8390 const Elf_Internal_Rela *rel,
8391 const struct ppc_link_hash_entry *hash1,
8392 const struct ppc_link_hash_entry *hash2)
8393 {
8394 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8395 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8396 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8397
8398 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8399 {
8400 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8401 struct elf_link_hash_entry *h;
8402
8403 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8404 h = elf_follow_link (h);
8405 if (h == &hash1->elf || h == &hash2->elf)
8406 return TRUE;
8407 }
8408 return FALSE;
8409 }
8410
8411 /* Run through all the TLS relocs looking for optimization
8412 opportunities. The linker has been hacked (see ppc64elf.em) to do
8413 a preliminary section layout so that we know the TLS segment
8414 offsets. We can't optimize earlier because some optimizations need
8415 to know the tp offset, and we need to optimize before allocating
8416 dynamic relocations. */
8417
8418 bfd_boolean
8419 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8420 {
8421 bfd *ibfd;
8422 asection *sec;
8423 struct ppc_link_hash_table *htab;
8424 unsigned char *toc_ref;
8425 int pass;
8426
8427 if (!bfd_link_executable (info))
8428 return TRUE;
8429
8430 htab = ppc_hash_table (info);
8431 if (htab == NULL)
8432 return FALSE;
8433
8434 /* Make two passes over the relocs. On the first pass, mark toc
8435 entries involved with tls relocs, and check that tls relocs
8436 involved in setting up a tls_get_addr call are indeed followed by
8437 such a call. If they are not, we can't do any tls optimization.
8438 On the second pass twiddle tls_mask flags to notify
8439 relocate_section that optimization can be done, and adjust got
8440 and plt refcounts. */
8441 toc_ref = NULL;
8442 for (pass = 0; pass < 2; ++pass)
8443 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8444 {
8445 Elf_Internal_Sym *locsyms = NULL;
8446 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8447
8448 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8449 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8450 {
8451 Elf_Internal_Rela *relstart, *rel, *relend;
8452 bfd_boolean found_tls_get_addr_arg = 0;
8453
8454 /* Read the relocations. */
8455 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8456 info->keep_memory);
8457 if (relstart == NULL)
8458 {
8459 free (toc_ref);
8460 return FALSE;
8461 }
8462
8463 relend = relstart + sec->reloc_count;
8464 for (rel = relstart; rel < relend; rel++)
8465 {
8466 enum elf_ppc64_reloc_type r_type;
8467 unsigned long r_symndx;
8468 struct elf_link_hash_entry *h;
8469 Elf_Internal_Sym *sym;
8470 asection *sym_sec;
8471 unsigned char *tls_mask;
8472 unsigned char tls_set, tls_clear, tls_type = 0;
8473 bfd_vma value;
8474 bfd_boolean ok_tprel, is_local;
8475 long toc_ref_index = 0;
8476 int expecting_tls_get_addr = 0;
8477 bfd_boolean ret = FALSE;
8478
8479 r_symndx = ELF64_R_SYM (rel->r_info);
8480 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8481 r_symndx, ibfd))
8482 {
8483 err_free_rel:
8484 if (elf_section_data (sec)->relocs != relstart)
8485 free (relstart);
8486 if (toc_ref != NULL)
8487 free (toc_ref);
8488 if (locsyms != NULL
8489 && (elf_symtab_hdr (ibfd).contents
8490 != (unsigned char *) locsyms))
8491 free (locsyms);
8492 return ret;
8493 }
8494
8495 if (h != NULL)
8496 {
8497 if (h->root.type == bfd_link_hash_defined
8498 || h->root.type == bfd_link_hash_defweak)
8499 value = h->root.u.def.value;
8500 else if (h->root.type == bfd_link_hash_undefweak)
8501 value = 0;
8502 else
8503 {
8504 found_tls_get_addr_arg = 0;
8505 continue;
8506 }
8507 }
8508 else
8509 /* Symbols referenced by TLS relocs must be of type
8510 STT_TLS. So no need for .opd local sym adjust. */
8511 value = sym->st_value;
8512
8513 ok_tprel = FALSE;
8514 is_local = FALSE;
8515 if (h == NULL
8516 || !h->def_dynamic)
8517 {
8518 is_local = TRUE;
8519 if (h != NULL
8520 && h->root.type == bfd_link_hash_undefweak)
8521 ok_tprel = TRUE;
8522 else if (sym_sec != NULL
8523 && sym_sec->output_section != NULL)
8524 {
8525 value += sym_sec->output_offset;
8526 value += sym_sec->output_section->vma;
8527 value -= htab->elf.tls_sec->vma;
8528 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8529 < (bfd_vma) 1 << 32);
8530 }
8531 }
8532
8533 r_type = ELF64_R_TYPE (rel->r_info);
8534 /* If this section has old-style __tls_get_addr calls
8535 without marker relocs, then check that each
8536 __tls_get_addr call reloc is preceded by a reloc
8537 that conceivably belongs to the __tls_get_addr arg
8538 setup insn. If we don't find matching arg setup
8539 relocs, don't do any tls optimization. */
8540 if (pass == 0
8541 && sec->has_tls_get_addr_call
8542 && h != NULL
8543 && (h == &htab->tls_get_addr->elf
8544 || h == &htab->tls_get_addr_fd->elf)
8545 && !found_tls_get_addr_arg
8546 && is_branch_reloc (r_type))
8547 {
8548 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8549 "TLS optimization disabled\n"),
8550 ibfd, sec, rel->r_offset);
8551 ret = TRUE;
8552 goto err_free_rel;
8553 }
8554
8555 found_tls_get_addr_arg = 0;
8556 switch (r_type)
8557 {
8558 case R_PPC64_GOT_TLSLD16:
8559 case R_PPC64_GOT_TLSLD16_LO:
8560 expecting_tls_get_addr = 1;
8561 found_tls_get_addr_arg = 1;
8562 /* Fall through. */
8563
8564 case R_PPC64_GOT_TLSLD16_HI:
8565 case R_PPC64_GOT_TLSLD16_HA:
8566 /* These relocs should never be against a symbol
8567 defined in a shared lib. Leave them alone if
8568 that turns out to be the case. */
8569 if (!is_local)
8570 continue;
8571
8572 /* LD -> LE */
8573 tls_set = 0;
8574 tls_clear = TLS_LD;
8575 tls_type = TLS_TLS | TLS_LD;
8576 break;
8577
8578 case R_PPC64_GOT_TLSGD16:
8579 case R_PPC64_GOT_TLSGD16_LO:
8580 expecting_tls_get_addr = 1;
8581 found_tls_get_addr_arg = 1;
8582 /* Fall through. */
8583
8584 case R_PPC64_GOT_TLSGD16_HI:
8585 case R_PPC64_GOT_TLSGD16_HA:
8586 if (ok_tprel)
8587 /* GD -> LE */
8588 tls_set = 0;
8589 else
8590 /* GD -> IE */
8591 tls_set = TLS_TLS | TLS_TPRELGD;
8592 tls_clear = TLS_GD;
8593 tls_type = TLS_TLS | TLS_GD;
8594 break;
8595
8596 case R_PPC64_GOT_TPREL16_DS:
8597 case R_PPC64_GOT_TPREL16_LO_DS:
8598 case R_PPC64_GOT_TPREL16_HI:
8599 case R_PPC64_GOT_TPREL16_HA:
8600 if (ok_tprel)
8601 {
8602 /* IE -> LE */
8603 tls_set = 0;
8604 tls_clear = TLS_TPREL;
8605 tls_type = TLS_TLS | TLS_TPREL;
8606 break;
8607 }
8608 continue;
8609
8610 case R_PPC64_TLSGD:
8611 case R_PPC64_TLSLD:
8612 found_tls_get_addr_arg = 1;
8613 /* Fall through. */
8614
8615 case R_PPC64_TLS:
8616 case R_PPC64_TOC16:
8617 case R_PPC64_TOC16_LO:
8618 if (sym_sec == NULL || sym_sec != toc)
8619 continue;
8620
8621 /* Mark this toc entry as referenced by a TLS
8622 code sequence. We can do that now in the
8623 case of R_PPC64_TLS, and after checking for
8624 tls_get_addr for the TOC16 relocs. */
8625 if (toc_ref == NULL)
8626 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8627 if (toc_ref == NULL)
8628 goto err_free_rel;
8629
8630 if (h != NULL)
8631 value = h->root.u.def.value;
8632 else
8633 value = sym->st_value;
8634 value += rel->r_addend;
8635 if (value % 8 != 0)
8636 continue;
8637 BFD_ASSERT (value < toc->size
8638 && toc->output_offset % 8 == 0);
8639 toc_ref_index = (value + toc->output_offset) / 8;
8640 if (r_type == R_PPC64_TLS
8641 || r_type == R_PPC64_TLSGD
8642 || r_type == R_PPC64_TLSLD)
8643 {
8644 toc_ref[toc_ref_index] = 1;
8645 continue;
8646 }
8647
8648 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8649 continue;
8650
8651 tls_set = 0;
8652 tls_clear = 0;
8653 expecting_tls_get_addr = 2;
8654 break;
8655
8656 case R_PPC64_TPREL64:
8657 if (pass == 0
8658 || sec != toc
8659 || toc_ref == NULL
8660 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8661 continue;
8662 if (ok_tprel)
8663 {
8664 /* IE -> LE */
8665 tls_set = TLS_EXPLICIT;
8666 tls_clear = TLS_TPREL;
8667 break;
8668 }
8669 continue;
8670
8671 case R_PPC64_DTPMOD64:
8672 if (pass == 0
8673 || sec != toc
8674 || toc_ref == NULL
8675 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8676 continue;
8677 if (rel + 1 < relend
8678 && (rel[1].r_info
8679 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8680 && rel[1].r_offset == rel->r_offset + 8)
8681 {
8682 if (ok_tprel)
8683 /* GD -> LE */
8684 tls_set = TLS_EXPLICIT | TLS_GD;
8685 else
8686 /* GD -> IE */
8687 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8688 tls_clear = TLS_GD;
8689 }
8690 else
8691 {
8692 if (!is_local)
8693 continue;
8694
8695 /* LD -> LE */
8696 tls_set = TLS_EXPLICIT;
8697 tls_clear = TLS_LD;
8698 }
8699 break;
8700
8701 default:
8702 continue;
8703 }
8704
8705 if (pass == 0)
8706 {
8707 if (!expecting_tls_get_addr
8708 || !sec->has_tls_get_addr_call)
8709 continue;
8710
8711 if (rel + 1 < relend
8712 && branch_reloc_hash_match (ibfd, rel + 1,
8713 htab->tls_get_addr,
8714 htab->tls_get_addr_fd))
8715 {
8716 if (expecting_tls_get_addr == 2)
8717 {
8718 /* Check for toc tls entries. */
8719 unsigned char *toc_tls;
8720 int retval;
8721
8722 retval = get_tls_mask (&toc_tls, NULL, NULL,
8723 &locsyms,
8724 rel, ibfd);
8725 if (retval == 0)
8726 goto err_free_rel;
8727 if (toc_tls != NULL)
8728 {
8729 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8730 found_tls_get_addr_arg = 1;
8731 if (retval > 1)
8732 toc_ref[toc_ref_index] = 1;
8733 }
8734 }
8735 continue;
8736 }
8737
8738 if (expecting_tls_get_addr != 1)
8739 continue;
8740
8741 /* Uh oh, we didn't find the expected call. We
8742 could just mark this symbol to exclude it
8743 from tls optimization but it's safer to skip
8744 the entire optimization. */
8745 /* xgettext:c-format */
8746 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8747 "TLS optimization disabled\n"),
8748 ibfd, sec, rel->r_offset);
8749 ret = TRUE;
8750 goto err_free_rel;
8751 }
8752
8753 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8754 {
8755 struct plt_entry *ent;
8756 for (ent = htab->tls_get_addr->elf.plt.plist;
8757 ent != NULL;
8758 ent = ent->next)
8759 if (ent->addend == 0)
8760 {
8761 if (ent->plt.refcount > 0)
8762 {
8763 ent->plt.refcount -= 1;
8764 expecting_tls_get_addr = 0;
8765 }
8766 break;
8767 }
8768 }
8769
8770 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8771 {
8772 struct plt_entry *ent;
8773 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8774 ent != NULL;
8775 ent = ent->next)
8776 if (ent->addend == 0)
8777 {
8778 if (ent->plt.refcount > 0)
8779 ent->plt.refcount -= 1;
8780 break;
8781 }
8782 }
8783
8784 if (tls_clear == 0)
8785 continue;
8786
8787 if ((tls_set & TLS_EXPLICIT) == 0)
8788 {
8789 struct got_entry *ent;
8790
8791 /* Adjust got entry for this reloc. */
8792 if (h != NULL)
8793 ent = h->got.glist;
8794 else
8795 ent = elf_local_got_ents (ibfd)[r_symndx];
8796
8797 for (; ent != NULL; ent = ent->next)
8798 if (ent->addend == rel->r_addend
8799 && ent->owner == ibfd
8800 && ent->tls_type == tls_type)
8801 break;
8802 if (ent == NULL)
8803 abort ();
8804
8805 if (tls_set == 0)
8806 {
8807 /* We managed to get rid of a got entry. */
8808 if (ent->got.refcount > 0)
8809 ent->got.refcount -= 1;
8810 }
8811 }
8812 else
8813 {
8814 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8815 we'll lose one or two dyn relocs. */
8816 if (!dec_dynrel_count (rel->r_info, sec, info,
8817 NULL, h, sym))
8818 return FALSE;
8819
8820 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8821 {
8822 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8823 NULL, h, sym))
8824 return FALSE;
8825 }
8826 }
8827
8828 *tls_mask |= tls_set;
8829 *tls_mask &= ~tls_clear;
8830 }
8831
8832 if (elf_section_data (sec)->relocs != relstart)
8833 free (relstart);
8834 }
8835
8836 if (locsyms != NULL
8837 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8838 {
8839 if (!info->keep_memory)
8840 free (locsyms);
8841 else
8842 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8843 }
8844 }
8845
8846 if (toc_ref != NULL)
8847 free (toc_ref);
8848 return TRUE;
8849 }
8850
8851 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8852 the values of any global symbols in a toc section that has been
8853 edited. Globals in toc sections should be a rarity, so this function
8854 sets a flag if any are found in toc sections other than the one just
8855 edited, so that futher hash table traversals can be avoided. */
8856
8857 struct adjust_toc_info
8858 {
8859 asection *toc;
8860 unsigned long *skip;
8861 bfd_boolean global_toc_syms;
8862 };
8863
8864 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8865
8866 static bfd_boolean
8867 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8868 {
8869 struct ppc_link_hash_entry *eh;
8870 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8871 unsigned long i;
8872
8873 if (h->root.type != bfd_link_hash_defined
8874 && h->root.type != bfd_link_hash_defweak)
8875 return TRUE;
8876
8877 eh = (struct ppc_link_hash_entry *) h;
8878 if (eh->adjust_done)
8879 return TRUE;
8880
8881 if (eh->elf.root.u.def.section == toc_inf->toc)
8882 {
8883 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8884 i = toc_inf->toc->rawsize >> 3;
8885 else
8886 i = eh->elf.root.u.def.value >> 3;
8887
8888 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8889 {
8890 _bfd_error_handler
8891 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8892 do
8893 ++i;
8894 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8895 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8896 }
8897
8898 eh->elf.root.u.def.value -= toc_inf->skip[i];
8899 eh->adjust_done = 1;
8900 }
8901 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8902 toc_inf->global_toc_syms = TRUE;
8903
8904 return TRUE;
8905 }
8906
8907 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8908
8909 static bfd_boolean
8910 ok_lo_toc_insn (unsigned int insn)
8911 {
8912 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8913 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8914 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8915 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8916 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8917 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8918 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8919 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8920 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8921 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8922 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8923 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8924 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8925 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8926 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8927 && (insn & 3) != 1)
8928 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8929 && ((insn & 3) == 0 || (insn & 3) == 3))
8930 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8931 }
8932
8933 /* Examine all relocs referencing .toc sections in order to remove
8934 unused .toc entries. */
8935
8936 bfd_boolean
8937 ppc64_elf_edit_toc (struct bfd_link_info *info)
8938 {
8939 bfd *ibfd;
8940 struct adjust_toc_info toc_inf;
8941 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8942
8943 htab->do_toc_opt = 1;
8944 toc_inf.global_toc_syms = TRUE;
8945 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8946 {
8947 asection *toc, *sec;
8948 Elf_Internal_Shdr *symtab_hdr;
8949 Elf_Internal_Sym *local_syms;
8950 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8951 unsigned long *skip, *drop;
8952 unsigned char *used;
8953 unsigned char *keep, last, some_unused;
8954
8955 if (!is_ppc64_elf (ibfd))
8956 continue;
8957
8958 toc = bfd_get_section_by_name (ibfd, ".toc");
8959 if (toc == NULL
8960 || toc->size == 0
8961 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8962 || discarded_section (toc))
8963 continue;
8964
8965 toc_relocs = NULL;
8966 local_syms = NULL;
8967 symtab_hdr = &elf_symtab_hdr (ibfd);
8968
8969 /* Look at sections dropped from the final link. */
8970 skip = NULL;
8971 relstart = NULL;
8972 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8973 {
8974 if (sec->reloc_count == 0
8975 || !discarded_section (sec)
8976 || get_opd_info (sec)
8977 || (sec->flags & SEC_ALLOC) == 0
8978 || (sec->flags & SEC_DEBUGGING) != 0)
8979 continue;
8980
8981 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8982 if (relstart == NULL)
8983 goto error_ret;
8984
8985 /* Run through the relocs to see which toc entries might be
8986 unused. */
8987 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8988 {
8989 enum elf_ppc64_reloc_type r_type;
8990 unsigned long r_symndx;
8991 asection *sym_sec;
8992 struct elf_link_hash_entry *h;
8993 Elf_Internal_Sym *sym;
8994 bfd_vma val;
8995
8996 r_type = ELF64_R_TYPE (rel->r_info);
8997 switch (r_type)
8998 {
8999 default:
9000 continue;
9001
9002 case R_PPC64_TOC16:
9003 case R_PPC64_TOC16_LO:
9004 case R_PPC64_TOC16_HI:
9005 case R_PPC64_TOC16_HA:
9006 case R_PPC64_TOC16_DS:
9007 case R_PPC64_TOC16_LO_DS:
9008 break;
9009 }
9010
9011 r_symndx = ELF64_R_SYM (rel->r_info);
9012 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9013 r_symndx, ibfd))
9014 goto error_ret;
9015
9016 if (sym_sec != toc)
9017 continue;
9018
9019 if (h != NULL)
9020 val = h->root.u.def.value;
9021 else
9022 val = sym->st_value;
9023 val += rel->r_addend;
9024
9025 if (val >= toc->size)
9026 continue;
9027
9028 /* Anything in the toc ought to be aligned to 8 bytes.
9029 If not, don't mark as unused. */
9030 if (val & 7)
9031 continue;
9032
9033 if (skip == NULL)
9034 {
9035 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9036 if (skip == NULL)
9037 goto error_ret;
9038 }
9039
9040 skip[val >> 3] = ref_from_discarded;
9041 }
9042
9043 if (elf_section_data (sec)->relocs != relstart)
9044 free (relstart);
9045 }
9046
9047 /* For largetoc loads of address constants, we can convert
9048 . addis rx,2,addr@got@ha
9049 . ld ry,addr@got@l(rx)
9050 to
9051 . addis rx,2,addr@toc@ha
9052 . addi ry,rx,addr@toc@l
9053 when addr is within 2G of the toc pointer. This then means
9054 that the word storing "addr" in the toc is no longer needed. */
9055
9056 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9057 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9058 && toc->reloc_count != 0)
9059 {
9060 /* Read toc relocs. */
9061 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9062 info->keep_memory);
9063 if (toc_relocs == NULL)
9064 goto error_ret;
9065
9066 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9067 {
9068 enum elf_ppc64_reloc_type r_type;
9069 unsigned long r_symndx;
9070 asection *sym_sec;
9071 struct elf_link_hash_entry *h;
9072 Elf_Internal_Sym *sym;
9073 bfd_vma val, addr;
9074
9075 r_type = ELF64_R_TYPE (rel->r_info);
9076 if (r_type != R_PPC64_ADDR64)
9077 continue;
9078
9079 r_symndx = ELF64_R_SYM (rel->r_info);
9080 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9081 r_symndx, ibfd))
9082 goto error_ret;
9083
9084 if (sym_sec == NULL
9085 || sym_sec->output_section == NULL
9086 || discarded_section (sym_sec))
9087 continue;
9088
9089 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9090 continue;
9091
9092 if (h != NULL)
9093 {
9094 if (h->type == STT_GNU_IFUNC)
9095 continue;
9096 val = h->root.u.def.value;
9097 }
9098 else
9099 {
9100 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9101 continue;
9102 val = sym->st_value;
9103 }
9104 val += rel->r_addend;
9105 val += sym_sec->output_section->vma + sym_sec->output_offset;
9106
9107 /* We don't yet know the exact toc pointer value, but we
9108 know it will be somewhere in the toc section. Don't
9109 optimize if the difference from any possible toc
9110 pointer is outside [ff..f80008000, 7fff7fff]. */
9111 addr = toc->output_section->vma + TOC_BASE_OFF;
9112 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9113 continue;
9114
9115 addr = toc->output_section->vma + toc->output_section->rawsize;
9116 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9117 continue;
9118
9119 if (skip == NULL)
9120 {
9121 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9122 if (skip == NULL)
9123 goto error_ret;
9124 }
9125
9126 skip[rel->r_offset >> 3]
9127 |= can_optimize | ((rel - toc_relocs) << 2);
9128 }
9129 }
9130
9131 if (skip == NULL)
9132 continue;
9133
9134 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9135 if (used == NULL)
9136 {
9137 error_ret:
9138 if (local_syms != NULL
9139 && symtab_hdr->contents != (unsigned char *) local_syms)
9140 free (local_syms);
9141 if (sec != NULL
9142 && relstart != NULL
9143 && elf_section_data (sec)->relocs != relstart)
9144 free (relstart);
9145 if (toc_relocs != NULL
9146 && elf_section_data (toc)->relocs != toc_relocs)
9147 free (toc_relocs);
9148 if (skip != NULL)
9149 free (skip);
9150 return FALSE;
9151 }
9152
9153 /* Now check all kept sections that might reference the toc.
9154 Check the toc itself last. */
9155 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9156 : ibfd->sections);
9157 sec != NULL;
9158 sec = (sec == toc ? NULL
9159 : sec->next == NULL ? toc
9160 : sec->next == toc && toc->next ? toc->next
9161 : sec->next))
9162 {
9163 int repeat;
9164
9165 if (sec->reloc_count == 0
9166 || discarded_section (sec)
9167 || get_opd_info (sec)
9168 || (sec->flags & SEC_ALLOC) == 0
9169 || (sec->flags & SEC_DEBUGGING) != 0)
9170 continue;
9171
9172 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9173 info->keep_memory);
9174 if (relstart == NULL)
9175 {
9176 free (used);
9177 goto error_ret;
9178 }
9179
9180 /* Mark toc entries referenced as used. */
9181 do
9182 {
9183 repeat = 0;
9184 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9185 {
9186 enum elf_ppc64_reloc_type r_type;
9187 unsigned long r_symndx;
9188 asection *sym_sec;
9189 struct elf_link_hash_entry *h;
9190 Elf_Internal_Sym *sym;
9191 bfd_vma val;
9192 enum {no_check, check_lo, check_ha} insn_check;
9193
9194 r_type = ELF64_R_TYPE (rel->r_info);
9195 switch (r_type)
9196 {
9197 default:
9198 insn_check = no_check;
9199 break;
9200
9201 case R_PPC64_GOT_TLSLD16_HA:
9202 case R_PPC64_GOT_TLSGD16_HA:
9203 case R_PPC64_GOT_TPREL16_HA:
9204 case R_PPC64_GOT_DTPREL16_HA:
9205 case R_PPC64_GOT16_HA:
9206 case R_PPC64_TOC16_HA:
9207 insn_check = check_ha;
9208 break;
9209
9210 case R_PPC64_GOT_TLSLD16_LO:
9211 case R_PPC64_GOT_TLSGD16_LO:
9212 case R_PPC64_GOT_TPREL16_LO_DS:
9213 case R_PPC64_GOT_DTPREL16_LO_DS:
9214 case R_PPC64_GOT16_LO:
9215 case R_PPC64_GOT16_LO_DS:
9216 case R_PPC64_TOC16_LO:
9217 case R_PPC64_TOC16_LO_DS:
9218 insn_check = check_lo;
9219 break;
9220 }
9221
9222 if (insn_check != no_check)
9223 {
9224 bfd_vma off = rel->r_offset & ~3;
9225 unsigned char buf[4];
9226 unsigned int insn;
9227
9228 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9229 {
9230 free (used);
9231 goto error_ret;
9232 }
9233 insn = bfd_get_32 (ibfd, buf);
9234 if (insn_check == check_lo
9235 ? !ok_lo_toc_insn (insn)
9236 : ((insn & ((0x3f << 26) | 0x1f << 16))
9237 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9238 {
9239 char str[12];
9240
9241 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9242 sprintf (str, "%#08x", insn);
9243 info->callbacks->einfo
9244 /* xgettext:c-format */
9245 (_("%P: %H: toc optimization is not supported for"
9246 " %s instruction.\n"),
9247 ibfd, sec, rel->r_offset & ~3, str);
9248 }
9249 }
9250
9251 switch (r_type)
9252 {
9253 case R_PPC64_TOC16:
9254 case R_PPC64_TOC16_LO:
9255 case R_PPC64_TOC16_HI:
9256 case R_PPC64_TOC16_HA:
9257 case R_PPC64_TOC16_DS:
9258 case R_PPC64_TOC16_LO_DS:
9259 /* In case we're taking addresses of toc entries. */
9260 case R_PPC64_ADDR64:
9261 break;
9262
9263 default:
9264 continue;
9265 }
9266
9267 r_symndx = ELF64_R_SYM (rel->r_info);
9268 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9269 r_symndx, ibfd))
9270 {
9271 free (used);
9272 goto error_ret;
9273 }
9274
9275 if (sym_sec != toc)
9276 continue;
9277
9278 if (h != NULL)
9279 val = h->root.u.def.value;
9280 else
9281 val = sym->st_value;
9282 val += rel->r_addend;
9283
9284 if (val >= toc->size)
9285 continue;
9286
9287 if ((skip[val >> 3] & can_optimize) != 0)
9288 {
9289 bfd_vma off;
9290 unsigned char opc;
9291
9292 switch (r_type)
9293 {
9294 case R_PPC64_TOC16_HA:
9295 break;
9296
9297 case R_PPC64_TOC16_LO_DS:
9298 off = rel->r_offset;
9299 off += (bfd_big_endian (ibfd) ? -2 : 3);
9300 if (!bfd_get_section_contents (ibfd, sec, &opc,
9301 off, 1))
9302 {
9303 free (used);
9304 goto error_ret;
9305 }
9306 if ((opc & (0x3f << 2)) == (58u << 2))
9307 break;
9308 /* Fall through. */
9309
9310 default:
9311 /* Wrong sort of reloc, or not a ld. We may
9312 as well clear ref_from_discarded too. */
9313 skip[val >> 3] = 0;
9314 }
9315 }
9316
9317 if (sec != toc)
9318 used[val >> 3] = 1;
9319 /* For the toc section, we only mark as used if this
9320 entry itself isn't unused. */
9321 else if ((used[rel->r_offset >> 3]
9322 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9323 && !used[val >> 3])
9324 {
9325 /* Do all the relocs again, to catch reference
9326 chains. */
9327 repeat = 1;
9328 used[val >> 3] = 1;
9329 }
9330 }
9331 }
9332 while (repeat);
9333
9334 if (elf_section_data (sec)->relocs != relstart)
9335 free (relstart);
9336 }
9337
9338 /* Merge the used and skip arrays. Assume that TOC
9339 doublewords not appearing as either used or unused belong
9340 to to an entry more than one doubleword in size. */
9341 for (drop = skip, keep = used, last = 0, some_unused = 0;
9342 drop < skip + (toc->size + 7) / 8;
9343 ++drop, ++keep)
9344 {
9345 if (*keep)
9346 {
9347 *drop &= ~ref_from_discarded;
9348 if ((*drop & can_optimize) != 0)
9349 some_unused = 1;
9350 last = 0;
9351 }
9352 else if ((*drop & ref_from_discarded) != 0)
9353 {
9354 some_unused = 1;
9355 last = ref_from_discarded;
9356 }
9357 else
9358 *drop = last;
9359 }
9360
9361 free (used);
9362
9363 if (some_unused)
9364 {
9365 bfd_byte *contents, *src;
9366 unsigned long off;
9367 Elf_Internal_Sym *sym;
9368 bfd_boolean local_toc_syms = FALSE;
9369
9370 /* Shuffle the toc contents, and at the same time convert the
9371 skip array from booleans into offsets. */
9372 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9373 goto error_ret;
9374
9375 elf_section_data (toc)->this_hdr.contents = contents;
9376
9377 for (src = contents, off = 0, drop = skip;
9378 src < contents + toc->size;
9379 src += 8, ++drop)
9380 {
9381 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9382 off += 8;
9383 else if (off != 0)
9384 {
9385 *drop = off;
9386 memcpy (src - off, src, 8);
9387 }
9388 }
9389 *drop = off;
9390 toc->rawsize = toc->size;
9391 toc->size = src - contents - off;
9392
9393 /* Adjust addends for relocs against the toc section sym,
9394 and optimize any accesses we can. */
9395 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9396 {
9397 if (sec->reloc_count == 0
9398 || discarded_section (sec))
9399 continue;
9400
9401 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9402 info->keep_memory);
9403 if (relstart == NULL)
9404 goto error_ret;
9405
9406 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9407 {
9408 enum elf_ppc64_reloc_type r_type;
9409 unsigned long r_symndx;
9410 asection *sym_sec;
9411 struct elf_link_hash_entry *h;
9412 bfd_vma val;
9413
9414 r_type = ELF64_R_TYPE (rel->r_info);
9415 switch (r_type)
9416 {
9417 default:
9418 continue;
9419
9420 case R_PPC64_TOC16:
9421 case R_PPC64_TOC16_LO:
9422 case R_PPC64_TOC16_HI:
9423 case R_PPC64_TOC16_HA:
9424 case R_PPC64_TOC16_DS:
9425 case R_PPC64_TOC16_LO_DS:
9426 case R_PPC64_ADDR64:
9427 break;
9428 }
9429
9430 r_symndx = ELF64_R_SYM (rel->r_info);
9431 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9432 r_symndx, ibfd))
9433 goto error_ret;
9434
9435 if (sym_sec != toc)
9436 continue;
9437
9438 if (h != NULL)
9439 val = h->root.u.def.value;
9440 else
9441 {
9442 val = sym->st_value;
9443 if (val != 0)
9444 local_toc_syms = TRUE;
9445 }
9446
9447 val += rel->r_addend;
9448
9449 if (val > toc->rawsize)
9450 val = toc->rawsize;
9451 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9452 continue;
9453 else if ((skip[val >> 3] & can_optimize) != 0)
9454 {
9455 Elf_Internal_Rela *tocrel
9456 = toc_relocs + (skip[val >> 3] >> 2);
9457 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9458
9459 switch (r_type)
9460 {
9461 case R_PPC64_TOC16_HA:
9462 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9463 break;
9464
9465 case R_PPC64_TOC16_LO_DS:
9466 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9467 break;
9468
9469 default:
9470 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9471 ppc_howto_init ();
9472 info->callbacks->einfo
9473 /* xgettext:c-format */
9474 (_("%P: %H: %s references "
9475 "optimized away TOC entry\n"),
9476 ibfd, sec, rel->r_offset,
9477 ppc64_elf_howto_table[r_type]->name);
9478 bfd_set_error (bfd_error_bad_value);
9479 goto error_ret;
9480 }
9481 rel->r_addend = tocrel->r_addend;
9482 elf_section_data (sec)->relocs = relstart;
9483 continue;
9484 }
9485
9486 if (h != NULL || sym->st_value != 0)
9487 continue;
9488
9489 rel->r_addend -= skip[val >> 3];
9490 elf_section_data (sec)->relocs = relstart;
9491 }
9492
9493 if (elf_section_data (sec)->relocs != relstart)
9494 free (relstart);
9495 }
9496
9497 /* We shouldn't have local or global symbols defined in the TOC,
9498 but handle them anyway. */
9499 if (local_syms != NULL)
9500 for (sym = local_syms;
9501 sym < local_syms + symtab_hdr->sh_info;
9502 ++sym)
9503 if (sym->st_value != 0
9504 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9505 {
9506 unsigned long i;
9507
9508 if (sym->st_value > toc->rawsize)
9509 i = toc->rawsize >> 3;
9510 else
9511 i = sym->st_value >> 3;
9512
9513 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9514 {
9515 if (local_toc_syms)
9516 _bfd_error_handler
9517 (_("%s defined on removed toc entry"),
9518 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9519 do
9520 ++i;
9521 while ((skip[i] & (ref_from_discarded | can_optimize)));
9522 sym->st_value = (bfd_vma) i << 3;
9523 }
9524
9525 sym->st_value -= skip[i];
9526 symtab_hdr->contents = (unsigned char *) local_syms;
9527 }
9528
9529 /* Adjust any global syms defined in this toc input section. */
9530 if (toc_inf.global_toc_syms)
9531 {
9532 toc_inf.toc = toc;
9533 toc_inf.skip = skip;
9534 toc_inf.global_toc_syms = FALSE;
9535 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9536 &toc_inf);
9537 }
9538
9539 if (toc->reloc_count != 0)
9540 {
9541 Elf_Internal_Shdr *rel_hdr;
9542 Elf_Internal_Rela *wrel;
9543 bfd_size_type sz;
9544
9545 /* Remove unused toc relocs, and adjust those we keep. */
9546 if (toc_relocs == NULL)
9547 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9548 info->keep_memory);
9549 if (toc_relocs == NULL)
9550 goto error_ret;
9551
9552 wrel = toc_relocs;
9553 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9554 if ((skip[rel->r_offset >> 3]
9555 & (ref_from_discarded | can_optimize)) == 0)
9556 {
9557 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9558 wrel->r_info = rel->r_info;
9559 wrel->r_addend = rel->r_addend;
9560 ++wrel;
9561 }
9562 else if (!dec_dynrel_count (rel->r_info, toc, info,
9563 &local_syms, NULL, NULL))
9564 goto error_ret;
9565
9566 elf_section_data (toc)->relocs = toc_relocs;
9567 toc->reloc_count = wrel - toc_relocs;
9568 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9569 sz = rel_hdr->sh_entsize;
9570 rel_hdr->sh_size = toc->reloc_count * sz;
9571 }
9572 }
9573 else if (toc_relocs != NULL
9574 && elf_section_data (toc)->relocs != toc_relocs)
9575 free (toc_relocs);
9576
9577 if (local_syms != NULL
9578 && symtab_hdr->contents != (unsigned char *) local_syms)
9579 {
9580 if (!info->keep_memory)
9581 free (local_syms);
9582 else
9583 symtab_hdr->contents = (unsigned char *) local_syms;
9584 }
9585 free (skip);
9586 }
9587
9588 return TRUE;
9589 }
9590
9591 /* Return true iff input section I references the TOC using
9592 instructions limited to +/-32k offsets. */
9593
9594 bfd_boolean
9595 ppc64_elf_has_small_toc_reloc (asection *i)
9596 {
9597 return (is_ppc64_elf (i->owner)
9598 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9599 }
9600
9601 /* Allocate space for one GOT entry. */
9602
9603 static void
9604 allocate_got (struct elf_link_hash_entry *h,
9605 struct bfd_link_info *info,
9606 struct got_entry *gent)
9607 {
9608 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9609 bfd_boolean dyn;
9610 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9611 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9612 ? 16 : 8);
9613 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9614 ? 2 : 1) * sizeof (Elf64_External_Rela);
9615 asection *got = ppc64_elf_tdata (gent->owner)->got;
9616
9617 gent->got.offset = got->size;
9618 got->size += entsize;
9619
9620 dyn = htab->elf.dynamic_sections_created;
9621 if (h->type == STT_GNU_IFUNC)
9622 {
9623 htab->elf.irelplt->size += rentsize;
9624 htab->got_reli_size += rentsize;
9625 }
9626 else if ((bfd_link_pic (info)
9627 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9628 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9629 || h->root.type != bfd_link_hash_undefweak))
9630 {
9631 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9632 relgot->size += rentsize;
9633 }
9634 }
9635
9636 /* This function merges got entries in the same toc group. */
9637
9638 static void
9639 merge_got_entries (struct got_entry **pent)
9640 {
9641 struct got_entry *ent, *ent2;
9642
9643 for (ent = *pent; ent != NULL; ent = ent->next)
9644 if (!ent->is_indirect)
9645 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9646 if (!ent2->is_indirect
9647 && ent2->addend == ent->addend
9648 && ent2->tls_type == ent->tls_type
9649 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9650 {
9651 ent2->is_indirect = TRUE;
9652 ent2->got.ent = ent;
9653 }
9654 }
9655
9656 /* Allocate space in .plt, .got and associated reloc sections for
9657 dynamic relocs. */
9658
9659 static bfd_boolean
9660 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9661 {
9662 struct bfd_link_info *info;
9663 struct ppc_link_hash_table *htab;
9664 asection *s;
9665 struct ppc_link_hash_entry *eh;
9666 struct got_entry **pgent, *gent;
9667
9668 if (h->root.type == bfd_link_hash_indirect)
9669 return TRUE;
9670
9671 info = (struct bfd_link_info *) inf;
9672 htab = ppc_hash_table (info);
9673 if (htab == NULL)
9674 return FALSE;
9675
9676 eh = (struct ppc_link_hash_entry *) h;
9677 /* Run through the TLS GD got entries first if we're changing them
9678 to TPREL. */
9679 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9680 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9681 if (gent->got.refcount > 0
9682 && (gent->tls_type & TLS_GD) != 0)
9683 {
9684 /* This was a GD entry that has been converted to TPREL. If
9685 there happens to be a TPREL entry we can use that one. */
9686 struct got_entry *ent;
9687 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9688 if (ent->got.refcount > 0
9689 && (ent->tls_type & TLS_TPREL) != 0
9690 && ent->addend == gent->addend
9691 && ent->owner == gent->owner)
9692 {
9693 gent->got.refcount = 0;
9694 break;
9695 }
9696
9697 /* If not, then we'll be using our own TPREL entry. */
9698 if (gent->got.refcount != 0)
9699 gent->tls_type = TLS_TLS | TLS_TPREL;
9700 }
9701
9702 /* Remove any list entry that won't generate a word in the GOT before
9703 we call merge_got_entries. Otherwise we risk merging to empty
9704 entries. */
9705 pgent = &h->got.glist;
9706 while ((gent = *pgent) != NULL)
9707 if (gent->got.refcount > 0)
9708 {
9709 if ((gent->tls_type & TLS_LD) != 0
9710 && !h->def_dynamic)
9711 {
9712 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9713 *pgent = gent->next;
9714 }
9715 else
9716 pgent = &gent->next;
9717 }
9718 else
9719 *pgent = gent->next;
9720
9721 if (!htab->do_multi_toc)
9722 merge_got_entries (&h->got.glist);
9723
9724 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9725 if (!gent->is_indirect)
9726 {
9727 /* Make sure this symbol is output as a dynamic symbol.
9728 Undefined weak syms won't yet be marked as dynamic,
9729 nor will all TLS symbols. */
9730 if (h->dynindx == -1
9731 && !h->forced_local
9732 && h->type != STT_GNU_IFUNC
9733 && htab->elf.dynamic_sections_created)
9734 {
9735 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9736 return FALSE;
9737 }
9738
9739 if (!is_ppc64_elf (gent->owner))
9740 abort ();
9741
9742 allocate_got (h, info, gent);
9743 }
9744
9745 if (!htab->elf.dynamic_sections_created
9746 && h->type != STT_GNU_IFUNC)
9747 eh->dyn_relocs = NULL;
9748
9749 if (eh->dyn_relocs != NULL)
9750 {
9751 struct elf_dyn_relocs *p, **pp;
9752
9753 /* In the shared -Bsymbolic case, discard space allocated for
9754 dynamic pc-relative relocs against symbols which turn out to
9755 be defined in regular objects. For the normal shared case,
9756 discard space for relocs that have become local due to symbol
9757 visibility changes. */
9758
9759 if (bfd_link_pic (info))
9760 {
9761 /* Relocs that use pc_count are those that appear on a call
9762 insn, or certain REL relocs (see must_be_dyn_reloc) that
9763 can be generated via assembly. We want calls to
9764 protected symbols to resolve directly to the function
9765 rather than going via the plt. If people want function
9766 pointer comparisons to work as expected then they should
9767 avoid writing weird assembly. */
9768 if (SYMBOL_CALLS_LOCAL (info, h))
9769 {
9770 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9771 {
9772 p->count -= p->pc_count;
9773 p->pc_count = 0;
9774 if (p->count == 0)
9775 *pp = p->next;
9776 else
9777 pp = &p->next;
9778 }
9779 }
9780
9781 /* Also discard relocs on undefined weak syms with
9782 non-default visibility. */
9783 if (eh->dyn_relocs != NULL
9784 && h->root.type == bfd_link_hash_undefweak)
9785 {
9786 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9787 eh->dyn_relocs = NULL;
9788
9789 /* Make sure this symbol is output as a dynamic symbol.
9790 Undefined weak syms won't yet be marked as dynamic. */
9791 else if (h->dynindx == -1
9792 && !h->forced_local)
9793 {
9794 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9795 return FALSE;
9796 }
9797 }
9798 }
9799 else if (h->type == STT_GNU_IFUNC)
9800 {
9801 /* A plt entry is always created when making direct calls to
9802 an ifunc, even when building a static executable, but
9803 that doesn't cover all cases. We may have only an ifunc
9804 initialised function pointer for a given ifunc symbol.
9805
9806 For ELFv2, dynamic relocations are not required when
9807 generating a global entry PLT stub. */
9808 if (abiversion (info->output_bfd) >= 2)
9809 {
9810 if (global_entry_stub (h))
9811 eh->dyn_relocs = NULL;
9812 }
9813
9814 /* For ELFv1 we have function descriptors. Descriptors need
9815 to be treated like PLT entries and thus have dynamic
9816 relocations. One exception is when the function
9817 descriptor is copied into .dynbss (which should only
9818 happen with ancient versions of gcc). */
9819 else if (h->needs_copy)
9820 eh->dyn_relocs = NULL;
9821 }
9822 else if (ELIMINATE_COPY_RELOCS)
9823 {
9824 /* For the non-pic case, discard space for relocs against
9825 symbols which turn out to need copy relocs or are not
9826 dynamic. */
9827
9828 /* First make sure this symbol is output as a dynamic symbol.
9829 Undefined weak syms won't yet be marked as dynamic. */
9830 if (h->root.type == bfd_link_hash_undefweak
9831 && !h->non_got_ref
9832 && !h->def_regular
9833 && h->dynindx == -1
9834 && !h->forced_local
9835 && !bfd_elf_link_record_dynamic_symbol (info, h))
9836 return FALSE;
9837
9838 if (h->non_got_ref
9839 || h->def_regular
9840 || h->dynindx == -1)
9841 eh->dyn_relocs = NULL;
9842 }
9843
9844 /* Finally, allocate space. */
9845 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9846 {
9847 asection *sreloc = elf_section_data (p->sec)->sreloc;
9848 if (eh->elf.type == STT_GNU_IFUNC)
9849 sreloc = htab->elf.irelplt;
9850 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9851 }
9852 }
9853
9854 if ((htab->elf.dynamic_sections_created
9855 && h->dynindx != -1
9856 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9857 || h->type == STT_GNU_IFUNC)
9858 {
9859 struct plt_entry *pent;
9860 bfd_boolean doneone = FALSE;
9861 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9862 if (pent->plt.refcount > 0)
9863 {
9864 if (!htab->elf.dynamic_sections_created
9865 || h->dynindx == -1)
9866 {
9867 s = htab->elf.iplt;
9868 pent->plt.offset = s->size;
9869 s->size += PLT_ENTRY_SIZE (htab);
9870 s = htab->elf.irelplt;
9871 }
9872 else
9873 {
9874 /* If this is the first .plt entry, make room for the special
9875 first entry. */
9876 s = htab->elf.splt;
9877 if (s->size == 0)
9878 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9879
9880 pent->plt.offset = s->size;
9881
9882 /* Make room for this entry. */
9883 s->size += PLT_ENTRY_SIZE (htab);
9884
9885 /* Make room for the .glink code. */
9886 s = htab->glink;
9887 if (s->size == 0)
9888 s->size += GLINK_CALL_STUB_SIZE;
9889 if (htab->opd_abi)
9890 {
9891 /* We need bigger stubs past index 32767. */
9892 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9893 s->size += 4;
9894 s->size += 2*4;
9895 }
9896 else
9897 s->size += 4;
9898
9899 /* We also need to make an entry in the .rela.plt section. */
9900 s = htab->elf.srelplt;
9901 }
9902 s->size += sizeof (Elf64_External_Rela);
9903 doneone = TRUE;
9904 }
9905 else
9906 pent->plt.offset = (bfd_vma) -1;
9907 if (!doneone)
9908 {
9909 h->plt.plist = NULL;
9910 h->needs_plt = 0;
9911 }
9912 }
9913 else
9914 {
9915 h->plt.plist = NULL;
9916 h->needs_plt = 0;
9917 }
9918
9919 return TRUE;
9920 }
9921
9922 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9923 to set up space for global entry stubs. These are put in glink,
9924 after the branch table. */
9925
9926 static bfd_boolean
9927 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9928 {
9929 struct bfd_link_info *info;
9930 struct ppc_link_hash_table *htab;
9931 struct plt_entry *pent;
9932 asection *s;
9933
9934 if (h->root.type == bfd_link_hash_indirect)
9935 return TRUE;
9936
9937 if (!h->pointer_equality_needed)
9938 return TRUE;
9939
9940 if (h->def_regular)
9941 return TRUE;
9942
9943 info = inf;
9944 htab = ppc_hash_table (info);
9945 if (htab == NULL)
9946 return FALSE;
9947
9948 s = htab->glink;
9949 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9950 if (pent->plt.offset != (bfd_vma) -1
9951 && pent->addend == 0)
9952 {
9953 /* For ELFv2, if this symbol is not defined in a regular file
9954 and we are not generating a shared library or pie, then we
9955 need to define the symbol in the executable on a call stub.
9956 This is to avoid text relocations. */
9957 s->size = (s->size + 15) & -16;
9958 h->root.type = bfd_link_hash_defined;
9959 h->root.u.def.section = s;
9960 h->root.u.def.value = s->size;
9961 s->size += 16;
9962 break;
9963 }
9964 return TRUE;
9965 }
9966
9967 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9968 read-only sections. */
9969
9970 static bfd_boolean
9971 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9972 {
9973 if (h->root.type == bfd_link_hash_indirect)
9974 return TRUE;
9975
9976 if (readonly_dynrelocs (h))
9977 {
9978 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9979
9980 /* Not an error, just cut short the traversal. */
9981 return FALSE;
9982 }
9983 return TRUE;
9984 }
9985
9986 /* Set the sizes of the dynamic sections. */
9987
9988 static bfd_boolean
9989 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9990 struct bfd_link_info *info)
9991 {
9992 struct ppc_link_hash_table *htab;
9993 bfd *dynobj;
9994 asection *s;
9995 bfd_boolean relocs;
9996 bfd *ibfd;
9997 struct got_entry *first_tlsld;
9998
9999 htab = ppc_hash_table (info);
10000 if (htab == NULL)
10001 return FALSE;
10002
10003 dynobj = htab->elf.dynobj;
10004 if (dynobj == NULL)
10005 abort ();
10006
10007 if (htab->elf.dynamic_sections_created)
10008 {
10009 /* Set the contents of the .interp section to the interpreter. */
10010 if (bfd_link_executable (info) && !info->nointerp)
10011 {
10012 s = bfd_get_linker_section (dynobj, ".interp");
10013 if (s == NULL)
10014 abort ();
10015 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10016 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10017 }
10018 }
10019
10020 /* Set up .got offsets for local syms, and space for local dynamic
10021 relocs. */
10022 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10023 {
10024 struct got_entry **lgot_ents;
10025 struct got_entry **end_lgot_ents;
10026 struct plt_entry **local_plt;
10027 struct plt_entry **end_local_plt;
10028 unsigned char *lgot_masks;
10029 bfd_size_type locsymcount;
10030 Elf_Internal_Shdr *symtab_hdr;
10031
10032 if (!is_ppc64_elf (ibfd))
10033 continue;
10034
10035 for (s = ibfd->sections; s != NULL; s = s->next)
10036 {
10037 struct ppc_dyn_relocs *p;
10038
10039 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10040 {
10041 if (!bfd_is_abs_section (p->sec)
10042 && bfd_is_abs_section (p->sec->output_section))
10043 {
10044 /* Input section has been discarded, either because
10045 it is a copy of a linkonce section or due to
10046 linker script /DISCARD/, so we'll be discarding
10047 the relocs too. */
10048 }
10049 else if (p->count != 0)
10050 {
10051 asection *srel = elf_section_data (p->sec)->sreloc;
10052 if (p->ifunc)
10053 srel = htab->elf.irelplt;
10054 srel->size += p->count * sizeof (Elf64_External_Rela);
10055 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10056 info->flags |= DF_TEXTREL;
10057 }
10058 }
10059 }
10060
10061 lgot_ents = elf_local_got_ents (ibfd);
10062 if (!lgot_ents)
10063 continue;
10064
10065 symtab_hdr = &elf_symtab_hdr (ibfd);
10066 locsymcount = symtab_hdr->sh_info;
10067 end_lgot_ents = lgot_ents + locsymcount;
10068 local_plt = (struct plt_entry **) end_lgot_ents;
10069 end_local_plt = local_plt + locsymcount;
10070 lgot_masks = (unsigned char *) end_local_plt;
10071 s = ppc64_elf_tdata (ibfd)->got;
10072 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10073 {
10074 struct got_entry **pent, *ent;
10075
10076 pent = lgot_ents;
10077 while ((ent = *pent) != NULL)
10078 if (ent->got.refcount > 0)
10079 {
10080 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10081 {
10082 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10083 *pent = ent->next;
10084 }
10085 else
10086 {
10087 unsigned int ent_size = 8;
10088 unsigned int rel_size = sizeof (Elf64_External_Rela);
10089
10090 ent->got.offset = s->size;
10091 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10092 {
10093 ent_size *= 2;
10094 rel_size *= 2;
10095 }
10096 s->size += ent_size;
10097 if ((*lgot_masks & PLT_IFUNC) != 0)
10098 {
10099 htab->elf.irelplt->size += rel_size;
10100 htab->got_reli_size += rel_size;
10101 }
10102 else if (bfd_link_pic (info))
10103 {
10104 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10105 srel->size += rel_size;
10106 }
10107 pent = &ent->next;
10108 }
10109 }
10110 else
10111 *pent = ent->next;
10112 }
10113
10114 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10115 for (; local_plt < end_local_plt; ++local_plt)
10116 {
10117 struct plt_entry *ent;
10118
10119 for (ent = *local_plt; ent != NULL; ent = ent->next)
10120 if (ent->plt.refcount > 0)
10121 {
10122 s = htab->elf.iplt;
10123 ent->plt.offset = s->size;
10124 s->size += PLT_ENTRY_SIZE (htab);
10125
10126 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10127 }
10128 else
10129 ent->plt.offset = (bfd_vma) -1;
10130 }
10131 }
10132
10133 /* Allocate global sym .plt and .got entries, and space for global
10134 sym dynamic relocs. */
10135 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10136 /* Stash the end of glink branch table. */
10137 if (htab->glink != NULL)
10138 htab->glink->rawsize = htab->glink->size;
10139
10140 if (!htab->opd_abi && !bfd_link_pic (info))
10141 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10142
10143 first_tlsld = NULL;
10144 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10145 {
10146 struct got_entry *ent;
10147
10148 if (!is_ppc64_elf (ibfd))
10149 continue;
10150
10151 ent = ppc64_tlsld_got (ibfd);
10152 if (ent->got.refcount > 0)
10153 {
10154 if (!htab->do_multi_toc && first_tlsld != NULL)
10155 {
10156 ent->is_indirect = TRUE;
10157 ent->got.ent = first_tlsld;
10158 }
10159 else
10160 {
10161 if (first_tlsld == NULL)
10162 first_tlsld = ent;
10163 s = ppc64_elf_tdata (ibfd)->got;
10164 ent->got.offset = s->size;
10165 ent->owner = ibfd;
10166 s->size += 16;
10167 if (bfd_link_pic (info))
10168 {
10169 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10170 srel->size += sizeof (Elf64_External_Rela);
10171 }
10172 }
10173 }
10174 else
10175 ent->got.offset = (bfd_vma) -1;
10176 }
10177
10178 /* We now have determined the sizes of the various dynamic sections.
10179 Allocate memory for them. */
10180 relocs = FALSE;
10181 for (s = dynobj->sections; s != NULL; s = s->next)
10182 {
10183 if ((s->flags & SEC_LINKER_CREATED) == 0)
10184 continue;
10185
10186 if (s == htab->brlt || s == htab->relbrlt)
10187 /* These haven't been allocated yet; don't strip. */
10188 continue;
10189 else if (s == htab->elf.sgot
10190 || s == htab->elf.splt
10191 || s == htab->elf.iplt
10192 || s == htab->glink
10193 || s == htab->dynbss)
10194 {
10195 /* Strip this section if we don't need it; see the
10196 comment below. */
10197 }
10198 else if (s == htab->glink_eh_frame)
10199 {
10200 if (!bfd_is_abs_section (s->output_section))
10201 /* Not sized yet. */
10202 continue;
10203 }
10204 else if (CONST_STRNEQ (s->name, ".rela"))
10205 {
10206 if (s->size != 0)
10207 {
10208 if (s != htab->elf.srelplt)
10209 relocs = TRUE;
10210
10211 /* We use the reloc_count field as a counter if we need
10212 to copy relocs into the output file. */
10213 s->reloc_count = 0;
10214 }
10215 }
10216 else
10217 {
10218 /* It's not one of our sections, so don't allocate space. */
10219 continue;
10220 }
10221
10222 if (s->size == 0)
10223 {
10224 /* If we don't need this section, strip it from the
10225 output file. This is mostly to handle .rela.bss and
10226 .rela.plt. We must create both sections in
10227 create_dynamic_sections, because they must be created
10228 before the linker maps input sections to output
10229 sections. The linker does that before
10230 adjust_dynamic_symbol is called, and it is that
10231 function which decides whether anything needs to go
10232 into these sections. */
10233 s->flags |= SEC_EXCLUDE;
10234 continue;
10235 }
10236
10237 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10238 continue;
10239
10240 /* Allocate memory for the section contents. We use bfd_zalloc
10241 here in case unused entries are not reclaimed before the
10242 section's contents are written out. This should not happen,
10243 but this way if it does we get a R_PPC64_NONE reloc in .rela
10244 sections instead of garbage.
10245 We also rely on the section contents being zero when writing
10246 the GOT. */
10247 s->contents = bfd_zalloc (dynobj, s->size);
10248 if (s->contents == NULL)
10249 return FALSE;
10250 }
10251
10252 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10253 {
10254 if (!is_ppc64_elf (ibfd))
10255 continue;
10256
10257 s = ppc64_elf_tdata (ibfd)->got;
10258 if (s != NULL && s != htab->elf.sgot)
10259 {
10260 if (s->size == 0)
10261 s->flags |= SEC_EXCLUDE;
10262 else
10263 {
10264 s->contents = bfd_zalloc (ibfd, s->size);
10265 if (s->contents == NULL)
10266 return FALSE;
10267 }
10268 }
10269 s = ppc64_elf_tdata (ibfd)->relgot;
10270 if (s != NULL)
10271 {
10272 if (s->size == 0)
10273 s->flags |= SEC_EXCLUDE;
10274 else
10275 {
10276 s->contents = bfd_zalloc (ibfd, s->size);
10277 if (s->contents == NULL)
10278 return FALSE;
10279 relocs = TRUE;
10280 s->reloc_count = 0;
10281 }
10282 }
10283 }
10284
10285 if (htab->elf.dynamic_sections_created)
10286 {
10287 bfd_boolean tls_opt;
10288
10289 /* Add some entries to the .dynamic section. We fill in the
10290 values later, in ppc64_elf_finish_dynamic_sections, but we
10291 must add the entries now so that we get the correct size for
10292 the .dynamic section. The DT_DEBUG entry is filled in by the
10293 dynamic linker and used by the debugger. */
10294 #define add_dynamic_entry(TAG, VAL) \
10295 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10296
10297 if (bfd_link_executable (info))
10298 {
10299 if (!add_dynamic_entry (DT_DEBUG, 0))
10300 return FALSE;
10301 }
10302
10303 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10304 {
10305 if (!add_dynamic_entry (DT_PLTGOT, 0)
10306 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10307 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10308 || !add_dynamic_entry (DT_JMPREL, 0)
10309 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10310 return FALSE;
10311 }
10312
10313 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10314 {
10315 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10316 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10317 return FALSE;
10318 }
10319
10320 tls_opt = (htab->params->tls_get_addr_opt
10321 && htab->tls_get_addr_fd != NULL
10322 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10323 if (tls_opt || !htab->opd_abi)
10324 {
10325 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10326 return FALSE;
10327 }
10328
10329 if (relocs)
10330 {
10331 if (!add_dynamic_entry (DT_RELA, 0)
10332 || !add_dynamic_entry (DT_RELASZ, 0)
10333 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10334 return FALSE;
10335
10336 /* If any dynamic relocs apply to a read-only section,
10337 then we need a DT_TEXTREL entry. */
10338 if ((info->flags & DF_TEXTREL) == 0)
10339 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10340
10341 if ((info->flags & DF_TEXTREL) != 0)
10342 {
10343 if (!add_dynamic_entry (DT_TEXTREL, 0))
10344 return FALSE;
10345 }
10346 }
10347 }
10348 #undef add_dynamic_entry
10349
10350 return TRUE;
10351 }
10352
10353 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10354
10355 static bfd_boolean
10356 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10357 {
10358 if (h->plt.plist != NULL
10359 && !h->def_regular
10360 && !h->pointer_equality_needed)
10361 return FALSE;
10362
10363 return _bfd_elf_hash_symbol (h);
10364 }
10365
10366 /* Determine the type of stub needed, if any, for a call. */
10367
10368 static inline enum ppc_stub_type
10369 ppc_type_of_stub (asection *input_sec,
10370 const Elf_Internal_Rela *rel,
10371 struct ppc_link_hash_entry **hash,
10372 struct plt_entry **plt_ent,
10373 bfd_vma destination,
10374 unsigned long local_off)
10375 {
10376 struct ppc_link_hash_entry *h = *hash;
10377 bfd_vma location;
10378 bfd_vma branch_offset;
10379 bfd_vma max_branch_offset;
10380 enum elf_ppc64_reloc_type r_type;
10381
10382 if (h != NULL)
10383 {
10384 struct plt_entry *ent;
10385 struct ppc_link_hash_entry *fdh = h;
10386 if (h->oh != NULL
10387 && h->oh->is_func_descriptor)
10388 {
10389 fdh = ppc_follow_link (h->oh);
10390 *hash = fdh;
10391 }
10392
10393 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10394 if (ent->addend == rel->r_addend
10395 && ent->plt.offset != (bfd_vma) -1)
10396 {
10397 *plt_ent = ent;
10398 return ppc_stub_plt_call;
10399 }
10400
10401 /* Here, we know we don't have a plt entry. If we don't have a
10402 either a defined function descriptor or a defined entry symbol
10403 in a regular object file, then it is pointless trying to make
10404 any other type of stub. */
10405 if (!is_static_defined (&fdh->elf)
10406 && !is_static_defined (&h->elf))
10407 return ppc_stub_none;
10408 }
10409 else if (elf_local_got_ents (input_sec->owner) != NULL)
10410 {
10411 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10412 struct plt_entry **local_plt = (struct plt_entry **)
10413 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10414 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10415
10416 if (local_plt[r_symndx] != NULL)
10417 {
10418 struct plt_entry *ent;
10419
10420 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10421 if (ent->addend == rel->r_addend
10422 && ent->plt.offset != (bfd_vma) -1)
10423 {
10424 *plt_ent = ent;
10425 return ppc_stub_plt_call;
10426 }
10427 }
10428 }
10429
10430 /* Determine where the call point is. */
10431 location = (input_sec->output_offset
10432 + input_sec->output_section->vma
10433 + rel->r_offset);
10434
10435 branch_offset = destination - location;
10436 r_type = ELF64_R_TYPE (rel->r_info);
10437
10438 /* Determine if a long branch stub is needed. */
10439 max_branch_offset = 1 << 25;
10440 if (r_type != R_PPC64_REL24)
10441 max_branch_offset = 1 << 15;
10442
10443 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10444 /* We need a stub. Figure out whether a long_branch or plt_branch
10445 is needed later. */
10446 return ppc_stub_long_branch;
10447
10448 return ppc_stub_none;
10449 }
10450
10451 /* With power7 weakly ordered memory model, it is possible for ld.so
10452 to update a plt entry in one thread and have another thread see a
10453 stale zero toc entry. To avoid this we need some sort of acquire
10454 barrier in the call stub. One solution is to make the load of the
10455 toc word seem to appear to depend on the load of the function entry
10456 word. Another solution is to test for r2 being zero, and branch to
10457 the appropriate glink entry if so.
10458
10459 . fake dep barrier compare
10460 . ld 12,xxx(2) ld 12,xxx(2)
10461 . mtctr 12 mtctr 12
10462 . xor 11,12,12 ld 2,xxx+8(2)
10463 . add 2,2,11 cmpldi 2,0
10464 . ld 2,xxx+8(2) bnectr+
10465 . bctr b <glink_entry>
10466
10467 The solution involving the compare turns out to be faster, so
10468 that's what we use unless the branch won't reach. */
10469
10470 #define ALWAYS_USE_FAKE_DEP 0
10471 #define ALWAYS_EMIT_R2SAVE 0
10472
10473 #define PPC_LO(v) ((v) & 0xffff)
10474 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10475 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10476
10477 static inline unsigned int
10478 plt_stub_size (struct ppc_link_hash_table *htab,
10479 struct ppc_stub_hash_entry *stub_entry,
10480 bfd_vma off)
10481 {
10482 unsigned size = 12;
10483
10484 if (ALWAYS_EMIT_R2SAVE
10485 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10486 size += 4;
10487 if (PPC_HA (off) != 0)
10488 size += 4;
10489 if (htab->opd_abi)
10490 {
10491 size += 4;
10492 if (htab->params->plt_static_chain)
10493 size += 4;
10494 if (htab->params->plt_thread_safe
10495 && htab->elf.dynamic_sections_created
10496 && stub_entry->h != NULL
10497 && stub_entry->h->elf.dynindx != -1)
10498 size += 8;
10499 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10500 size += 4;
10501 }
10502 if (stub_entry->h != NULL
10503 && (stub_entry->h == htab->tls_get_addr_fd
10504 || stub_entry->h == htab->tls_get_addr)
10505 && htab->params->tls_get_addr_opt)
10506 size += 13 * 4;
10507 return size;
10508 }
10509
10510 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10511 then return the padding needed to do so. */
10512 static inline unsigned int
10513 plt_stub_pad (struct ppc_link_hash_table *htab,
10514 struct ppc_stub_hash_entry *stub_entry,
10515 bfd_vma plt_off)
10516 {
10517 int stub_align = 1 << htab->params->plt_stub_align;
10518 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10519 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10520
10521 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10522 > ((stub_size - 1) & -stub_align))
10523 return stub_align - (stub_off & (stub_align - 1));
10524 return 0;
10525 }
10526
10527 /* Build a .plt call stub. */
10528
10529 static inline bfd_byte *
10530 build_plt_stub (struct ppc_link_hash_table *htab,
10531 struct ppc_stub_hash_entry *stub_entry,
10532 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10533 {
10534 bfd *obfd = htab->params->stub_bfd;
10535 bfd_boolean plt_load_toc = htab->opd_abi;
10536 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10537 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10538 && htab->elf.dynamic_sections_created
10539 && stub_entry->h != NULL
10540 && stub_entry->h->elf.dynindx != -1);
10541 bfd_boolean use_fake_dep = plt_thread_safe;
10542 bfd_vma cmp_branch_off = 0;
10543
10544 if (!ALWAYS_USE_FAKE_DEP
10545 && plt_load_toc
10546 && plt_thread_safe
10547 && !((stub_entry->h == htab->tls_get_addr_fd
10548 || stub_entry->h == htab->tls_get_addr)
10549 && htab->params->tls_get_addr_opt))
10550 {
10551 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10552 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10553 / PLT_ENTRY_SIZE (htab));
10554 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10555 bfd_vma to, from;
10556
10557 if (pltindex > 32768)
10558 glinkoff += (pltindex - 32768) * 4;
10559 to = (glinkoff
10560 + htab->glink->output_offset
10561 + htab->glink->output_section->vma);
10562 from = (p - stub_entry->group->stub_sec->contents
10563 + 4 * (ALWAYS_EMIT_R2SAVE
10564 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10565 + 4 * (PPC_HA (offset) != 0)
10566 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10567 != PPC_HA (offset))
10568 + 4 * (plt_static_chain != 0)
10569 + 20
10570 + stub_entry->group->stub_sec->output_offset
10571 + stub_entry->group->stub_sec->output_section->vma);
10572 cmp_branch_off = to - from;
10573 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10574 }
10575
10576 if (PPC_HA (offset) != 0)
10577 {
10578 if (r != NULL)
10579 {
10580 if (ALWAYS_EMIT_R2SAVE
10581 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10582 r[0].r_offset += 4;
10583 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10584 r[1].r_offset = r[0].r_offset + 4;
10585 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10586 r[1].r_addend = r[0].r_addend;
10587 if (plt_load_toc)
10588 {
10589 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10590 {
10591 r[2].r_offset = r[1].r_offset + 4;
10592 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10593 r[2].r_addend = r[0].r_addend;
10594 }
10595 else
10596 {
10597 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10598 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10599 r[2].r_addend = r[0].r_addend + 8;
10600 if (plt_static_chain)
10601 {
10602 r[3].r_offset = r[2].r_offset + 4;
10603 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10604 r[3].r_addend = r[0].r_addend + 16;
10605 }
10606 }
10607 }
10608 }
10609 if (ALWAYS_EMIT_R2SAVE
10610 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10611 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10612 if (plt_load_toc)
10613 {
10614 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10615 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10616 }
10617 else
10618 {
10619 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10620 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10621 }
10622 if (plt_load_toc
10623 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10624 {
10625 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10626 offset = 0;
10627 }
10628 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10629 if (plt_load_toc)
10630 {
10631 if (use_fake_dep)
10632 {
10633 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10634 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10635 }
10636 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10637 if (plt_static_chain)
10638 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10639 }
10640 }
10641 else
10642 {
10643 if (r != NULL)
10644 {
10645 if (ALWAYS_EMIT_R2SAVE
10646 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10647 r[0].r_offset += 4;
10648 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10649 if (plt_load_toc)
10650 {
10651 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10652 {
10653 r[1].r_offset = r[0].r_offset + 4;
10654 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10655 r[1].r_addend = r[0].r_addend;
10656 }
10657 else
10658 {
10659 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10660 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10661 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10662 if (plt_static_chain)
10663 {
10664 r[2].r_offset = r[1].r_offset + 4;
10665 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10666 r[2].r_addend = r[0].r_addend + 8;
10667 }
10668 }
10669 }
10670 }
10671 if (ALWAYS_EMIT_R2SAVE
10672 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10673 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10674 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10675 if (plt_load_toc
10676 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10677 {
10678 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10679 offset = 0;
10680 }
10681 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10682 if (plt_load_toc)
10683 {
10684 if (use_fake_dep)
10685 {
10686 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10687 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10688 }
10689 if (plt_static_chain)
10690 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10691 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10692 }
10693 }
10694 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10695 {
10696 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10697 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10698 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10699 }
10700 else
10701 bfd_put_32 (obfd, BCTR, p), p += 4;
10702 return p;
10703 }
10704
10705 /* Build a special .plt call stub for __tls_get_addr. */
10706
10707 #define LD_R11_0R3 0xe9630000
10708 #define LD_R12_0R3 0xe9830000
10709 #define MR_R0_R3 0x7c601b78
10710 #define CMPDI_R11_0 0x2c2b0000
10711 #define ADD_R3_R12_R13 0x7c6c6a14
10712 #define BEQLR 0x4d820020
10713 #define MR_R3_R0 0x7c030378
10714 #define STD_R11_0R1 0xf9610000
10715 #define BCTRL 0x4e800421
10716 #define LD_R11_0R1 0xe9610000
10717 #define MTLR_R11 0x7d6803a6
10718
10719 static inline bfd_byte *
10720 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10721 struct ppc_stub_hash_entry *stub_entry,
10722 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10723 {
10724 bfd *obfd = htab->params->stub_bfd;
10725
10726 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10727 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10728 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10729 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10730 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10731 bfd_put_32 (obfd, BEQLR, p), p += 4;
10732 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10733 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10734 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10735
10736 if (r != NULL)
10737 r[0].r_offset += 9 * 4;
10738 p = build_plt_stub (htab, stub_entry, p, offset, r);
10739 bfd_put_32 (obfd, BCTRL, p - 4);
10740
10741 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10742 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10743 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10744 bfd_put_32 (obfd, BLR, p), p += 4;
10745
10746 return p;
10747 }
10748
10749 static Elf_Internal_Rela *
10750 get_relocs (asection *sec, int count)
10751 {
10752 Elf_Internal_Rela *relocs;
10753 struct bfd_elf_section_data *elfsec_data;
10754
10755 elfsec_data = elf_section_data (sec);
10756 relocs = elfsec_data->relocs;
10757 if (relocs == NULL)
10758 {
10759 bfd_size_type relsize;
10760 relsize = sec->reloc_count * sizeof (*relocs);
10761 relocs = bfd_alloc (sec->owner, relsize);
10762 if (relocs == NULL)
10763 return NULL;
10764 elfsec_data->relocs = relocs;
10765 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10766 sizeof (Elf_Internal_Shdr));
10767 if (elfsec_data->rela.hdr == NULL)
10768 return NULL;
10769 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10770 * sizeof (Elf64_External_Rela));
10771 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10772 sec->reloc_count = 0;
10773 }
10774 relocs += sec->reloc_count;
10775 sec->reloc_count += count;
10776 return relocs;
10777 }
10778
10779 static bfd_vma
10780 get_r2off (struct bfd_link_info *info,
10781 struct ppc_stub_hash_entry *stub_entry)
10782 {
10783 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10784 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10785
10786 if (r2off == 0)
10787 {
10788 /* Support linking -R objects. Get the toc pointer from the
10789 opd entry. */
10790 char buf[8];
10791 if (!htab->opd_abi)
10792 return r2off;
10793 asection *opd = stub_entry->h->elf.root.u.def.section;
10794 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10795
10796 if (strcmp (opd->name, ".opd") != 0
10797 || opd->reloc_count != 0)
10798 {
10799 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10800 stub_entry->h->elf.root.root.string);
10801 bfd_set_error (bfd_error_bad_value);
10802 return (bfd_vma) -1;
10803 }
10804 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10805 return (bfd_vma) -1;
10806 r2off = bfd_get_64 (opd->owner, buf);
10807 r2off -= elf_gp (info->output_bfd);
10808 }
10809 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10810 return r2off;
10811 }
10812
10813 static bfd_boolean
10814 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10815 {
10816 struct ppc_stub_hash_entry *stub_entry;
10817 struct ppc_branch_hash_entry *br_entry;
10818 struct bfd_link_info *info;
10819 struct ppc_link_hash_table *htab;
10820 bfd_byte *loc;
10821 bfd_byte *p;
10822 bfd_vma dest, off;
10823 int size;
10824 Elf_Internal_Rela *r;
10825 asection *plt;
10826
10827 /* Massage our args to the form they really have. */
10828 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10829 info = in_arg;
10830
10831 htab = ppc_hash_table (info);
10832 if (htab == NULL)
10833 return FALSE;
10834
10835 /* Make a note of the offset within the stubs for this entry. */
10836 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10837 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10838
10839 htab->stub_count[stub_entry->stub_type - 1] += 1;
10840 switch (stub_entry->stub_type)
10841 {
10842 case ppc_stub_long_branch:
10843 case ppc_stub_long_branch_r2off:
10844 /* Branches are relative. This is where we are going to. */
10845 dest = (stub_entry->target_value
10846 + stub_entry->target_section->output_offset
10847 + stub_entry->target_section->output_section->vma);
10848 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10849 off = dest;
10850
10851 /* And this is where we are coming from. */
10852 off -= (stub_entry->stub_offset
10853 + stub_entry->group->stub_sec->output_offset
10854 + stub_entry->group->stub_sec->output_section->vma);
10855
10856 size = 4;
10857 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10858 {
10859 bfd_vma r2off = get_r2off (info, stub_entry);
10860
10861 if (r2off == (bfd_vma) -1)
10862 {
10863 htab->stub_error = TRUE;
10864 return FALSE;
10865 }
10866 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10867 loc += 4;
10868 size = 8;
10869 if (PPC_HA (r2off) != 0)
10870 {
10871 bfd_put_32 (htab->params->stub_bfd,
10872 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10873 loc += 4;
10874 size += 4;
10875 }
10876 if (PPC_LO (r2off) != 0)
10877 {
10878 bfd_put_32 (htab->params->stub_bfd,
10879 ADDI_R2_R2 | PPC_LO (r2off), loc);
10880 loc += 4;
10881 size += 4;
10882 }
10883 off -= size - 4;
10884 }
10885 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10886
10887 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10888 {
10889 info->callbacks->einfo
10890 (_("%P: long branch stub `%s' offset overflow\n"),
10891 stub_entry->root.string);
10892 htab->stub_error = TRUE;
10893 return FALSE;
10894 }
10895
10896 if (info->emitrelocations)
10897 {
10898 r = get_relocs (stub_entry->group->stub_sec, 1);
10899 if (r == NULL)
10900 return FALSE;
10901 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10902 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10903 r->r_addend = dest;
10904 if (stub_entry->h != NULL)
10905 {
10906 struct elf_link_hash_entry **hashes;
10907 unsigned long symndx;
10908 struct ppc_link_hash_entry *h;
10909
10910 hashes = elf_sym_hashes (htab->params->stub_bfd);
10911 if (hashes == NULL)
10912 {
10913 bfd_size_type hsize;
10914
10915 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10916 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10917 if (hashes == NULL)
10918 return FALSE;
10919 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10920 htab->stub_globals = 1;
10921 }
10922 symndx = htab->stub_globals++;
10923 h = stub_entry->h;
10924 hashes[symndx] = &h->elf;
10925 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10926 if (h->oh != NULL && h->oh->is_func)
10927 h = ppc_follow_link (h->oh);
10928 if (h->elf.root.u.def.section != stub_entry->target_section)
10929 /* H is an opd symbol. The addend must be zero. */
10930 r->r_addend = 0;
10931 else
10932 {
10933 off = (h->elf.root.u.def.value
10934 + h->elf.root.u.def.section->output_offset
10935 + h->elf.root.u.def.section->output_section->vma);
10936 r->r_addend -= off;
10937 }
10938 }
10939 }
10940 break;
10941
10942 case ppc_stub_plt_branch:
10943 case ppc_stub_plt_branch_r2off:
10944 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10945 stub_entry->root.string + 9,
10946 FALSE, FALSE);
10947 if (br_entry == NULL)
10948 {
10949 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10950 stub_entry->root.string);
10951 htab->stub_error = TRUE;
10952 return FALSE;
10953 }
10954
10955 dest = (stub_entry->target_value
10956 + stub_entry->target_section->output_offset
10957 + stub_entry->target_section->output_section->vma);
10958 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10959 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10960
10961 bfd_put_64 (htab->brlt->owner, dest,
10962 htab->brlt->contents + br_entry->offset);
10963
10964 if (br_entry->iter == htab->stub_iteration)
10965 {
10966 br_entry->iter = 0;
10967
10968 if (htab->relbrlt != NULL)
10969 {
10970 /* Create a reloc for the branch lookup table entry. */
10971 Elf_Internal_Rela rela;
10972 bfd_byte *rl;
10973
10974 rela.r_offset = (br_entry->offset
10975 + htab->brlt->output_offset
10976 + htab->brlt->output_section->vma);
10977 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10978 rela.r_addend = dest;
10979
10980 rl = htab->relbrlt->contents;
10981 rl += (htab->relbrlt->reloc_count++
10982 * sizeof (Elf64_External_Rela));
10983 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10984 }
10985 else if (info->emitrelocations)
10986 {
10987 r = get_relocs (htab->brlt, 1);
10988 if (r == NULL)
10989 return FALSE;
10990 /* brlt, being SEC_LINKER_CREATED does not go through the
10991 normal reloc processing. Symbols and offsets are not
10992 translated from input file to output file form, so
10993 set up the offset per the output file. */
10994 r->r_offset = (br_entry->offset
10995 + htab->brlt->output_offset
10996 + htab->brlt->output_section->vma);
10997 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10998 r->r_addend = dest;
10999 }
11000 }
11001
11002 dest = (br_entry->offset
11003 + htab->brlt->output_offset
11004 + htab->brlt->output_section->vma);
11005
11006 off = (dest
11007 - elf_gp (htab->brlt->output_section->owner)
11008 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11009
11010 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11011 {
11012 info->callbacks->einfo
11013 (_("%P: linkage table error against `%T'\n"),
11014 stub_entry->root.string);
11015 bfd_set_error (bfd_error_bad_value);
11016 htab->stub_error = TRUE;
11017 return FALSE;
11018 }
11019
11020 if (info->emitrelocations)
11021 {
11022 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11023 if (r == NULL)
11024 return FALSE;
11025 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11026 if (bfd_big_endian (info->output_bfd))
11027 r[0].r_offset += 2;
11028 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11029 r[0].r_offset += 4;
11030 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11031 r[0].r_addend = dest;
11032 if (PPC_HA (off) != 0)
11033 {
11034 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11035 r[1].r_offset = r[0].r_offset + 4;
11036 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11037 r[1].r_addend = r[0].r_addend;
11038 }
11039 }
11040
11041 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11042 {
11043 if (PPC_HA (off) != 0)
11044 {
11045 size = 16;
11046 bfd_put_32 (htab->params->stub_bfd,
11047 ADDIS_R12_R2 | PPC_HA (off), loc);
11048 loc += 4;
11049 bfd_put_32 (htab->params->stub_bfd,
11050 LD_R12_0R12 | PPC_LO (off), loc);
11051 }
11052 else
11053 {
11054 size = 12;
11055 bfd_put_32 (htab->params->stub_bfd,
11056 LD_R12_0R2 | PPC_LO (off), loc);
11057 }
11058 }
11059 else
11060 {
11061 bfd_vma r2off = get_r2off (info, stub_entry);
11062
11063 if (r2off == (bfd_vma) -1)
11064 {
11065 htab->stub_error = TRUE;
11066 return FALSE;
11067 }
11068
11069 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11070 loc += 4;
11071 size = 16;
11072 if (PPC_HA (off) != 0)
11073 {
11074 size += 4;
11075 bfd_put_32 (htab->params->stub_bfd,
11076 ADDIS_R12_R2 | PPC_HA (off), loc);
11077 loc += 4;
11078 bfd_put_32 (htab->params->stub_bfd,
11079 LD_R12_0R12 | PPC_LO (off), loc);
11080 }
11081 else
11082 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11083
11084 if (PPC_HA (r2off) != 0)
11085 {
11086 size += 4;
11087 loc += 4;
11088 bfd_put_32 (htab->params->stub_bfd,
11089 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11090 }
11091 if (PPC_LO (r2off) != 0)
11092 {
11093 size += 4;
11094 loc += 4;
11095 bfd_put_32 (htab->params->stub_bfd,
11096 ADDI_R2_R2 | PPC_LO (r2off), loc);
11097 }
11098 }
11099 loc += 4;
11100 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11101 loc += 4;
11102 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11103 break;
11104
11105 case ppc_stub_plt_call:
11106 case ppc_stub_plt_call_r2save:
11107 if (stub_entry->h != NULL
11108 && stub_entry->h->is_func_descriptor
11109 && stub_entry->h->oh != NULL)
11110 {
11111 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11112
11113 /* If the old-ABI "dot-symbol" is undefined make it weak so
11114 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11115 if (fh->elf.root.type == bfd_link_hash_undefined
11116 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11117 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11118 fh->elf.root.type = bfd_link_hash_undefweak;
11119 }
11120
11121 /* Now build the stub. */
11122 dest = stub_entry->plt_ent->plt.offset & ~1;
11123 if (dest >= (bfd_vma) -2)
11124 abort ();
11125
11126 plt = htab->elf.splt;
11127 if (!htab->elf.dynamic_sections_created
11128 || stub_entry->h == NULL
11129 || stub_entry->h->elf.dynindx == -1)
11130 plt = htab->elf.iplt;
11131
11132 dest += plt->output_offset + plt->output_section->vma;
11133
11134 if (stub_entry->h == NULL
11135 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11136 {
11137 Elf_Internal_Rela rela;
11138 bfd_byte *rl;
11139
11140 rela.r_offset = dest;
11141 if (htab->opd_abi)
11142 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11143 else
11144 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11145 rela.r_addend = (stub_entry->target_value
11146 + stub_entry->target_section->output_offset
11147 + stub_entry->target_section->output_section->vma);
11148
11149 rl = (htab->elf.irelplt->contents
11150 + (htab->elf.irelplt->reloc_count++
11151 * sizeof (Elf64_External_Rela)));
11152 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11153 stub_entry->plt_ent->plt.offset |= 1;
11154 }
11155
11156 off = (dest
11157 - elf_gp (plt->output_section->owner)
11158 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11159
11160 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11161 {
11162 info->callbacks->einfo
11163 /* xgettext:c-format */
11164 (_("%P: linkage table error against `%T'\n"),
11165 stub_entry->h != NULL
11166 ? stub_entry->h->elf.root.root.string
11167 : "<local sym>");
11168 bfd_set_error (bfd_error_bad_value);
11169 htab->stub_error = TRUE;
11170 return FALSE;
11171 }
11172
11173 if (htab->params->plt_stub_align != 0)
11174 {
11175 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11176
11177 stub_entry->group->stub_sec->size += pad;
11178 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11179 loc += pad;
11180 }
11181
11182 r = NULL;
11183 if (info->emitrelocations)
11184 {
11185 r = get_relocs (stub_entry->group->stub_sec,
11186 ((PPC_HA (off) != 0)
11187 + (htab->opd_abi
11188 ? 2 + (htab->params->plt_static_chain
11189 && PPC_HA (off + 16) == PPC_HA (off))
11190 : 1)));
11191 if (r == NULL)
11192 return FALSE;
11193 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11194 if (bfd_big_endian (info->output_bfd))
11195 r[0].r_offset += 2;
11196 r[0].r_addend = dest;
11197 }
11198 if (stub_entry->h != NULL
11199 && (stub_entry->h == htab->tls_get_addr_fd
11200 || stub_entry->h == htab->tls_get_addr)
11201 && htab->params->tls_get_addr_opt)
11202 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11203 else
11204 p = build_plt_stub (htab, stub_entry, loc, off, r);
11205 size = p - loc;
11206 break;
11207
11208 case ppc_stub_save_res:
11209 return TRUE;
11210
11211 default:
11212 BFD_FAIL ();
11213 return FALSE;
11214 }
11215
11216 stub_entry->group->stub_sec->size += size;
11217
11218 if (htab->params->emit_stub_syms)
11219 {
11220 struct elf_link_hash_entry *h;
11221 size_t len1, len2;
11222 char *name;
11223 const char *const stub_str[] = { "long_branch",
11224 "long_branch_r2off",
11225 "plt_branch",
11226 "plt_branch_r2off",
11227 "plt_call",
11228 "plt_call" };
11229
11230 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11231 len2 = strlen (stub_entry->root.string);
11232 name = bfd_malloc (len1 + len2 + 2);
11233 if (name == NULL)
11234 return FALSE;
11235 memcpy (name, stub_entry->root.string, 9);
11236 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11237 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11238 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11239 if (h == NULL)
11240 return FALSE;
11241 if (h->root.type == bfd_link_hash_new)
11242 {
11243 h->root.type = bfd_link_hash_defined;
11244 h->root.u.def.section = stub_entry->group->stub_sec;
11245 h->root.u.def.value = stub_entry->stub_offset;
11246 h->ref_regular = 1;
11247 h->def_regular = 1;
11248 h->ref_regular_nonweak = 1;
11249 h->forced_local = 1;
11250 h->non_elf = 0;
11251 h->root.linker_def = 1;
11252 }
11253 }
11254
11255 return TRUE;
11256 }
11257
11258 /* As above, but don't actually build the stub. Just bump offset so
11259 we know stub section sizes, and select plt_branch stubs where
11260 long_branch stubs won't do. */
11261
11262 static bfd_boolean
11263 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11264 {
11265 struct ppc_stub_hash_entry *stub_entry;
11266 struct bfd_link_info *info;
11267 struct ppc_link_hash_table *htab;
11268 bfd_vma off;
11269 int size;
11270
11271 /* Massage our args to the form they really have. */
11272 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11273 info = in_arg;
11274
11275 htab = ppc_hash_table (info);
11276 if (htab == NULL)
11277 return FALSE;
11278
11279 if (stub_entry->h != NULL
11280 && stub_entry->h->save_res
11281 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11282 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11283 {
11284 /* Don't make stubs to out-of-line register save/restore
11285 functions. Instead, emit copies of the functions. */
11286 stub_entry->group->needs_save_res = 1;
11287 stub_entry->stub_type = ppc_stub_save_res;
11288 return TRUE;
11289 }
11290
11291 if (stub_entry->stub_type == ppc_stub_plt_call
11292 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11293 {
11294 asection *plt;
11295 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11296 if (off >= (bfd_vma) -2)
11297 abort ();
11298 plt = htab->elf.splt;
11299 if (!htab->elf.dynamic_sections_created
11300 || stub_entry->h == NULL
11301 || stub_entry->h->elf.dynindx == -1)
11302 plt = htab->elf.iplt;
11303 off += (plt->output_offset
11304 + plt->output_section->vma
11305 - elf_gp (plt->output_section->owner)
11306 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11307
11308 size = plt_stub_size (htab, stub_entry, off);
11309 if (htab->params->plt_stub_align)
11310 size += plt_stub_pad (htab, stub_entry, off);
11311 if (info->emitrelocations)
11312 {
11313 stub_entry->group->stub_sec->reloc_count
11314 += ((PPC_HA (off) != 0)
11315 + (htab->opd_abi
11316 ? 2 + (htab->params->plt_static_chain
11317 && PPC_HA (off + 16) == PPC_HA (off))
11318 : 1));
11319 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11320 }
11321 }
11322 else
11323 {
11324 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11325 variants. */
11326 bfd_vma r2off = 0;
11327 bfd_vma local_off = 0;
11328
11329 off = (stub_entry->target_value
11330 + stub_entry->target_section->output_offset
11331 + stub_entry->target_section->output_section->vma);
11332 off -= (stub_entry->group->stub_sec->size
11333 + stub_entry->group->stub_sec->output_offset
11334 + stub_entry->group->stub_sec->output_section->vma);
11335
11336 /* Reset the stub type from the plt variant in case we now
11337 can reach with a shorter stub. */
11338 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11339 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11340
11341 size = 4;
11342 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11343 {
11344 r2off = get_r2off (info, stub_entry);
11345 if (r2off == (bfd_vma) -1)
11346 {
11347 htab->stub_error = TRUE;
11348 return FALSE;
11349 }
11350 size = 8;
11351 if (PPC_HA (r2off) != 0)
11352 size += 4;
11353 if (PPC_LO (r2off) != 0)
11354 size += 4;
11355 off -= size - 4;
11356 }
11357
11358 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11359
11360 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11361 Do the same for -R objects without function descriptors. */
11362 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11363 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11364 && r2off == 0
11365 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11366 {
11367 struct ppc_branch_hash_entry *br_entry;
11368
11369 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11370 stub_entry->root.string + 9,
11371 TRUE, FALSE);
11372 if (br_entry == NULL)
11373 {
11374 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11375 stub_entry->root.string);
11376 htab->stub_error = TRUE;
11377 return FALSE;
11378 }
11379
11380 if (br_entry->iter != htab->stub_iteration)
11381 {
11382 br_entry->iter = htab->stub_iteration;
11383 br_entry->offset = htab->brlt->size;
11384 htab->brlt->size += 8;
11385
11386 if (htab->relbrlt != NULL)
11387 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11388 else if (info->emitrelocations)
11389 {
11390 htab->brlt->reloc_count += 1;
11391 htab->brlt->flags |= SEC_RELOC;
11392 }
11393 }
11394
11395 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11396 off = (br_entry->offset
11397 + htab->brlt->output_offset
11398 + htab->brlt->output_section->vma
11399 - elf_gp (htab->brlt->output_section->owner)
11400 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11401
11402 if (info->emitrelocations)
11403 {
11404 stub_entry->group->stub_sec->reloc_count
11405 += 1 + (PPC_HA (off) != 0);
11406 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11407 }
11408
11409 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11410 {
11411 size = 12;
11412 if (PPC_HA (off) != 0)
11413 size = 16;
11414 }
11415 else
11416 {
11417 size = 16;
11418 if (PPC_HA (off) != 0)
11419 size += 4;
11420
11421 if (PPC_HA (r2off) != 0)
11422 size += 4;
11423 if (PPC_LO (r2off) != 0)
11424 size += 4;
11425 }
11426 }
11427 else if (info->emitrelocations)
11428 {
11429 stub_entry->group->stub_sec->reloc_count += 1;
11430 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11431 }
11432 }
11433
11434 stub_entry->group->stub_sec->size += size;
11435 return TRUE;
11436 }
11437
11438 /* Set up various things so that we can make a list of input sections
11439 for each output section included in the link. Returns -1 on error,
11440 0 when no stubs will be needed, and 1 on success. */
11441
11442 int
11443 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11444 {
11445 unsigned int id;
11446 bfd_size_type amt;
11447 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11448
11449 if (htab == NULL)
11450 return -1;
11451
11452 htab->sec_info_arr_size = bfd_get_next_section_id ();
11453 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11454 htab->sec_info = bfd_zmalloc (amt);
11455 if (htab->sec_info == NULL)
11456 return -1;
11457
11458 /* Set toc_off for com, und, abs and ind sections. */
11459 for (id = 0; id < 3; id++)
11460 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11461
11462 return 1;
11463 }
11464
11465 /* Set up for first pass at multitoc partitioning. */
11466
11467 void
11468 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11469 {
11470 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11471
11472 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11473 htab->toc_bfd = NULL;
11474 htab->toc_first_sec = NULL;
11475 }
11476
11477 /* The linker repeatedly calls this function for each TOC input section
11478 and linker generated GOT section. Group input bfds such that the toc
11479 within a group is less than 64k in size. */
11480
11481 bfd_boolean
11482 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11483 {
11484 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11485 bfd_vma addr, off, limit;
11486
11487 if (htab == NULL)
11488 return FALSE;
11489
11490 if (!htab->second_toc_pass)
11491 {
11492 /* Keep track of the first .toc or .got section for this input bfd. */
11493 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11494
11495 if (new_bfd)
11496 {
11497 htab->toc_bfd = isec->owner;
11498 htab->toc_first_sec = isec;
11499 }
11500
11501 addr = isec->output_offset + isec->output_section->vma;
11502 off = addr - htab->toc_curr;
11503 limit = 0x80008000;
11504 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11505 limit = 0x10000;
11506 if (off + isec->size > limit)
11507 {
11508 addr = (htab->toc_first_sec->output_offset
11509 + htab->toc_first_sec->output_section->vma);
11510 htab->toc_curr = addr;
11511 htab->toc_curr &= -TOC_BASE_ALIGN;
11512 }
11513
11514 /* toc_curr is the base address of this toc group. Set elf_gp
11515 for the input section to be the offset relative to the
11516 output toc base plus 0x8000. Making the input elf_gp an
11517 offset allows us to move the toc as a whole without
11518 recalculating input elf_gp. */
11519 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11520 off += TOC_BASE_OFF;
11521
11522 /* Die if someone uses a linker script that doesn't keep input
11523 file .toc and .got together. */
11524 if (new_bfd
11525 && elf_gp (isec->owner) != 0
11526 && elf_gp (isec->owner) != off)
11527 return FALSE;
11528
11529 elf_gp (isec->owner) = off;
11530 return TRUE;
11531 }
11532
11533 /* During the second pass toc_first_sec points to the start of
11534 a toc group, and toc_curr is used to track the old elf_gp.
11535 We use toc_bfd to ensure we only look at each bfd once. */
11536 if (htab->toc_bfd == isec->owner)
11537 return TRUE;
11538 htab->toc_bfd = isec->owner;
11539
11540 if (htab->toc_first_sec == NULL
11541 || htab->toc_curr != elf_gp (isec->owner))
11542 {
11543 htab->toc_curr = elf_gp (isec->owner);
11544 htab->toc_first_sec = isec;
11545 }
11546 addr = (htab->toc_first_sec->output_offset
11547 + htab->toc_first_sec->output_section->vma);
11548 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11549 elf_gp (isec->owner) = off;
11550
11551 return TRUE;
11552 }
11553
11554 /* Called via elf_link_hash_traverse to merge GOT entries for global
11555 symbol H. */
11556
11557 static bfd_boolean
11558 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11559 {
11560 if (h->root.type == bfd_link_hash_indirect)
11561 return TRUE;
11562
11563 merge_got_entries (&h->got.glist);
11564
11565 return TRUE;
11566 }
11567
11568 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11569 symbol H. */
11570
11571 static bfd_boolean
11572 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11573 {
11574 struct got_entry *gent;
11575
11576 if (h->root.type == bfd_link_hash_indirect)
11577 return TRUE;
11578
11579 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11580 if (!gent->is_indirect)
11581 allocate_got (h, (struct bfd_link_info *) inf, gent);
11582 return TRUE;
11583 }
11584
11585 /* Called on the first multitoc pass after the last call to
11586 ppc64_elf_next_toc_section. This function removes duplicate GOT
11587 entries. */
11588
11589 bfd_boolean
11590 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11591 {
11592 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11593 struct bfd *ibfd, *ibfd2;
11594 bfd_boolean done_something;
11595
11596 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11597
11598 if (!htab->do_multi_toc)
11599 return FALSE;
11600
11601 /* Merge global sym got entries within a toc group. */
11602 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11603
11604 /* And tlsld_got. */
11605 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11606 {
11607 struct got_entry *ent, *ent2;
11608
11609 if (!is_ppc64_elf (ibfd))
11610 continue;
11611
11612 ent = ppc64_tlsld_got (ibfd);
11613 if (!ent->is_indirect
11614 && ent->got.offset != (bfd_vma) -1)
11615 {
11616 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11617 {
11618 if (!is_ppc64_elf (ibfd2))
11619 continue;
11620
11621 ent2 = ppc64_tlsld_got (ibfd2);
11622 if (!ent2->is_indirect
11623 && ent2->got.offset != (bfd_vma) -1
11624 && elf_gp (ibfd2) == elf_gp (ibfd))
11625 {
11626 ent2->is_indirect = TRUE;
11627 ent2->got.ent = ent;
11628 }
11629 }
11630 }
11631 }
11632
11633 /* Zap sizes of got sections. */
11634 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11635 htab->elf.irelplt->size -= htab->got_reli_size;
11636 htab->got_reli_size = 0;
11637
11638 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11639 {
11640 asection *got, *relgot;
11641
11642 if (!is_ppc64_elf (ibfd))
11643 continue;
11644
11645 got = ppc64_elf_tdata (ibfd)->got;
11646 if (got != NULL)
11647 {
11648 got->rawsize = got->size;
11649 got->size = 0;
11650 relgot = ppc64_elf_tdata (ibfd)->relgot;
11651 relgot->rawsize = relgot->size;
11652 relgot->size = 0;
11653 }
11654 }
11655
11656 /* Now reallocate the got, local syms first. We don't need to
11657 allocate section contents again since we never increase size. */
11658 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11659 {
11660 struct got_entry **lgot_ents;
11661 struct got_entry **end_lgot_ents;
11662 struct plt_entry **local_plt;
11663 struct plt_entry **end_local_plt;
11664 unsigned char *lgot_masks;
11665 bfd_size_type locsymcount;
11666 Elf_Internal_Shdr *symtab_hdr;
11667 asection *s;
11668
11669 if (!is_ppc64_elf (ibfd))
11670 continue;
11671
11672 lgot_ents = elf_local_got_ents (ibfd);
11673 if (!lgot_ents)
11674 continue;
11675
11676 symtab_hdr = &elf_symtab_hdr (ibfd);
11677 locsymcount = symtab_hdr->sh_info;
11678 end_lgot_ents = lgot_ents + locsymcount;
11679 local_plt = (struct plt_entry **) end_lgot_ents;
11680 end_local_plt = local_plt + locsymcount;
11681 lgot_masks = (unsigned char *) end_local_plt;
11682 s = ppc64_elf_tdata (ibfd)->got;
11683 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11684 {
11685 struct got_entry *ent;
11686
11687 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11688 {
11689 unsigned int ent_size = 8;
11690 unsigned int rel_size = sizeof (Elf64_External_Rela);
11691
11692 ent->got.offset = s->size;
11693 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11694 {
11695 ent_size *= 2;
11696 rel_size *= 2;
11697 }
11698 s->size += ent_size;
11699 if ((*lgot_masks & PLT_IFUNC) != 0)
11700 {
11701 htab->elf.irelplt->size += rel_size;
11702 htab->got_reli_size += rel_size;
11703 }
11704 else if (bfd_link_pic (info))
11705 {
11706 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11707 srel->size += rel_size;
11708 }
11709 }
11710 }
11711 }
11712
11713 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11714
11715 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11716 {
11717 struct got_entry *ent;
11718
11719 if (!is_ppc64_elf (ibfd))
11720 continue;
11721
11722 ent = ppc64_tlsld_got (ibfd);
11723 if (!ent->is_indirect
11724 && ent->got.offset != (bfd_vma) -1)
11725 {
11726 asection *s = ppc64_elf_tdata (ibfd)->got;
11727 ent->got.offset = s->size;
11728 s->size += 16;
11729 if (bfd_link_pic (info))
11730 {
11731 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11732 srel->size += sizeof (Elf64_External_Rela);
11733 }
11734 }
11735 }
11736
11737 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11738 if (!done_something)
11739 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11740 {
11741 asection *got;
11742
11743 if (!is_ppc64_elf (ibfd))
11744 continue;
11745
11746 got = ppc64_elf_tdata (ibfd)->got;
11747 if (got != NULL)
11748 {
11749 done_something = got->rawsize != got->size;
11750 if (done_something)
11751 break;
11752 }
11753 }
11754
11755 if (done_something)
11756 (*htab->params->layout_sections_again) ();
11757
11758 /* Set up for second pass over toc sections to recalculate elf_gp
11759 on input sections. */
11760 htab->toc_bfd = NULL;
11761 htab->toc_first_sec = NULL;
11762 htab->second_toc_pass = TRUE;
11763 return done_something;
11764 }
11765
11766 /* Called after second pass of multitoc partitioning. */
11767
11768 void
11769 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11770 {
11771 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11772
11773 /* After the second pass, toc_curr tracks the TOC offset used
11774 for code sections below in ppc64_elf_next_input_section. */
11775 htab->toc_curr = TOC_BASE_OFF;
11776 }
11777
11778 /* No toc references were found in ISEC. If the code in ISEC makes no
11779 calls, then there's no need to use toc adjusting stubs when branching
11780 into ISEC. Actually, indirect calls from ISEC are OK as they will
11781 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11782 needed, and 2 if a cyclical call-graph was found but no other reason
11783 for a stub was detected. If called from the top level, a return of
11784 2 means the same as a return of 0. */
11785
11786 static int
11787 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11788 {
11789 int ret;
11790
11791 /* Mark this section as checked. */
11792 isec->call_check_done = 1;
11793
11794 /* We know none of our code bearing sections will need toc stubs. */
11795 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11796 return 0;
11797
11798 if (isec->size == 0)
11799 return 0;
11800
11801 if (isec->output_section == NULL)
11802 return 0;
11803
11804 ret = 0;
11805 if (isec->reloc_count != 0)
11806 {
11807 Elf_Internal_Rela *relstart, *rel;
11808 Elf_Internal_Sym *local_syms;
11809 struct ppc_link_hash_table *htab;
11810
11811 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11812 info->keep_memory);
11813 if (relstart == NULL)
11814 return -1;
11815
11816 /* Look for branches to outside of this section. */
11817 local_syms = NULL;
11818 htab = ppc_hash_table (info);
11819 if (htab == NULL)
11820 return -1;
11821
11822 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11823 {
11824 enum elf_ppc64_reloc_type r_type;
11825 unsigned long r_symndx;
11826 struct elf_link_hash_entry *h;
11827 struct ppc_link_hash_entry *eh;
11828 Elf_Internal_Sym *sym;
11829 asection *sym_sec;
11830 struct _opd_sec_data *opd;
11831 bfd_vma sym_value;
11832 bfd_vma dest;
11833
11834 r_type = ELF64_R_TYPE (rel->r_info);
11835 if (r_type != R_PPC64_REL24
11836 && r_type != R_PPC64_REL14
11837 && r_type != R_PPC64_REL14_BRTAKEN
11838 && r_type != R_PPC64_REL14_BRNTAKEN)
11839 continue;
11840
11841 r_symndx = ELF64_R_SYM (rel->r_info);
11842 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11843 isec->owner))
11844 {
11845 ret = -1;
11846 break;
11847 }
11848
11849 /* Calls to dynamic lib functions go through a plt call stub
11850 that uses r2. */
11851 eh = (struct ppc_link_hash_entry *) h;
11852 if (eh != NULL
11853 && (eh->elf.plt.plist != NULL
11854 || (eh->oh != NULL
11855 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11856 {
11857 ret = 1;
11858 break;
11859 }
11860
11861 if (sym_sec == NULL)
11862 /* Ignore other undefined symbols. */
11863 continue;
11864
11865 /* Assume branches to other sections not included in the
11866 link need stubs too, to cover -R and absolute syms. */
11867 if (sym_sec->output_section == NULL)
11868 {
11869 ret = 1;
11870 break;
11871 }
11872
11873 if (h == NULL)
11874 sym_value = sym->st_value;
11875 else
11876 {
11877 if (h->root.type != bfd_link_hash_defined
11878 && h->root.type != bfd_link_hash_defweak)
11879 abort ();
11880 sym_value = h->root.u.def.value;
11881 }
11882 sym_value += rel->r_addend;
11883
11884 /* If this branch reloc uses an opd sym, find the code section. */
11885 opd = get_opd_info (sym_sec);
11886 if (opd != NULL)
11887 {
11888 if (h == NULL && opd->adjust != NULL)
11889 {
11890 long adjust;
11891
11892 adjust = opd->adjust[OPD_NDX (sym_value)];
11893 if (adjust == -1)
11894 /* Assume deleted functions won't ever be called. */
11895 continue;
11896 sym_value += adjust;
11897 }
11898
11899 dest = opd_entry_value (sym_sec, sym_value,
11900 &sym_sec, NULL, FALSE);
11901 if (dest == (bfd_vma) -1)
11902 continue;
11903 }
11904 else
11905 dest = (sym_value
11906 + sym_sec->output_offset
11907 + sym_sec->output_section->vma);
11908
11909 /* Ignore branch to self. */
11910 if (sym_sec == isec)
11911 continue;
11912
11913 /* If the called function uses the toc, we need a stub. */
11914 if (sym_sec->has_toc_reloc
11915 || sym_sec->makes_toc_func_call)
11916 {
11917 ret = 1;
11918 break;
11919 }
11920
11921 /* Assume any branch that needs a long branch stub might in fact
11922 need a plt_branch stub. A plt_branch stub uses r2. */
11923 else if (dest - (isec->output_offset
11924 + isec->output_section->vma
11925 + rel->r_offset) + (1 << 25)
11926 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11927 ? h->other
11928 : sym->st_other))
11929 {
11930 ret = 1;
11931 break;
11932 }
11933
11934 /* If calling back to a section in the process of being
11935 tested, we can't say for sure that no toc adjusting stubs
11936 are needed, so don't return zero. */
11937 else if (sym_sec->call_check_in_progress)
11938 ret = 2;
11939
11940 /* Branches to another section that itself doesn't have any TOC
11941 references are OK. Recursively call ourselves to check. */
11942 else if (!sym_sec->call_check_done)
11943 {
11944 int recur;
11945
11946 /* Mark current section as indeterminate, so that other
11947 sections that call back to current won't be marked as
11948 known. */
11949 isec->call_check_in_progress = 1;
11950 recur = toc_adjusting_stub_needed (info, sym_sec);
11951 isec->call_check_in_progress = 0;
11952
11953 if (recur != 0)
11954 {
11955 ret = recur;
11956 if (recur != 2)
11957 break;
11958 }
11959 }
11960 }
11961
11962 if (local_syms != NULL
11963 && (elf_symtab_hdr (isec->owner).contents
11964 != (unsigned char *) local_syms))
11965 free (local_syms);
11966 if (elf_section_data (isec)->relocs != relstart)
11967 free (relstart);
11968 }
11969
11970 if ((ret & 1) == 0
11971 && isec->map_head.s != NULL
11972 && (strcmp (isec->output_section->name, ".init") == 0
11973 || strcmp (isec->output_section->name, ".fini") == 0))
11974 {
11975 if (isec->map_head.s->has_toc_reloc
11976 || isec->map_head.s->makes_toc_func_call)
11977 ret = 1;
11978 else if (!isec->map_head.s->call_check_done)
11979 {
11980 int recur;
11981 isec->call_check_in_progress = 1;
11982 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11983 isec->call_check_in_progress = 0;
11984 if (recur != 0)
11985 ret = recur;
11986 }
11987 }
11988
11989 if (ret == 1)
11990 isec->makes_toc_func_call = 1;
11991
11992 return ret;
11993 }
11994
11995 /* The linker repeatedly calls this function for each input section,
11996 in the order that input sections are linked into output sections.
11997 Build lists of input sections to determine groupings between which
11998 we may insert linker stubs. */
11999
12000 bfd_boolean
12001 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12002 {
12003 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12004
12005 if (htab == NULL)
12006 return FALSE;
12007
12008 if ((isec->output_section->flags & SEC_CODE) != 0
12009 && isec->output_section->id < htab->sec_info_arr_size)
12010 {
12011 /* This happens to make the list in reverse order,
12012 which is what we want. */
12013 htab->sec_info[isec->id].u.list
12014 = htab->sec_info[isec->output_section->id].u.list;
12015 htab->sec_info[isec->output_section->id].u.list = isec;
12016 }
12017
12018 if (htab->multi_toc_needed)
12019 {
12020 /* Analyse sections that aren't already flagged as needing a
12021 valid toc pointer. Exclude .fixup for the linux kernel.
12022 .fixup contains branches, but only back to the function that
12023 hit an exception. */
12024 if (!(isec->has_toc_reloc
12025 || (isec->flags & SEC_CODE) == 0
12026 || strcmp (isec->name, ".fixup") == 0
12027 || isec->call_check_done))
12028 {
12029 if (toc_adjusting_stub_needed (info, isec) < 0)
12030 return FALSE;
12031 }
12032 /* Make all sections use the TOC assigned for this object file.
12033 This will be wrong for pasted sections; We fix that in
12034 check_pasted_section(). */
12035 if (elf_gp (isec->owner) != 0)
12036 htab->toc_curr = elf_gp (isec->owner);
12037 }
12038
12039 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12040 return TRUE;
12041 }
12042
12043 /* Check that all .init and .fini sections use the same toc, if they
12044 have toc relocs. */
12045
12046 static bfd_boolean
12047 check_pasted_section (struct bfd_link_info *info, const char *name)
12048 {
12049 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12050
12051 if (o != NULL)
12052 {
12053 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12054 bfd_vma toc_off = 0;
12055 asection *i;
12056
12057 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12058 if (i->has_toc_reloc)
12059 {
12060 if (toc_off == 0)
12061 toc_off = htab->sec_info[i->id].toc_off;
12062 else if (toc_off != htab->sec_info[i->id].toc_off)
12063 return FALSE;
12064 }
12065
12066 if (toc_off == 0)
12067 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12068 if (i->makes_toc_func_call)
12069 {
12070 toc_off = htab->sec_info[i->id].toc_off;
12071 break;
12072 }
12073
12074 /* Make sure the whole pasted function uses the same toc offset. */
12075 if (toc_off != 0)
12076 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12077 htab->sec_info[i->id].toc_off = toc_off;
12078 }
12079 return TRUE;
12080 }
12081
12082 bfd_boolean
12083 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12084 {
12085 return (check_pasted_section (info, ".init")
12086 & check_pasted_section (info, ".fini"));
12087 }
12088
12089 /* See whether we can group stub sections together. Grouping stub
12090 sections may result in fewer stubs. More importantly, we need to
12091 put all .init* and .fini* stubs at the beginning of the .init or
12092 .fini output sections respectively, because glibc splits the
12093 _init and _fini functions into multiple parts. Putting a stub in
12094 the middle of a function is not a good idea. */
12095
12096 static bfd_boolean
12097 group_sections (struct bfd_link_info *info,
12098 bfd_size_type stub_group_size,
12099 bfd_boolean stubs_always_before_branch)
12100 {
12101 struct ppc_link_hash_table *htab;
12102 asection *osec;
12103 bfd_boolean suppress_size_errors;
12104
12105 htab = ppc_hash_table (info);
12106 if (htab == NULL)
12107 return FALSE;
12108
12109 suppress_size_errors = FALSE;
12110 if (stub_group_size == 1)
12111 {
12112 /* Default values. */
12113 if (stubs_always_before_branch)
12114 stub_group_size = 0x1e00000;
12115 else
12116 stub_group_size = 0x1c00000;
12117 suppress_size_errors = TRUE;
12118 }
12119
12120 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12121 {
12122 asection *tail;
12123
12124 if (osec->id >= htab->sec_info_arr_size)
12125 continue;
12126
12127 tail = htab->sec_info[osec->id].u.list;
12128 while (tail != NULL)
12129 {
12130 asection *curr;
12131 asection *prev;
12132 bfd_size_type total;
12133 bfd_boolean big_sec;
12134 bfd_vma curr_toc;
12135 struct map_stub *group;
12136 bfd_size_type group_size;
12137
12138 curr = tail;
12139 total = tail->size;
12140 group_size = (ppc64_elf_section_data (tail) != NULL
12141 && ppc64_elf_section_data (tail)->has_14bit_branch
12142 ? stub_group_size >> 10 : stub_group_size);
12143
12144 big_sec = total > group_size;
12145 if (big_sec && !suppress_size_errors)
12146 /* xgettext:c-format */
12147 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12148 tail->owner, tail);
12149 curr_toc = htab->sec_info[tail->id].toc_off;
12150
12151 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12152 && ((total += curr->output_offset - prev->output_offset)
12153 < (ppc64_elf_section_data (prev) != NULL
12154 && ppc64_elf_section_data (prev)->has_14bit_branch
12155 ? (group_size = stub_group_size >> 10) : group_size))
12156 && htab->sec_info[prev->id].toc_off == curr_toc)
12157 curr = prev;
12158
12159 /* OK, the size from the start of CURR to the end is less
12160 than group_size and thus can be handled by one stub
12161 section. (or the tail section is itself larger than
12162 group_size, in which case we may be toast.) We should
12163 really be keeping track of the total size of stubs added
12164 here, as stubs contribute to the final output section
12165 size. That's a little tricky, and this way will only
12166 break if stubs added make the total size more than 2^25,
12167 ie. for the default stub_group_size, if stubs total more
12168 than 2097152 bytes, or nearly 75000 plt call stubs. */
12169 group = bfd_alloc (curr->owner, sizeof (*group));
12170 if (group == NULL)
12171 return FALSE;
12172 group->link_sec = curr;
12173 group->stub_sec = NULL;
12174 group->needs_save_res = 0;
12175 group->next = htab->group;
12176 htab->group = group;
12177 do
12178 {
12179 prev = htab->sec_info[tail->id].u.list;
12180 /* Set up this stub group. */
12181 htab->sec_info[tail->id].u.group = group;
12182 }
12183 while (tail != curr && (tail = prev) != NULL);
12184
12185 /* But wait, there's more! Input sections up to group_size
12186 bytes before the stub section can be handled by it too.
12187 Don't do this if we have a really large section after the
12188 stubs, as adding more stubs increases the chance that
12189 branches may not reach into the stub section. */
12190 if (!stubs_always_before_branch && !big_sec)
12191 {
12192 total = 0;
12193 while (prev != NULL
12194 && ((total += tail->output_offset - prev->output_offset)
12195 < (ppc64_elf_section_data (prev) != NULL
12196 && ppc64_elf_section_data (prev)->has_14bit_branch
12197 ? (group_size = stub_group_size >> 10) : group_size))
12198 && htab->sec_info[prev->id].toc_off == curr_toc)
12199 {
12200 tail = prev;
12201 prev = htab->sec_info[tail->id].u.list;
12202 htab->sec_info[tail->id].u.group = group;
12203 }
12204 }
12205 tail = prev;
12206 }
12207 }
12208 return TRUE;
12209 }
12210
12211 static const unsigned char glink_eh_frame_cie[] =
12212 {
12213 0, 0, 0, 16, /* length. */
12214 0, 0, 0, 0, /* id. */
12215 1, /* CIE version. */
12216 'z', 'R', 0, /* Augmentation string. */
12217 4, /* Code alignment. */
12218 0x78, /* Data alignment. */
12219 65, /* RA reg. */
12220 1, /* Augmentation size. */
12221 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12222 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12223 0, 0, 0, 0
12224 };
12225
12226 /* Stripping output sections is normally done before dynamic section
12227 symbols have been allocated. This function is called later, and
12228 handles cases like htab->brlt which is mapped to its own output
12229 section. */
12230
12231 static void
12232 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12233 {
12234 if (isec->size == 0
12235 && isec->output_section->size == 0
12236 && !(isec->output_section->flags & SEC_KEEP)
12237 && !bfd_section_removed_from_list (info->output_bfd,
12238 isec->output_section)
12239 && elf_section_data (isec->output_section)->dynindx == 0)
12240 {
12241 isec->output_section->flags |= SEC_EXCLUDE;
12242 bfd_section_list_remove (info->output_bfd, isec->output_section);
12243 info->output_bfd->section_count--;
12244 }
12245 }
12246
12247 /* Determine and set the size of the stub section for a final link.
12248
12249 The basic idea here is to examine all the relocations looking for
12250 PC-relative calls to a target that is unreachable with a "bl"
12251 instruction. */
12252
12253 bfd_boolean
12254 ppc64_elf_size_stubs (struct bfd_link_info *info)
12255 {
12256 bfd_size_type stub_group_size;
12257 bfd_boolean stubs_always_before_branch;
12258 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12259
12260 if (htab == NULL)
12261 return FALSE;
12262
12263 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12264 htab->params->plt_thread_safe = 1;
12265 if (!htab->opd_abi)
12266 htab->params->plt_thread_safe = 0;
12267 else if (htab->params->plt_thread_safe == -1)
12268 {
12269 static const char *const thread_starter[] =
12270 {
12271 "pthread_create",
12272 /* libstdc++ */
12273 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12274 /* librt */
12275 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12276 "mq_notify", "create_timer",
12277 /* libanl */
12278 "getaddrinfo_a",
12279 /* libgomp */
12280 "GOMP_parallel",
12281 "GOMP_parallel_start",
12282 "GOMP_parallel_loop_static",
12283 "GOMP_parallel_loop_static_start",
12284 "GOMP_parallel_loop_dynamic",
12285 "GOMP_parallel_loop_dynamic_start",
12286 "GOMP_parallel_loop_guided",
12287 "GOMP_parallel_loop_guided_start",
12288 "GOMP_parallel_loop_runtime",
12289 "GOMP_parallel_loop_runtime_start",
12290 "GOMP_parallel_sections",
12291 "GOMP_parallel_sections_start",
12292 /* libgo */
12293 "__go_go",
12294 };
12295 unsigned i;
12296
12297 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12298 {
12299 struct elf_link_hash_entry *h;
12300 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12301 FALSE, FALSE, TRUE);
12302 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12303 if (htab->params->plt_thread_safe)
12304 break;
12305 }
12306 }
12307 stubs_always_before_branch = htab->params->group_size < 0;
12308 if (htab->params->group_size < 0)
12309 stub_group_size = -htab->params->group_size;
12310 else
12311 stub_group_size = htab->params->group_size;
12312
12313 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12314 return FALSE;
12315
12316 #define STUB_SHRINK_ITER 20
12317 /* Loop until no stubs added. After iteration 20 of this loop we may
12318 exit on a stub section shrinking. This is to break out of a
12319 pathological case where adding stubs on one iteration decreases
12320 section gaps (perhaps due to alignment), which then requires
12321 fewer or smaller stubs on the next iteration. */
12322
12323 while (1)
12324 {
12325 bfd *input_bfd;
12326 unsigned int bfd_indx;
12327 struct map_stub *group;
12328 asection *stub_sec;
12329
12330 htab->stub_iteration += 1;
12331
12332 for (input_bfd = info->input_bfds, bfd_indx = 0;
12333 input_bfd != NULL;
12334 input_bfd = input_bfd->link.next, bfd_indx++)
12335 {
12336 Elf_Internal_Shdr *symtab_hdr;
12337 asection *section;
12338 Elf_Internal_Sym *local_syms = NULL;
12339
12340 if (!is_ppc64_elf (input_bfd))
12341 continue;
12342
12343 /* We'll need the symbol table in a second. */
12344 symtab_hdr = &elf_symtab_hdr (input_bfd);
12345 if (symtab_hdr->sh_info == 0)
12346 continue;
12347
12348 /* Walk over each section attached to the input bfd. */
12349 for (section = input_bfd->sections;
12350 section != NULL;
12351 section = section->next)
12352 {
12353 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12354
12355 /* If there aren't any relocs, then there's nothing more
12356 to do. */
12357 if ((section->flags & SEC_RELOC) == 0
12358 || (section->flags & SEC_ALLOC) == 0
12359 || (section->flags & SEC_LOAD) == 0
12360 || (section->flags & SEC_CODE) == 0
12361 || section->reloc_count == 0)
12362 continue;
12363
12364 /* If this section is a link-once section that will be
12365 discarded, then don't create any stubs. */
12366 if (section->output_section == NULL
12367 || section->output_section->owner != info->output_bfd)
12368 continue;
12369
12370 /* Get the relocs. */
12371 internal_relocs
12372 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12373 info->keep_memory);
12374 if (internal_relocs == NULL)
12375 goto error_ret_free_local;
12376
12377 /* Now examine each relocation. */
12378 irela = internal_relocs;
12379 irelaend = irela + section->reloc_count;
12380 for (; irela < irelaend; irela++)
12381 {
12382 enum elf_ppc64_reloc_type r_type;
12383 unsigned int r_indx;
12384 enum ppc_stub_type stub_type;
12385 struct ppc_stub_hash_entry *stub_entry;
12386 asection *sym_sec, *code_sec;
12387 bfd_vma sym_value, code_value;
12388 bfd_vma destination;
12389 unsigned long local_off;
12390 bfd_boolean ok_dest;
12391 struct ppc_link_hash_entry *hash;
12392 struct ppc_link_hash_entry *fdh;
12393 struct elf_link_hash_entry *h;
12394 Elf_Internal_Sym *sym;
12395 char *stub_name;
12396 const asection *id_sec;
12397 struct _opd_sec_data *opd;
12398 struct plt_entry *plt_ent;
12399
12400 r_type = ELF64_R_TYPE (irela->r_info);
12401 r_indx = ELF64_R_SYM (irela->r_info);
12402
12403 if (r_type >= R_PPC64_max)
12404 {
12405 bfd_set_error (bfd_error_bad_value);
12406 goto error_ret_free_internal;
12407 }
12408
12409 /* Only look for stubs on branch instructions. */
12410 if (r_type != R_PPC64_REL24
12411 && r_type != R_PPC64_REL14
12412 && r_type != R_PPC64_REL14_BRTAKEN
12413 && r_type != R_PPC64_REL14_BRNTAKEN)
12414 continue;
12415
12416 /* Now determine the call target, its name, value,
12417 section. */
12418 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12419 r_indx, input_bfd))
12420 goto error_ret_free_internal;
12421 hash = (struct ppc_link_hash_entry *) h;
12422
12423 ok_dest = FALSE;
12424 fdh = NULL;
12425 sym_value = 0;
12426 if (hash == NULL)
12427 {
12428 sym_value = sym->st_value;
12429 if (sym_sec != NULL
12430 && sym_sec->output_section != NULL)
12431 ok_dest = TRUE;
12432 }
12433 else if (hash->elf.root.type == bfd_link_hash_defined
12434 || hash->elf.root.type == bfd_link_hash_defweak)
12435 {
12436 sym_value = hash->elf.root.u.def.value;
12437 if (sym_sec->output_section != NULL)
12438 ok_dest = TRUE;
12439 }
12440 else if (hash->elf.root.type == bfd_link_hash_undefweak
12441 || hash->elf.root.type == bfd_link_hash_undefined)
12442 {
12443 /* Recognise an old ABI func code entry sym, and
12444 use the func descriptor sym instead if it is
12445 defined. */
12446 if (hash->elf.root.root.string[0] == '.'
12447 && hash->oh != NULL)
12448 {
12449 fdh = ppc_follow_link (hash->oh);
12450 if (fdh->elf.root.type == bfd_link_hash_defined
12451 || fdh->elf.root.type == bfd_link_hash_defweak)
12452 {
12453 sym_sec = fdh->elf.root.u.def.section;
12454 sym_value = fdh->elf.root.u.def.value;
12455 if (sym_sec->output_section != NULL)
12456 ok_dest = TRUE;
12457 }
12458 else
12459 fdh = NULL;
12460 }
12461 }
12462 else
12463 {
12464 bfd_set_error (bfd_error_bad_value);
12465 goto error_ret_free_internal;
12466 }
12467
12468 destination = 0;
12469 local_off = 0;
12470 if (ok_dest)
12471 {
12472 sym_value += irela->r_addend;
12473 destination = (sym_value
12474 + sym_sec->output_offset
12475 + sym_sec->output_section->vma);
12476 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12477 ? hash->elf.other
12478 : sym->st_other);
12479 }
12480
12481 code_sec = sym_sec;
12482 code_value = sym_value;
12483 opd = get_opd_info (sym_sec);
12484 if (opd != NULL)
12485 {
12486 bfd_vma dest;
12487
12488 if (hash == NULL && opd->adjust != NULL)
12489 {
12490 long adjust = opd->adjust[OPD_NDX (sym_value)];
12491 if (adjust == -1)
12492 continue;
12493 code_value += adjust;
12494 sym_value += adjust;
12495 }
12496 dest = opd_entry_value (sym_sec, sym_value,
12497 &code_sec, &code_value, FALSE);
12498 if (dest != (bfd_vma) -1)
12499 {
12500 destination = dest;
12501 if (fdh != NULL)
12502 {
12503 /* Fixup old ABI sym to point at code
12504 entry. */
12505 hash->elf.root.type = bfd_link_hash_defweak;
12506 hash->elf.root.u.def.section = code_sec;
12507 hash->elf.root.u.def.value = code_value;
12508 }
12509 }
12510 }
12511
12512 /* Determine what (if any) linker stub is needed. */
12513 plt_ent = NULL;
12514 stub_type = ppc_type_of_stub (section, irela, &hash,
12515 &plt_ent, destination,
12516 local_off);
12517
12518 if (stub_type != ppc_stub_plt_call)
12519 {
12520 /* Check whether we need a TOC adjusting stub.
12521 Since the linker pastes together pieces from
12522 different object files when creating the
12523 _init and _fini functions, it may be that a
12524 call to what looks like a local sym is in
12525 fact a call needing a TOC adjustment. */
12526 if (code_sec != NULL
12527 && code_sec->output_section != NULL
12528 && (htab->sec_info[code_sec->id].toc_off
12529 != htab->sec_info[section->id].toc_off)
12530 && (code_sec->has_toc_reloc
12531 || code_sec->makes_toc_func_call))
12532 stub_type = ppc_stub_long_branch_r2off;
12533 }
12534
12535 if (stub_type == ppc_stub_none)
12536 continue;
12537
12538 /* __tls_get_addr calls might be eliminated. */
12539 if (stub_type != ppc_stub_plt_call
12540 && hash != NULL
12541 && (hash == htab->tls_get_addr
12542 || hash == htab->tls_get_addr_fd)
12543 && section->has_tls_reloc
12544 && irela != internal_relocs)
12545 {
12546 /* Get tls info. */
12547 unsigned char *tls_mask;
12548
12549 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12550 irela - 1, input_bfd))
12551 goto error_ret_free_internal;
12552 if (*tls_mask != 0)
12553 continue;
12554 }
12555
12556 if (stub_type == ppc_stub_plt_call
12557 && irela + 1 < irelaend
12558 && irela[1].r_offset == irela->r_offset + 4
12559 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12560 {
12561 if (!tocsave_find (htab, INSERT,
12562 &local_syms, irela + 1, input_bfd))
12563 goto error_ret_free_internal;
12564 }
12565 else if (stub_type == ppc_stub_plt_call)
12566 stub_type = ppc_stub_plt_call_r2save;
12567
12568 /* Support for grouping stub sections. */
12569 id_sec = htab->sec_info[section->id].u.group->link_sec;
12570
12571 /* Get the name of this stub. */
12572 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12573 if (!stub_name)
12574 goto error_ret_free_internal;
12575
12576 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12577 stub_name, FALSE, FALSE);
12578 if (stub_entry != NULL)
12579 {
12580 /* The proper stub has already been created. */
12581 free (stub_name);
12582 if (stub_type == ppc_stub_plt_call_r2save)
12583 stub_entry->stub_type = stub_type;
12584 continue;
12585 }
12586
12587 stub_entry = ppc_add_stub (stub_name, section, info);
12588 if (stub_entry == NULL)
12589 {
12590 free (stub_name);
12591 error_ret_free_internal:
12592 if (elf_section_data (section)->relocs == NULL)
12593 free (internal_relocs);
12594 error_ret_free_local:
12595 if (local_syms != NULL
12596 && (symtab_hdr->contents
12597 != (unsigned char *) local_syms))
12598 free (local_syms);
12599 return FALSE;
12600 }
12601
12602 stub_entry->stub_type = stub_type;
12603 if (stub_type != ppc_stub_plt_call
12604 && stub_type != ppc_stub_plt_call_r2save)
12605 {
12606 stub_entry->target_value = code_value;
12607 stub_entry->target_section = code_sec;
12608 }
12609 else
12610 {
12611 stub_entry->target_value = sym_value;
12612 stub_entry->target_section = sym_sec;
12613 }
12614 stub_entry->h = hash;
12615 stub_entry->plt_ent = plt_ent;
12616 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12617
12618 if (stub_entry->h != NULL)
12619 htab->stub_globals += 1;
12620 }
12621
12622 /* We're done with the internal relocs, free them. */
12623 if (elf_section_data (section)->relocs != internal_relocs)
12624 free (internal_relocs);
12625 }
12626
12627 if (local_syms != NULL
12628 && symtab_hdr->contents != (unsigned char *) local_syms)
12629 {
12630 if (!info->keep_memory)
12631 free (local_syms);
12632 else
12633 symtab_hdr->contents = (unsigned char *) local_syms;
12634 }
12635 }
12636
12637 /* We may have added some stubs. Find out the new size of the
12638 stub sections. */
12639 for (stub_sec = htab->params->stub_bfd->sections;
12640 stub_sec != NULL;
12641 stub_sec = stub_sec->next)
12642 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12643 {
12644 if (htab->stub_iteration <= STUB_SHRINK_ITER
12645 || stub_sec->rawsize < stub_sec->size)
12646 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12647 stub_sec->rawsize = stub_sec->size;
12648 stub_sec->size = 0;
12649 stub_sec->reloc_count = 0;
12650 stub_sec->flags &= ~SEC_RELOC;
12651 }
12652
12653 htab->brlt->size = 0;
12654 htab->brlt->reloc_count = 0;
12655 htab->brlt->flags &= ~SEC_RELOC;
12656 if (htab->relbrlt != NULL)
12657 htab->relbrlt->size = 0;
12658
12659 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12660
12661 for (group = htab->group; group != NULL; group = group->next)
12662 if (group->needs_save_res)
12663 group->stub_sec->size += htab->sfpr->size;
12664
12665 if (info->emitrelocations
12666 && htab->glink != NULL && htab->glink->size != 0)
12667 {
12668 htab->glink->reloc_count = 1;
12669 htab->glink->flags |= SEC_RELOC;
12670 }
12671
12672 if (htab->glink_eh_frame != NULL
12673 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12674 && htab->glink_eh_frame->output_section->size != 0)
12675 {
12676 size_t size = 0, align;
12677
12678 for (stub_sec = htab->params->stub_bfd->sections;
12679 stub_sec != NULL;
12680 stub_sec = stub_sec->next)
12681 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12682 size += 24;
12683 if (htab->glink != NULL && htab->glink->size != 0)
12684 size += 24;
12685 if (size != 0)
12686 size += sizeof (glink_eh_frame_cie);
12687 align = 1;
12688 align <<= htab->glink_eh_frame->output_section->alignment_power;
12689 align -= 1;
12690 size = (size + align) & ~align;
12691 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12692 htab->glink_eh_frame->size = size;
12693 }
12694
12695 if (htab->params->plt_stub_align != 0)
12696 for (stub_sec = htab->params->stub_bfd->sections;
12697 stub_sec != NULL;
12698 stub_sec = stub_sec->next)
12699 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12700 stub_sec->size = ((stub_sec->size
12701 + (1 << htab->params->plt_stub_align) - 1)
12702 & -(1 << htab->params->plt_stub_align));
12703
12704 for (stub_sec = htab->params->stub_bfd->sections;
12705 stub_sec != NULL;
12706 stub_sec = stub_sec->next)
12707 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12708 && stub_sec->rawsize != stub_sec->size
12709 && (htab->stub_iteration <= STUB_SHRINK_ITER
12710 || stub_sec->rawsize < stub_sec->size))
12711 break;
12712
12713 if (stub_sec == NULL
12714 && (htab->glink_eh_frame == NULL
12715 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12716 break;
12717
12718 /* Ask the linker to do its stuff. */
12719 (*htab->params->layout_sections_again) ();
12720 }
12721
12722 if (htab->glink_eh_frame != NULL
12723 && htab->glink_eh_frame->size != 0)
12724 {
12725 bfd_vma val;
12726 bfd_byte *p, *last_fde;
12727 size_t last_fde_len, size, align, pad;
12728 asection *stub_sec;
12729
12730 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12731 if (p == NULL)
12732 return FALSE;
12733 htab->glink_eh_frame->contents = p;
12734 last_fde = p;
12735
12736 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12737 /* CIE length (rewrite in case little-endian). */
12738 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12739 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12740 p += sizeof (glink_eh_frame_cie);
12741
12742 for (stub_sec = htab->params->stub_bfd->sections;
12743 stub_sec != NULL;
12744 stub_sec = stub_sec->next)
12745 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12746 {
12747 last_fde = p;
12748 last_fde_len = 20;
12749 /* FDE length. */
12750 bfd_put_32 (htab->elf.dynobj, 20, p);
12751 p += 4;
12752 /* CIE pointer. */
12753 val = p - htab->glink_eh_frame->contents;
12754 bfd_put_32 (htab->elf.dynobj, val, p);
12755 p += 4;
12756 /* Offset to stub section, written later. */
12757 p += 4;
12758 /* stub section size. */
12759 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12760 p += 4;
12761 /* Augmentation. */
12762 p += 1;
12763 /* Pad. */
12764 p += 7;
12765 }
12766 if (htab->glink != NULL && htab->glink->size != 0)
12767 {
12768 last_fde = p;
12769 last_fde_len = 20;
12770 /* FDE length. */
12771 bfd_put_32 (htab->elf.dynobj, 20, p);
12772 p += 4;
12773 /* CIE pointer. */
12774 val = p - htab->glink_eh_frame->contents;
12775 bfd_put_32 (htab->elf.dynobj, val, p);
12776 p += 4;
12777 /* Offset to .glink, written later. */
12778 p += 4;
12779 /* .glink size. */
12780 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12781 p += 4;
12782 /* Augmentation. */
12783 p += 1;
12784
12785 *p++ = DW_CFA_advance_loc + 1;
12786 *p++ = DW_CFA_register;
12787 *p++ = 65;
12788 *p++ = htab->opd_abi ? 12 : 0;
12789 *p++ = DW_CFA_advance_loc + 4;
12790 *p++ = DW_CFA_restore_extended;
12791 *p++ = 65;
12792 }
12793 /* Subsume any padding into the last FDE if user .eh_frame
12794 sections are aligned more than glink_eh_frame. Otherwise any
12795 zero padding will be seen as a terminator. */
12796 size = p - htab->glink_eh_frame->contents;
12797 align = 1;
12798 align <<= htab->glink_eh_frame->output_section->alignment_power;
12799 align -= 1;
12800 pad = ((size + align) & ~align) - size;
12801 htab->glink_eh_frame->size = size + pad;
12802 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12803 }
12804
12805 maybe_strip_output (info, htab->brlt);
12806 if (htab->glink_eh_frame != NULL)
12807 maybe_strip_output (info, htab->glink_eh_frame);
12808
12809 return TRUE;
12810 }
12811
12812 /* Called after we have determined section placement. If sections
12813 move, we'll be called again. Provide a value for TOCstart. */
12814
12815 bfd_vma
12816 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12817 {
12818 asection *s;
12819 bfd_vma TOCstart, adjust;
12820
12821 if (info != NULL)
12822 {
12823 struct elf_link_hash_entry *h;
12824 struct elf_link_hash_table *htab = elf_hash_table (info);
12825
12826 if (is_elf_hash_table (htab)
12827 && htab->hgot != NULL)
12828 h = htab->hgot;
12829 else
12830 {
12831 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12832 if (is_elf_hash_table (htab))
12833 htab->hgot = h;
12834 }
12835 if (h != NULL
12836 && h->root.type == bfd_link_hash_defined
12837 && !h->root.linker_def
12838 && (!is_elf_hash_table (htab)
12839 || h->def_regular))
12840 {
12841 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12842 + h->root.u.def.section->output_offset
12843 + h->root.u.def.section->output_section->vma);
12844 _bfd_set_gp_value (obfd, TOCstart);
12845 return TOCstart;
12846 }
12847 }
12848
12849 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12850 order. The TOC starts where the first of these sections starts. */
12851 s = bfd_get_section_by_name (obfd, ".got");
12852 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12853 s = bfd_get_section_by_name (obfd, ".toc");
12854 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12855 s = bfd_get_section_by_name (obfd, ".tocbss");
12856 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12857 s = bfd_get_section_by_name (obfd, ".plt");
12858 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12859 {
12860 /* This may happen for
12861 o references to TOC base (SYM@toc / TOC[tc0]) without a
12862 .toc directive
12863 o bad linker script
12864 o --gc-sections and empty TOC sections
12865
12866 FIXME: Warn user? */
12867
12868 /* Look for a likely section. We probably won't even be
12869 using TOCstart. */
12870 for (s = obfd->sections; s != NULL; s = s->next)
12871 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12872 | SEC_EXCLUDE))
12873 == (SEC_ALLOC | SEC_SMALL_DATA))
12874 break;
12875 if (s == NULL)
12876 for (s = obfd->sections; s != NULL; s = s->next)
12877 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12878 == (SEC_ALLOC | SEC_SMALL_DATA))
12879 break;
12880 if (s == NULL)
12881 for (s = obfd->sections; s != NULL; s = s->next)
12882 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12883 == SEC_ALLOC)
12884 break;
12885 if (s == NULL)
12886 for (s = obfd->sections; s != NULL; s = s->next)
12887 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12888 break;
12889 }
12890
12891 TOCstart = 0;
12892 if (s != NULL)
12893 TOCstart = s->output_section->vma + s->output_offset;
12894
12895 /* Force alignment. */
12896 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12897 TOCstart -= adjust;
12898 _bfd_set_gp_value (obfd, TOCstart);
12899
12900 if (info != NULL && s != NULL)
12901 {
12902 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12903
12904 if (htab != NULL)
12905 {
12906 if (htab->elf.hgot != NULL)
12907 {
12908 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12909 htab->elf.hgot->root.u.def.section = s;
12910 }
12911 }
12912 else
12913 {
12914 struct bfd_link_hash_entry *bh = NULL;
12915 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12916 s, TOC_BASE_OFF - adjust,
12917 NULL, FALSE, FALSE, &bh);
12918 }
12919 }
12920 return TOCstart;
12921 }
12922
12923 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12924 write out any global entry stubs. */
12925
12926 static bfd_boolean
12927 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12928 {
12929 struct bfd_link_info *info;
12930 struct ppc_link_hash_table *htab;
12931 struct plt_entry *pent;
12932 asection *s;
12933
12934 if (h->root.type == bfd_link_hash_indirect)
12935 return TRUE;
12936
12937 if (!h->pointer_equality_needed)
12938 return TRUE;
12939
12940 if (h->def_regular)
12941 return TRUE;
12942
12943 info = inf;
12944 htab = ppc_hash_table (info);
12945 if (htab == NULL)
12946 return FALSE;
12947
12948 s = htab->glink;
12949 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12950 if (pent->plt.offset != (bfd_vma) -1
12951 && pent->addend == 0)
12952 {
12953 bfd_byte *p;
12954 asection *plt;
12955 bfd_vma off;
12956
12957 p = s->contents + h->root.u.def.value;
12958 plt = htab->elf.splt;
12959 if (!htab->elf.dynamic_sections_created
12960 || h->dynindx == -1)
12961 plt = htab->elf.iplt;
12962 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12963 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12964
12965 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12966 {
12967 info->callbacks->einfo
12968 (_("%P: linkage table error against `%T'\n"),
12969 h->root.root.string);
12970 bfd_set_error (bfd_error_bad_value);
12971 htab->stub_error = TRUE;
12972 }
12973
12974 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12975 if (htab->params->emit_stub_syms)
12976 {
12977 size_t len = strlen (h->root.root.string);
12978 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12979
12980 if (name == NULL)
12981 return FALSE;
12982
12983 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12984 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12985 if (h == NULL)
12986 return FALSE;
12987 if (h->root.type == bfd_link_hash_new)
12988 {
12989 h->root.type = bfd_link_hash_defined;
12990 h->root.u.def.section = s;
12991 h->root.u.def.value = p - s->contents;
12992 h->ref_regular = 1;
12993 h->def_regular = 1;
12994 h->ref_regular_nonweak = 1;
12995 h->forced_local = 1;
12996 h->non_elf = 0;
12997 h->root.linker_def = 1;
12998 }
12999 }
13000
13001 if (PPC_HA (off) != 0)
13002 {
13003 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13004 p += 4;
13005 }
13006 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13007 p += 4;
13008 bfd_put_32 (s->owner, MTCTR_R12, p);
13009 p += 4;
13010 bfd_put_32 (s->owner, BCTR, p);
13011 break;
13012 }
13013 return TRUE;
13014 }
13015
13016 /* Build all the stubs associated with the current output file.
13017 The stubs are kept in a hash table attached to the main linker
13018 hash table. This function is called via gldelf64ppc_finish. */
13019
13020 bfd_boolean
13021 ppc64_elf_build_stubs (struct bfd_link_info *info,
13022 char **stats)
13023 {
13024 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13025 struct map_stub *group;
13026 asection *stub_sec;
13027 bfd_byte *p;
13028 int stub_sec_count = 0;
13029
13030 if (htab == NULL)
13031 return FALSE;
13032
13033 /* Allocate memory to hold the linker stubs. */
13034 for (stub_sec = htab->params->stub_bfd->sections;
13035 stub_sec != NULL;
13036 stub_sec = stub_sec->next)
13037 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13038 && stub_sec->size != 0)
13039 {
13040 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13041 if (stub_sec->contents == NULL)
13042 return FALSE;
13043 stub_sec->size = 0;
13044 }
13045
13046 if (htab->glink != NULL && htab->glink->size != 0)
13047 {
13048 unsigned int indx;
13049 bfd_vma plt0;
13050
13051 /* Build the .glink plt call stub. */
13052 if (htab->params->emit_stub_syms)
13053 {
13054 struct elf_link_hash_entry *h;
13055 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13056 TRUE, FALSE, FALSE);
13057 if (h == NULL)
13058 return FALSE;
13059 if (h->root.type == bfd_link_hash_new)
13060 {
13061 h->root.type = bfd_link_hash_defined;
13062 h->root.u.def.section = htab->glink;
13063 h->root.u.def.value = 8;
13064 h->ref_regular = 1;
13065 h->def_regular = 1;
13066 h->ref_regular_nonweak = 1;
13067 h->forced_local = 1;
13068 h->non_elf = 0;
13069 h->root.linker_def = 1;
13070 }
13071 }
13072 plt0 = (htab->elf.splt->output_section->vma
13073 + htab->elf.splt->output_offset
13074 - 16);
13075 if (info->emitrelocations)
13076 {
13077 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13078 if (r == NULL)
13079 return FALSE;
13080 r->r_offset = (htab->glink->output_offset
13081 + htab->glink->output_section->vma);
13082 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13083 r->r_addend = plt0;
13084 }
13085 p = htab->glink->contents;
13086 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13087 bfd_put_64 (htab->glink->owner, plt0, p);
13088 p += 8;
13089 if (htab->opd_abi)
13090 {
13091 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13092 p += 4;
13093 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13094 p += 4;
13095 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13096 p += 4;
13097 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13098 p += 4;
13099 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13100 p += 4;
13101 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13102 p += 4;
13103 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13104 p += 4;
13105 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13106 p += 4;
13107 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13108 p += 4;
13109 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13110 p += 4;
13111 }
13112 else
13113 {
13114 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13115 p += 4;
13116 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13117 p += 4;
13118 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13119 p += 4;
13120 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13121 p += 4;
13122 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13123 p += 4;
13124 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13125 p += 4;
13126 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13127 p += 4;
13128 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13129 p += 4;
13130 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13131 p += 4;
13132 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13133 p += 4;
13134 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13135 p += 4;
13136 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13137 p += 4;
13138 }
13139 bfd_put_32 (htab->glink->owner, BCTR, p);
13140 p += 4;
13141 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13142 {
13143 bfd_put_32 (htab->glink->owner, NOP, p);
13144 p += 4;
13145 }
13146
13147 /* Build the .glink lazy link call stubs. */
13148 indx = 0;
13149 while (p < htab->glink->contents + htab->glink->rawsize)
13150 {
13151 if (htab->opd_abi)
13152 {
13153 if (indx < 0x8000)
13154 {
13155 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13156 p += 4;
13157 }
13158 else
13159 {
13160 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13161 p += 4;
13162 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13163 p);
13164 p += 4;
13165 }
13166 }
13167 bfd_put_32 (htab->glink->owner,
13168 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13169 indx++;
13170 p += 4;
13171 }
13172
13173 /* Build .glink global entry stubs. */
13174 if (htab->glink->size > htab->glink->rawsize)
13175 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13176 }
13177
13178 if (htab->brlt != NULL && htab->brlt->size != 0)
13179 {
13180 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13181 htab->brlt->size);
13182 if (htab->brlt->contents == NULL)
13183 return FALSE;
13184 }
13185 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13186 {
13187 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13188 htab->relbrlt->size);
13189 if (htab->relbrlt->contents == NULL)
13190 return FALSE;
13191 }
13192
13193 /* Build the stubs as directed by the stub hash table. */
13194 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13195
13196 for (group = htab->group; group != NULL; group = group->next)
13197 if (group->needs_save_res)
13198 {
13199 stub_sec = group->stub_sec;
13200 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13201 htab->sfpr->size);
13202 if (htab->params->emit_stub_syms)
13203 {
13204 unsigned int i;
13205
13206 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13207 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13208 return FALSE;
13209 }
13210 stub_sec->size += htab->sfpr->size;
13211 }
13212
13213 if (htab->relbrlt != NULL)
13214 htab->relbrlt->reloc_count = 0;
13215
13216 if (htab->params->plt_stub_align != 0)
13217 for (stub_sec = htab->params->stub_bfd->sections;
13218 stub_sec != NULL;
13219 stub_sec = stub_sec->next)
13220 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13221 stub_sec->size = ((stub_sec->size
13222 + (1 << htab->params->plt_stub_align) - 1)
13223 & -(1 << htab->params->plt_stub_align));
13224
13225 for (stub_sec = htab->params->stub_bfd->sections;
13226 stub_sec != NULL;
13227 stub_sec = stub_sec->next)
13228 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13229 {
13230 stub_sec_count += 1;
13231 if (stub_sec->rawsize != stub_sec->size
13232 && (htab->stub_iteration <= STUB_SHRINK_ITER
13233 || stub_sec->rawsize < stub_sec->size))
13234 break;
13235 }
13236
13237 /* Note that the glink_eh_frame check here is not only testing that
13238 the generated size matched the calculated size but also that
13239 bfd_elf_discard_info didn't make any changes to the section. */
13240 if (stub_sec != NULL
13241 || (htab->glink_eh_frame != NULL
13242 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13243 {
13244 htab->stub_error = TRUE;
13245 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13246 }
13247
13248 if (htab->stub_error)
13249 return FALSE;
13250
13251 if (stats != NULL)
13252 {
13253 *stats = bfd_malloc (500);
13254 if (*stats == NULL)
13255 return FALSE;
13256
13257 sprintf (*stats, _("linker stubs in %u group%s\n"
13258 " branch %lu\n"
13259 " toc adjust %lu\n"
13260 " long branch %lu\n"
13261 " long toc adj %lu\n"
13262 " plt call %lu\n"
13263 " plt call toc %lu\n"
13264 " global entry %lu"),
13265 stub_sec_count,
13266 stub_sec_count == 1 ? "" : "s",
13267 htab->stub_count[ppc_stub_long_branch - 1],
13268 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13269 htab->stub_count[ppc_stub_plt_branch - 1],
13270 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13271 htab->stub_count[ppc_stub_plt_call - 1],
13272 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13273 htab->stub_count[ppc_stub_global_entry - 1]);
13274 }
13275 return TRUE;
13276 }
13277
13278 /* What to do when ld finds relocations against symbols defined in
13279 discarded sections. */
13280
13281 static unsigned int
13282 ppc64_elf_action_discarded (asection *sec)
13283 {
13284 if (strcmp (".opd", sec->name) == 0)
13285 return 0;
13286
13287 if (strcmp (".toc", sec->name) == 0)
13288 return 0;
13289
13290 if (strcmp (".toc1", sec->name) == 0)
13291 return 0;
13292
13293 return _bfd_elf_default_action_discarded (sec);
13294 }
13295
13296 /* The RELOCATE_SECTION function is called by the ELF backend linker
13297 to handle the relocations for a section.
13298
13299 The relocs are always passed as Rela structures; if the section
13300 actually uses Rel structures, the r_addend field will always be
13301 zero.
13302
13303 This function is responsible for adjust the section contents as
13304 necessary, and (if using Rela relocs and generating a
13305 relocatable output file) adjusting the reloc addend as
13306 necessary.
13307
13308 This function does not have to worry about setting the reloc
13309 address or the reloc symbol index.
13310
13311 LOCAL_SYMS is a pointer to the swapped in local symbols.
13312
13313 LOCAL_SECTIONS is an array giving the section in the input file
13314 corresponding to the st_shndx field of each local symbol.
13315
13316 The global hash table entry for the global symbols can be found
13317 via elf_sym_hashes (input_bfd).
13318
13319 When generating relocatable output, this function must handle
13320 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13321 going to be the section symbol corresponding to the output
13322 section, which means that the addend must be adjusted
13323 accordingly. */
13324
13325 static bfd_boolean
13326 ppc64_elf_relocate_section (bfd *output_bfd,
13327 struct bfd_link_info *info,
13328 bfd *input_bfd,
13329 asection *input_section,
13330 bfd_byte *contents,
13331 Elf_Internal_Rela *relocs,
13332 Elf_Internal_Sym *local_syms,
13333 asection **local_sections)
13334 {
13335 struct ppc_link_hash_table *htab;
13336 Elf_Internal_Shdr *symtab_hdr;
13337 struct elf_link_hash_entry **sym_hashes;
13338 Elf_Internal_Rela *rel;
13339 Elf_Internal_Rela *wrel;
13340 Elf_Internal_Rela *relend;
13341 Elf_Internal_Rela outrel;
13342 bfd_byte *loc;
13343 struct got_entry **local_got_ents;
13344 bfd_vma TOCstart;
13345 bfd_boolean ret = TRUE;
13346 bfd_boolean is_opd;
13347 /* Assume 'at' branch hints. */
13348 bfd_boolean is_isa_v2 = TRUE;
13349 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13350
13351 /* Initialize howto table if needed. */
13352 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13353 ppc_howto_init ();
13354
13355 htab = ppc_hash_table (info);
13356 if (htab == NULL)
13357 return FALSE;
13358
13359 /* Don't relocate stub sections. */
13360 if (input_section->owner == htab->params->stub_bfd)
13361 return TRUE;
13362
13363 BFD_ASSERT (is_ppc64_elf (input_bfd));
13364
13365 local_got_ents = elf_local_got_ents (input_bfd);
13366 TOCstart = elf_gp (output_bfd);
13367 symtab_hdr = &elf_symtab_hdr (input_bfd);
13368 sym_hashes = elf_sym_hashes (input_bfd);
13369 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13370
13371 rel = wrel = relocs;
13372 relend = relocs + input_section->reloc_count;
13373 for (; rel < relend; wrel++, rel++)
13374 {
13375 enum elf_ppc64_reloc_type r_type;
13376 bfd_vma addend;
13377 bfd_reloc_status_type r;
13378 Elf_Internal_Sym *sym;
13379 asection *sec;
13380 struct elf_link_hash_entry *h_elf;
13381 struct ppc_link_hash_entry *h;
13382 struct ppc_link_hash_entry *fdh;
13383 const char *sym_name;
13384 unsigned long r_symndx, toc_symndx;
13385 bfd_vma toc_addend;
13386 unsigned char tls_mask, tls_gd, tls_type;
13387 unsigned char sym_type;
13388 bfd_vma relocation;
13389 bfd_boolean unresolved_reloc;
13390 bfd_boolean warned;
13391 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13392 unsigned int insn;
13393 unsigned int mask;
13394 struct ppc_stub_hash_entry *stub_entry;
13395 bfd_vma max_br_offset;
13396 bfd_vma from;
13397 Elf_Internal_Rela orig_rel;
13398 reloc_howto_type *howto;
13399 struct reloc_howto_struct alt_howto;
13400
13401 again:
13402 orig_rel = *rel;
13403
13404 r_type = ELF64_R_TYPE (rel->r_info);
13405 r_symndx = ELF64_R_SYM (rel->r_info);
13406
13407 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13408 symbol of the previous ADDR64 reloc. The symbol gives us the
13409 proper TOC base to use. */
13410 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13411 && wrel != relocs
13412 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13413 && is_opd)
13414 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13415
13416 sym = NULL;
13417 sec = NULL;
13418 h_elf = NULL;
13419 sym_name = NULL;
13420 unresolved_reloc = FALSE;
13421 warned = FALSE;
13422
13423 if (r_symndx < symtab_hdr->sh_info)
13424 {
13425 /* It's a local symbol. */
13426 struct _opd_sec_data *opd;
13427
13428 sym = local_syms + r_symndx;
13429 sec = local_sections[r_symndx];
13430 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13431 sym_type = ELF64_ST_TYPE (sym->st_info);
13432 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13433 opd = get_opd_info (sec);
13434 if (opd != NULL && opd->adjust != NULL)
13435 {
13436 long adjust = opd->adjust[OPD_NDX (sym->st_value
13437 + rel->r_addend)];
13438 if (adjust == -1)
13439 relocation = 0;
13440 else
13441 {
13442 /* If this is a relocation against the opd section sym
13443 and we have edited .opd, adjust the reloc addend so
13444 that ld -r and ld --emit-relocs output is correct.
13445 If it is a reloc against some other .opd symbol,
13446 then the symbol value will be adjusted later. */
13447 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13448 rel->r_addend += adjust;
13449 else
13450 relocation += adjust;
13451 }
13452 }
13453 }
13454 else
13455 {
13456 bfd_boolean ignored;
13457
13458 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13459 r_symndx, symtab_hdr, sym_hashes,
13460 h_elf, sec, relocation,
13461 unresolved_reloc, warned, ignored);
13462 sym_name = h_elf->root.root.string;
13463 sym_type = h_elf->type;
13464 if (sec != NULL
13465 && sec->owner == output_bfd
13466 && strcmp (sec->name, ".opd") == 0)
13467 {
13468 /* This is a symbol defined in a linker script. All
13469 such are defined in output sections, even those
13470 defined by simple assignment from a symbol defined in
13471 an input section. Transfer the symbol to an
13472 appropriate input .opd section, so that a branch to
13473 this symbol will be mapped to the location specified
13474 by the opd entry. */
13475 struct bfd_link_order *lo;
13476 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13477 if (lo->type == bfd_indirect_link_order)
13478 {
13479 asection *isec = lo->u.indirect.section;
13480 if (h_elf->root.u.def.value >= isec->output_offset
13481 && h_elf->root.u.def.value < (isec->output_offset
13482 + isec->size))
13483 {
13484 h_elf->root.u.def.value -= isec->output_offset;
13485 h_elf->root.u.def.section = isec;
13486 sec = isec;
13487 break;
13488 }
13489 }
13490 }
13491 }
13492 h = (struct ppc_link_hash_entry *) h_elf;
13493
13494 if (sec != NULL && discarded_section (sec))
13495 {
13496 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13497 input_bfd, input_section,
13498 contents + rel->r_offset);
13499 wrel->r_offset = rel->r_offset;
13500 wrel->r_info = 0;
13501 wrel->r_addend = 0;
13502
13503 /* For ld -r, remove relocations in debug sections against
13504 sections defined in discarded sections. Not done for
13505 non-debug to preserve relocs in .eh_frame which the
13506 eh_frame editing code expects to be present. */
13507 if (bfd_link_relocatable (info)
13508 && (input_section->flags & SEC_DEBUGGING))
13509 wrel--;
13510
13511 continue;
13512 }
13513
13514 if (bfd_link_relocatable (info))
13515 goto copy_reloc;
13516
13517 if (h != NULL && &h->elf == htab->elf.hgot)
13518 {
13519 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13520 sec = bfd_abs_section_ptr;
13521 unresolved_reloc = FALSE;
13522 }
13523
13524 /* TLS optimizations. Replace instruction sequences and relocs
13525 based on information we collected in tls_optimize. We edit
13526 RELOCS so that --emit-relocs will output something sensible
13527 for the final instruction stream. */
13528 tls_mask = 0;
13529 tls_gd = 0;
13530 toc_symndx = 0;
13531 if (h != NULL)
13532 tls_mask = h->tls_mask;
13533 else if (local_got_ents != NULL)
13534 {
13535 struct plt_entry **local_plt = (struct plt_entry **)
13536 (local_got_ents + symtab_hdr->sh_info);
13537 unsigned char *lgot_masks = (unsigned char *)
13538 (local_plt + symtab_hdr->sh_info);
13539 tls_mask = lgot_masks[r_symndx];
13540 }
13541 if (tls_mask == 0
13542 && (r_type == R_PPC64_TLS
13543 || r_type == R_PPC64_TLSGD
13544 || r_type == R_PPC64_TLSLD))
13545 {
13546 /* Check for toc tls entries. */
13547 unsigned char *toc_tls;
13548
13549 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13550 &local_syms, rel, input_bfd))
13551 return FALSE;
13552
13553 if (toc_tls)
13554 tls_mask = *toc_tls;
13555 }
13556
13557 /* Check that tls relocs are used with tls syms, and non-tls
13558 relocs are used with non-tls syms. */
13559 if (r_symndx != STN_UNDEF
13560 && r_type != R_PPC64_NONE
13561 && (h == NULL
13562 || h->elf.root.type == bfd_link_hash_defined
13563 || h->elf.root.type == bfd_link_hash_defweak)
13564 && (IS_PPC64_TLS_RELOC (r_type)
13565 != (sym_type == STT_TLS
13566 || (sym_type == STT_SECTION
13567 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13568 {
13569 if (tls_mask != 0
13570 && (r_type == R_PPC64_TLS
13571 || r_type == R_PPC64_TLSGD
13572 || r_type == R_PPC64_TLSLD))
13573 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13574 ;
13575 else
13576 info->callbacks->einfo
13577 (!IS_PPC64_TLS_RELOC (r_type)
13578 /* xgettext:c-format */
13579 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13580 /* xgettext:c-format */
13581 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13582 input_bfd, input_section, rel->r_offset,
13583 ppc64_elf_howto_table[r_type]->name,
13584 sym_name);
13585 }
13586
13587 /* Ensure reloc mapping code below stays sane. */
13588 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13589 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13590 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13591 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13592 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13593 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13594 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13595 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13596 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13597 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13598 abort ();
13599
13600 switch (r_type)
13601 {
13602 default:
13603 break;
13604
13605 case R_PPC64_LO_DS_OPT:
13606 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13607 if ((insn & (0x3f << 26)) != 58u << 26)
13608 abort ();
13609 insn += (14u << 26) - (58u << 26);
13610 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13611 r_type = R_PPC64_TOC16_LO;
13612 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13613 break;
13614
13615 case R_PPC64_TOC16:
13616 case R_PPC64_TOC16_LO:
13617 case R_PPC64_TOC16_DS:
13618 case R_PPC64_TOC16_LO_DS:
13619 {
13620 /* Check for toc tls entries. */
13621 unsigned char *toc_tls;
13622 int retval;
13623
13624 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13625 &local_syms, rel, input_bfd);
13626 if (retval == 0)
13627 return FALSE;
13628
13629 if (toc_tls)
13630 {
13631 tls_mask = *toc_tls;
13632 if (r_type == R_PPC64_TOC16_DS
13633 || r_type == R_PPC64_TOC16_LO_DS)
13634 {
13635 if (tls_mask != 0
13636 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13637 goto toctprel;
13638 }
13639 else
13640 {
13641 /* If we found a GD reloc pair, then we might be
13642 doing a GD->IE transition. */
13643 if (retval == 2)
13644 {
13645 tls_gd = TLS_TPRELGD;
13646 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13647 goto tls_ldgd_opt;
13648 }
13649 else if (retval == 3)
13650 {
13651 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13652 goto tls_ldgd_opt;
13653 }
13654 }
13655 }
13656 }
13657 break;
13658
13659 case R_PPC64_GOT_TPREL16_HI:
13660 case R_PPC64_GOT_TPREL16_HA:
13661 if (tls_mask != 0
13662 && (tls_mask & TLS_TPREL) == 0)
13663 {
13664 rel->r_offset -= d_offset;
13665 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13666 r_type = R_PPC64_NONE;
13667 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13668 }
13669 break;
13670
13671 case R_PPC64_GOT_TPREL16_DS:
13672 case R_PPC64_GOT_TPREL16_LO_DS:
13673 if (tls_mask != 0
13674 && (tls_mask & TLS_TPREL) == 0)
13675 {
13676 toctprel:
13677 insn = bfd_get_32 (input_bfd,
13678 contents + rel->r_offset - d_offset);
13679 insn &= 31 << 21;
13680 insn |= 0x3c0d0000; /* addis 0,13,0 */
13681 bfd_put_32 (input_bfd, insn,
13682 contents + rel->r_offset - d_offset);
13683 r_type = R_PPC64_TPREL16_HA;
13684 if (toc_symndx != 0)
13685 {
13686 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13687 rel->r_addend = toc_addend;
13688 /* We changed the symbol. Start over in order to
13689 get h, sym, sec etc. right. */
13690 goto again;
13691 }
13692 else
13693 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13694 }
13695 break;
13696
13697 case R_PPC64_TLS:
13698 if (tls_mask != 0
13699 && (tls_mask & TLS_TPREL) == 0)
13700 {
13701 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13702 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13703 if (insn == 0)
13704 abort ();
13705 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13706 /* Was PPC64_TLS which sits on insn boundary, now
13707 PPC64_TPREL16_LO which is at low-order half-word. */
13708 rel->r_offset += d_offset;
13709 r_type = R_PPC64_TPREL16_LO;
13710 if (toc_symndx != 0)
13711 {
13712 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13713 rel->r_addend = toc_addend;
13714 /* We changed the symbol. Start over in order to
13715 get h, sym, sec etc. right. */
13716 goto again;
13717 }
13718 else
13719 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13720 }
13721 break;
13722
13723 case R_PPC64_GOT_TLSGD16_HI:
13724 case R_PPC64_GOT_TLSGD16_HA:
13725 tls_gd = TLS_TPRELGD;
13726 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13727 goto tls_gdld_hi;
13728 break;
13729
13730 case R_PPC64_GOT_TLSLD16_HI:
13731 case R_PPC64_GOT_TLSLD16_HA:
13732 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13733 {
13734 tls_gdld_hi:
13735 if ((tls_mask & tls_gd) != 0)
13736 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13737 + R_PPC64_GOT_TPREL16_DS);
13738 else
13739 {
13740 rel->r_offset -= d_offset;
13741 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13742 r_type = R_PPC64_NONE;
13743 }
13744 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13745 }
13746 break;
13747
13748 case R_PPC64_GOT_TLSGD16:
13749 case R_PPC64_GOT_TLSGD16_LO:
13750 tls_gd = TLS_TPRELGD;
13751 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13752 goto tls_ldgd_opt;
13753 break;
13754
13755 case R_PPC64_GOT_TLSLD16:
13756 case R_PPC64_GOT_TLSLD16_LO:
13757 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13758 {
13759 unsigned int insn1, insn2, insn3;
13760 bfd_vma offset;
13761
13762 tls_ldgd_opt:
13763 offset = (bfd_vma) -1;
13764 /* If not using the newer R_PPC64_TLSGD/LD to mark
13765 __tls_get_addr calls, we must trust that the call
13766 stays with its arg setup insns, ie. that the next
13767 reloc is the __tls_get_addr call associated with
13768 the current reloc. Edit both insns. */
13769 if (input_section->has_tls_get_addr_call
13770 && rel + 1 < relend
13771 && branch_reloc_hash_match (input_bfd, rel + 1,
13772 htab->tls_get_addr,
13773 htab->tls_get_addr_fd))
13774 offset = rel[1].r_offset;
13775 /* We read the low GOT_TLS (or TOC16) insn because we
13776 need to keep the destination reg. It may be
13777 something other than the usual r3, and moved to r3
13778 before the call by intervening code. */
13779 insn1 = bfd_get_32 (input_bfd,
13780 contents + rel->r_offset - d_offset);
13781 if ((tls_mask & tls_gd) != 0)
13782 {
13783 /* IE */
13784 insn1 &= (0x1f << 21) | (0x1f << 16);
13785 insn1 |= 58 << 26; /* ld */
13786 insn2 = 0x7c636a14; /* add 3,3,13 */
13787 if (offset != (bfd_vma) -1)
13788 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13789 if ((tls_mask & TLS_EXPLICIT) == 0)
13790 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13791 + R_PPC64_GOT_TPREL16_DS);
13792 else
13793 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13794 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13795 }
13796 else
13797 {
13798 /* LE */
13799 insn1 &= 0x1f << 21;
13800 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13801 insn2 = 0x38630000; /* addi 3,3,0 */
13802 if (tls_gd == 0)
13803 {
13804 /* Was an LD reloc. */
13805 if (toc_symndx)
13806 sec = local_sections[toc_symndx];
13807 for (r_symndx = 0;
13808 r_symndx < symtab_hdr->sh_info;
13809 r_symndx++)
13810 if (local_sections[r_symndx] == sec)
13811 break;
13812 if (r_symndx >= symtab_hdr->sh_info)
13813 r_symndx = STN_UNDEF;
13814 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13815 if (r_symndx != STN_UNDEF)
13816 rel->r_addend -= (local_syms[r_symndx].st_value
13817 + sec->output_offset
13818 + sec->output_section->vma);
13819 }
13820 else if (toc_symndx != 0)
13821 {
13822 r_symndx = toc_symndx;
13823 rel->r_addend = toc_addend;
13824 }
13825 r_type = R_PPC64_TPREL16_HA;
13826 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13827 if (offset != (bfd_vma) -1)
13828 {
13829 rel[1].r_info = ELF64_R_INFO (r_symndx,
13830 R_PPC64_TPREL16_LO);
13831 rel[1].r_offset = offset + d_offset;
13832 rel[1].r_addend = rel->r_addend;
13833 }
13834 }
13835 bfd_put_32 (input_bfd, insn1,
13836 contents + rel->r_offset - d_offset);
13837 if (offset != (bfd_vma) -1)
13838 {
13839 insn3 = bfd_get_32 (input_bfd,
13840 contents + offset + 4);
13841 if (insn3 == NOP
13842 || insn3 == CROR_151515 || insn3 == CROR_313131)
13843 {
13844 rel[1].r_offset += 4;
13845 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13846 insn2 = NOP;
13847 }
13848 bfd_put_32 (input_bfd, insn2, contents + offset);
13849 }
13850 if ((tls_mask & tls_gd) == 0
13851 && (tls_gd == 0 || toc_symndx != 0))
13852 {
13853 /* We changed the symbol. Start over in order
13854 to get h, sym, sec etc. right. */
13855 goto again;
13856 }
13857 }
13858 break;
13859
13860 case R_PPC64_TLSGD:
13861 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13862 {
13863 unsigned int insn2, insn3;
13864 bfd_vma offset = rel->r_offset;
13865
13866 if ((tls_mask & TLS_TPRELGD) != 0)
13867 {
13868 /* IE */
13869 r_type = R_PPC64_NONE;
13870 insn2 = 0x7c636a14; /* add 3,3,13 */
13871 }
13872 else
13873 {
13874 /* LE */
13875 if (toc_symndx != 0)
13876 {
13877 r_symndx = toc_symndx;
13878 rel->r_addend = toc_addend;
13879 }
13880 r_type = R_PPC64_TPREL16_LO;
13881 rel->r_offset = offset + d_offset;
13882 insn2 = 0x38630000; /* addi 3,3,0 */
13883 }
13884 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13885 /* Zap the reloc on the _tls_get_addr call too. */
13886 BFD_ASSERT (offset == rel[1].r_offset);
13887 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13888 insn3 = bfd_get_32 (input_bfd,
13889 contents + offset + 4);
13890 if (insn3 == NOP
13891 || insn3 == CROR_151515 || insn3 == CROR_313131)
13892 {
13893 rel->r_offset += 4;
13894 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13895 insn2 = NOP;
13896 }
13897 bfd_put_32 (input_bfd, insn2, contents + offset);
13898 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13899 goto again;
13900 }
13901 break;
13902
13903 case R_PPC64_TLSLD:
13904 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13905 {
13906 unsigned int insn2, insn3;
13907 bfd_vma offset = rel->r_offset;
13908
13909 if (toc_symndx)
13910 sec = local_sections[toc_symndx];
13911 for (r_symndx = 0;
13912 r_symndx < symtab_hdr->sh_info;
13913 r_symndx++)
13914 if (local_sections[r_symndx] == sec)
13915 break;
13916 if (r_symndx >= symtab_hdr->sh_info)
13917 r_symndx = STN_UNDEF;
13918 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13919 if (r_symndx != STN_UNDEF)
13920 rel->r_addend -= (local_syms[r_symndx].st_value
13921 + sec->output_offset
13922 + sec->output_section->vma);
13923
13924 r_type = R_PPC64_TPREL16_LO;
13925 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13926 rel->r_offset = offset + d_offset;
13927 /* Zap the reloc on the _tls_get_addr call too. */
13928 BFD_ASSERT (offset == rel[1].r_offset);
13929 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13930 insn2 = 0x38630000; /* addi 3,3,0 */
13931 insn3 = bfd_get_32 (input_bfd,
13932 contents + offset + 4);
13933 if (insn3 == NOP
13934 || insn3 == CROR_151515 || insn3 == CROR_313131)
13935 {
13936 rel->r_offset += 4;
13937 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13938 insn2 = NOP;
13939 }
13940 bfd_put_32 (input_bfd, insn2, contents + offset);
13941 goto again;
13942 }
13943 break;
13944
13945 case R_PPC64_DTPMOD64:
13946 if (rel + 1 < relend
13947 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13948 && rel[1].r_offset == rel->r_offset + 8)
13949 {
13950 if ((tls_mask & TLS_GD) == 0)
13951 {
13952 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13953 if ((tls_mask & TLS_TPRELGD) != 0)
13954 r_type = R_PPC64_TPREL64;
13955 else
13956 {
13957 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13958 r_type = R_PPC64_NONE;
13959 }
13960 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13961 }
13962 }
13963 else
13964 {
13965 if ((tls_mask & TLS_LD) == 0)
13966 {
13967 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13968 r_type = R_PPC64_NONE;
13969 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13970 }
13971 }
13972 break;
13973
13974 case R_PPC64_TPREL64:
13975 if ((tls_mask & TLS_TPREL) == 0)
13976 {
13977 r_type = R_PPC64_NONE;
13978 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13979 }
13980 break;
13981
13982 case R_PPC64_ENTRY:
13983 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13984 if (!bfd_link_pic (info)
13985 && !info->traditional_format
13986 && relocation + 0x80008000 <= 0xffffffff)
13987 {
13988 unsigned int insn1, insn2;
13989
13990 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13991 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13992 if ((insn1 & ~0xfffc) == LD_R2_0R12
13993 && insn2 == ADD_R2_R2_R12)
13994 {
13995 bfd_put_32 (input_bfd,
13996 LIS_R2 + PPC_HA (relocation),
13997 contents + rel->r_offset);
13998 bfd_put_32 (input_bfd,
13999 ADDI_R2_R2 + PPC_LO (relocation),
14000 contents + rel->r_offset + 4);
14001 }
14002 }
14003 else
14004 {
14005 relocation -= (rel->r_offset
14006 + input_section->output_offset
14007 + input_section->output_section->vma);
14008 if (relocation + 0x80008000 <= 0xffffffff)
14009 {
14010 unsigned int insn1, insn2;
14011
14012 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14013 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14014 if ((insn1 & ~0xfffc) == LD_R2_0R12
14015 && insn2 == ADD_R2_R2_R12)
14016 {
14017 bfd_put_32 (input_bfd,
14018 ADDIS_R2_R12 + PPC_HA (relocation),
14019 contents + rel->r_offset);
14020 bfd_put_32 (input_bfd,
14021 ADDI_R2_R2 + PPC_LO (relocation),
14022 contents + rel->r_offset + 4);
14023 }
14024 }
14025 }
14026 break;
14027
14028 case R_PPC64_REL16_HA:
14029 /* If we are generating a non-PIC executable, edit
14030 . 0: addis 2,12,.TOC.-0b@ha
14031 . addi 2,2,.TOC.-0b@l
14032 used by ELFv2 global entry points to set up r2, to
14033 . lis 2,.TOC.@ha
14034 . addi 2,2,.TOC.@l
14035 if .TOC. is in range. */
14036 if (!bfd_link_pic (info)
14037 && !info->traditional_format
14038 && !htab->opd_abi
14039 && rel->r_addend == d_offset
14040 && h != NULL && &h->elf == htab->elf.hgot
14041 && rel + 1 < relend
14042 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14043 && rel[1].r_offset == rel->r_offset + 4
14044 && rel[1].r_addend == rel->r_addend + 4
14045 && relocation + 0x80008000 <= 0xffffffff)
14046 {
14047 unsigned int insn1, insn2;
14048 bfd_vma offset = rel->r_offset - d_offset;
14049 insn1 = bfd_get_32 (input_bfd, contents + offset);
14050 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14051 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14052 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14053 {
14054 r_type = R_PPC64_ADDR16_HA;
14055 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14056 rel->r_addend -= d_offset;
14057 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14058 rel[1].r_addend -= d_offset + 4;
14059 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14060 }
14061 }
14062 break;
14063 }
14064
14065 /* Handle other relocations that tweak non-addend part of insn. */
14066 insn = 0;
14067 max_br_offset = 1 << 25;
14068 addend = rel->r_addend;
14069 reloc_dest = DEST_NORMAL;
14070 switch (r_type)
14071 {
14072 default:
14073 break;
14074
14075 case R_PPC64_TOCSAVE:
14076 if (relocation + addend == (rel->r_offset
14077 + input_section->output_offset
14078 + input_section->output_section->vma)
14079 && tocsave_find (htab, NO_INSERT,
14080 &local_syms, rel, input_bfd))
14081 {
14082 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14083 if (insn == NOP
14084 || insn == CROR_151515 || insn == CROR_313131)
14085 bfd_put_32 (input_bfd,
14086 STD_R2_0R1 + STK_TOC (htab),
14087 contents + rel->r_offset);
14088 }
14089 break;
14090
14091 /* Branch taken prediction relocations. */
14092 case R_PPC64_ADDR14_BRTAKEN:
14093 case R_PPC64_REL14_BRTAKEN:
14094 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14095 /* Fall through. */
14096
14097 /* Branch not taken prediction relocations. */
14098 case R_PPC64_ADDR14_BRNTAKEN:
14099 case R_PPC64_REL14_BRNTAKEN:
14100 insn |= bfd_get_32 (input_bfd,
14101 contents + rel->r_offset) & ~(0x01 << 21);
14102 /* Fall through. */
14103
14104 case R_PPC64_REL14:
14105 max_br_offset = 1 << 15;
14106 /* Fall through. */
14107
14108 case R_PPC64_REL24:
14109 /* Calls to functions with a different TOC, such as calls to
14110 shared objects, need to alter the TOC pointer. This is
14111 done using a linkage stub. A REL24 branching to these
14112 linkage stubs needs to be followed by a nop, as the nop
14113 will be replaced with an instruction to restore the TOC
14114 base pointer. */
14115 fdh = h;
14116 if (h != NULL
14117 && h->oh != NULL
14118 && h->oh->is_func_descriptor)
14119 fdh = ppc_follow_link (h->oh);
14120 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14121 htab);
14122 if (stub_entry != NULL
14123 && (stub_entry->stub_type == ppc_stub_plt_call
14124 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14125 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14126 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14127 {
14128 bfd_boolean can_plt_call = FALSE;
14129
14130 /* All of these stubs will modify r2, so there must be a
14131 branch and link followed by a nop. The nop is
14132 replaced by an insn to restore r2. */
14133 if (rel->r_offset + 8 <= input_section->size)
14134 {
14135 unsigned long br;
14136
14137 br = bfd_get_32 (input_bfd,
14138 contents + rel->r_offset);
14139 if ((br & 1) != 0)
14140 {
14141 unsigned long nop;
14142
14143 nop = bfd_get_32 (input_bfd,
14144 contents + rel->r_offset + 4);
14145 if (nop == NOP
14146 || nop == CROR_151515 || nop == CROR_313131)
14147 {
14148 if (h != NULL
14149 && (h == htab->tls_get_addr_fd
14150 || h == htab->tls_get_addr)
14151 && htab->params->tls_get_addr_opt)
14152 {
14153 /* Special stub used, leave nop alone. */
14154 }
14155 else
14156 bfd_put_32 (input_bfd,
14157 LD_R2_0R1 + STK_TOC (htab),
14158 contents + rel->r_offset + 4);
14159 can_plt_call = TRUE;
14160 }
14161 }
14162 }
14163
14164 if (!can_plt_call && h != NULL)
14165 {
14166 const char *name = h->elf.root.root.string;
14167
14168 if (*name == '.')
14169 ++name;
14170
14171 if (strncmp (name, "__libc_start_main", 17) == 0
14172 && (name[17] == 0 || name[17] == '@'))
14173 {
14174 /* Allow crt1 branch to go via a toc adjusting
14175 stub. Other calls that never return could do
14176 the same, if we could detect such. */
14177 can_plt_call = TRUE;
14178 }
14179 }
14180
14181 if (!can_plt_call)
14182 {
14183 /* g++ as of 20130507 emits self-calls without a
14184 following nop. This is arguably wrong since we
14185 have conflicting information. On the one hand a
14186 global symbol and on the other a local call
14187 sequence, but don't error for this special case.
14188 It isn't possible to cheaply verify we have
14189 exactly such a call. Allow all calls to the same
14190 section. */
14191 asection *code_sec = sec;
14192
14193 if (get_opd_info (sec) != NULL)
14194 {
14195 bfd_vma off = (relocation + addend
14196 - sec->output_section->vma
14197 - sec->output_offset);
14198
14199 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14200 }
14201 if (code_sec == input_section)
14202 can_plt_call = TRUE;
14203 }
14204
14205 if (!can_plt_call)
14206 {
14207 if (stub_entry->stub_type == ppc_stub_plt_call
14208 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14209 info->callbacks->einfo
14210 /* xgettext:c-format */
14211 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14212 "recompile with -fPIC\n"),
14213 input_bfd, input_section, rel->r_offset, sym_name);
14214 else
14215 info->callbacks->einfo
14216 /* xgettext:c-format */
14217 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14218 "(-mcmodel=small toc adjust stub)\n"),
14219 input_bfd, input_section, rel->r_offset, sym_name);
14220
14221 bfd_set_error (bfd_error_bad_value);
14222 ret = FALSE;
14223 }
14224
14225 if (can_plt_call
14226 && (stub_entry->stub_type == ppc_stub_plt_call
14227 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14228 unresolved_reloc = FALSE;
14229 }
14230
14231 if ((stub_entry == NULL
14232 || stub_entry->stub_type == ppc_stub_long_branch
14233 || stub_entry->stub_type == ppc_stub_plt_branch)
14234 && get_opd_info (sec) != NULL)
14235 {
14236 /* The branch destination is the value of the opd entry. */
14237 bfd_vma off = (relocation + addend
14238 - sec->output_section->vma
14239 - sec->output_offset);
14240 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14241 if (dest != (bfd_vma) -1)
14242 {
14243 relocation = dest;
14244 addend = 0;
14245 reloc_dest = DEST_OPD;
14246 }
14247 }
14248
14249 /* If the branch is out of reach we ought to have a long
14250 branch stub. */
14251 from = (rel->r_offset
14252 + input_section->output_offset
14253 + input_section->output_section->vma);
14254
14255 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14256 ? fdh->elf.other
14257 : sym->st_other);
14258
14259 if (stub_entry != NULL
14260 && (stub_entry->stub_type == ppc_stub_long_branch
14261 || stub_entry->stub_type == ppc_stub_plt_branch)
14262 && (r_type == R_PPC64_ADDR14_BRTAKEN
14263 || r_type == R_PPC64_ADDR14_BRNTAKEN
14264 || (relocation + addend - from + max_br_offset
14265 < 2 * max_br_offset)))
14266 /* Don't use the stub if this branch is in range. */
14267 stub_entry = NULL;
14268
14269 if (stub_entry != NULL)
14270 {
14271 /* Munge up the value and addend so that we call the stub
14272 rather than the procedure directly. */
14273 asection *stub_sec = stub_entry->group->stub_sec;
14274
14275 if (stub_entry->stub_type == ppc_stub_save_res)
14276 relocation += (stub_sec->output_offset
14277 + stub_sec->output_section->vma
14278 + stub_sec->size - htab->sfpr->size
14279 - htab->sfpr->output_offset
14280 - htab->sfpr->output_section->vma);
14281 else
14282 relocation = (stub_entry->stub_offset
14283 + stub_sec->output_offset
14284 + stub_sec->output_section->vma);
14285 addend = 0;
14286 reloc_dest = DEST_STUB;
14287
14288 if ((stub_entry->stub_type == ppc_stub_plt_call
14289 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14290 && (ALWAYS_EMIT_R2SAVE
14291 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14292 && rel + 1 < relend
14293 && rel[1].r_offset == rel->r_offset + 4
14294 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14295 relocation += 4;
14296 }
14297
14298 if (insn != 0)
14299 {
14300 if (is_isa_v2)
14301 {
14302 /* Set 'a' bit. This is 0b00010 in BO field for branch
14303 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14304 for branch on CTR insns (BO == 1a00t or 1a01t). */
14305 if ((insn & (0x14 << 21)) == (0x04 << 21))
14306 insn |= 0x02 << 21;
14307 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14308 insn |= 0x08 << 21;
14309 else
14310 break;
14311 }
14312 else
14313 {
14314 /* Invert 'y' bit if not the default. */
14315 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14316 insn ^= 0x01 << 21;
14317 }
14318
14319 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14320 }
14321
14322 /* NOP out calls to undefined weak functions.
14323 We can thus call a weak function without first
14324 checking whether the function is defined. */
14325 else if (h != NULL
14326 && h->elf.root.type == bfd_link_hash_undefweak
14327 && h->elf.dynindx == -1
14328 && r_type == R_PPC64_REL24
14329 && relocation == 0
14330 && addend == 0)
14331 {
14332 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14333 goto copy_reloc;
14334 }
14335 break;
14336 }
14337
14338 /* Set `addend'. */
14339 tls_type = 0;
14340 switch (r_type)
14341 {
14342 default:
14343 info->callbacks->einfo
14344 /* xgettext:c-format */
14345 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14346 input_bfd, (int) r_type, sym_name);
14347
14348 bfd_set_error (bfd_error_bad_value);
14349 ret = FALSE;
14350 goto copy_reloc;
14351
14352 case R_PPC64_NONE:
14353 case R_PPC64_TLS:
14354 case R_PPC64_TLSGD:
14355 case R_PPC64_TLSLD:
14356 case R_PPC64_TOCSAVE:
14357 case R_PPC64_GNU_VTINHERIT:
14358 case R_PPC64_GNU_VTENTRY:
14359 case R_PPC64_ENTRY:
14360 goto copy_reloc;
14361
14362 /* GOT16 relocations. Like an ADDR16 using the symbol's
14363 address in the GOT as relocation value instead of the
14364 symbol's value itself. Also, create a GOT entry for the
14365 symbol and put the symbol value there. */
14366 case R_PPC64_GOT_TLSGD16:
14367 case R_PPC64_GOT_TLSGD16_LO:
14368 case R_PPC64_GOT_TLSGD16_HI:
14369 case R_PPC64_GOT_TLSGD16_HA:
14370 tls_type = TLS_TLS | TLS_GD;
14371 goto dogot;
14372
14373 case R_PPC64_GOT_TLSLD16:
14374 case R_PPC64_GOT_TLSLD16_LO:
14375 case R_PPC64_GOT_TLSLD16_HI:
14376 case R_PPC64_GOT_TLSLD16_HA:
14377 tls_type = TLS_TLS | TLS_LD;
14378 goto dogot;
14379
14380 case R_PPC64_GOT_TPREL16_DS:
14381 case R_PPC64_GOT_TPREL16_LO_DS:
14382 case R_PPC64_GOT_TPREL16_HI:
14383 case R_PPC64_GOT_TPREL16_HA:
14384 tls_type = TLS_TLS | TLS_TPREL;
14385 goto dogot;
14386
14387 case R_PPC64_GOT_DTPREL16_DS:
14388 case R_PPC64_GOT_DTPREL16_LO_DS:
14389 case R_PPC64_GOT_DTPREL16_HI:
14390 case R_PPC64_GOT_DTPREL16_HA:
14391 tls_type = TLS_TLS | TLS_DTPREL;
14392 goto dogot;
14393
14394 case R_PPC64_GOT16:
14395 case R_PPC64_GOT16_LO:
14396 case R_PPC64_GOT16_HI:
14397 case R_PPC64_GOT16_HA:
14398 case R_PPC64_GOT16_DS:
14399 case R_PPC64_GOT16_LO_DS:
14400 dogot:
14401 {
14402 /* Relocation is to the entry for this symbol in the global
14403 offset table. */
14404 asection *got;
14405 bfd_vma *offp;
14406 bfd_vma off;
14407 unsigned long indx = 0;
14408 struct got_entry *ent;
14409
14410 if (tls_type == (TLS_TLS | TLS_LD)
14411 && (h == NULL
14412 || !h->elf.def_dynamic))
14413 ent = ppc64_tlsld_got (input_bfd);
14414 else
14415 {
14416
14417 if (h != NULL)
14418 {
14419 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14420 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14421 &h->elf)
14422 || (bfd_link_pic (info)
14423 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14424 /* This is actually a static link, or it is a
14425 -Bsymbolic link and the symbol is defined
14426 locally, or the symbol was forced to be local
14427 because of a version file. */
14428 ;
14429 else
14430 {
14431 BFD_ASSERT (h->elf.dynindx != -1);
14432 indx = h->elf.dynindx;
14433 unresolved_reloc = FALSE;
14434 }
14435 ent = h->elf.got.glist;
14436 }
14437 else
14438 {
14439 if (local_got_ents == NULL)
14440 abort ();
14441 ent = local_got_ents[r_symndx];
14442 }
14443
14444 for (; ent != NULL; ent = ent->next)
14445 if (ent->addend == orig_rel.r_addend
14446 && ent->owner == input_bfd
14447 && ent->tls_type == tls_type)
14448 break;
14449 }
14450
14451 if (ent == NULL)
14452 abort ();
14453 if (ent->is_indirect)
14454 ent = ent->got.ent;
14455 offp = &ent->got.offset;
14456 got = ppc64_elf_tdata (ent->owner)->got;
14457 if (got == NULL)
14458 abort ();
14459
14460 /* The offset must always be a multiple of 8. We use the
14461 least significant bit to record whether we have already
14462 processed this entry. */
14463 off = *offp;
14464 if ((off & 1) != 0)
14465 off &= ~1;
14466 else
14467 {
14468 /* Generate relocs for the dynamic linker, except in
14469 the case of TLSLD where we'll use one entry per
14470 module. */
14471 asection *relgot;
14472 bfd_boolean ifunc;
14473
14474 *offp = off | 1;
14475 relgot = NULL;
14476 ifunc = (h != NULL
14477 ? h->elf.type == STT_GNU_IFUNC
14478 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14479 if (ifunc)
14480 relgot = htab->elf.irelplt;
14481 else if ((bfd_link_pic (info) || indx != 0)
14482 && (h == NULL
14483 || (tls_type == (TLS_TLS | TLS_LD)
14484 && !h->elf.def_dynamic)
14485 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14486 || h->elf.root.type != bfd_link_hash_undefweak))
14487 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14488 if (relgot != NULL)
14489 {
14490 outrel.r_offset = (got->output_section->vma
14491 + got->output_offset
14492 + off);
14493 outrel.r_addend = addend;
14494 if (tls_type & (TLS_LD | TLS_GD))
14495 {
14496 outrel.r_addend = 0;
14497 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14498 if (tls_type == (TLS_TLS | TLS_GD))
14499 {
14500 loc = relgot->contents;
14501 loc += (relgot->reloc_count++
14502 * sizeof (Elf64_External_Rela));
14503 bfd_elf64_swap_reloca_out (output_bfd,
14504 &outrel, loc);
14505 outrel.r_offset += 8;
14506 outrel.r_addend = addend;
14507 outrel.r_info
14508 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14509 }
14510 }
14511 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14512 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14513 else if (tls_type == (TLS_TLS | TLS_TPREL))
14514 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14515 else if (indx != 0)
14516 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14517 else
14518 {
14519 if (ifunc)
14520 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14521 else
14522 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14523
14524 /* Write the .got section contents for the sake
14525 of prelink. */
14526 loc = got->contents + off;
14527 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14528 loc);
14529 }
14530
14531 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14532 {
14533 outrel.r_addend += relocation;
14534 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14535 {
14536 if (htab->elf.tls_sec == NULL)
14537 outrel.r_addend = 0;
14538 else
14539 outrel.r_addend -= htab->elf.tls_sec->vma;
14540 }
14541 }
14542 loc = relgot->contents;
14543 loc += (relgot->reloc_count++
14544 * sizeof (Elf64_External_Rela));
14545 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14546 }
14547
14548 /* Init the .got section contents here if we're not
14549 emitting a reloc. */
14550 else
14551 {
14552 relocation += addend;
14553 if (tls_type == (TLS_TLS | TLS_LD))
14554 relocation = 1;
14555 else if (tls_type != 0)
14556 {
14557 if (htab->elf.tls_sec == NULL)
14558 relocation = 0;
14559 else
14560 {
14561 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14562 if (tls_type == (TLS_TLS | TLS_TPREL))
14563 relocation += DTP_OFFSET - TP_OFFSET;
14564 }
14565
14566 if (tls_type == (TLS_TLS | TLS_GD))
14567 {
14568 bfd_put_64 (output_bfd, relocation,
14569 got->contents + off + 8);
14570 relocation = 1;
14571 }
14572 }
14573
14574 bfd_put_64 (output_bfd, relocation,
14575 got->contents + off);
14576 }
14577 }
14578
14579 if (off >= (bfd_vma) -2)
14580 abort ();
14581
14582 relocation = got->output_section->vma + got->output_offset + off;
14583 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14584 }
14585 break;
14586
14587 case R_PPC64_PLT16_HA:
14588 case R_PPC64_PLT16_HI:
14589 case R_PPC64_PLT16_LO:
14590 case R_PPC64_PLT32:
14591 case R_PPC64_PLT64:
14592 /* Relocation is to the entry for this symbol in the
14593 procedure linkage table. */
14594 {
14595 struct plt_entry **plt_list = NULL;
14596 if (h != NULL)
14597 plt_list = &h->elf.plt.plist;
14598 else if (local_got_ents != NULL)
14599 {
14600 struct plt_entry **local_plt = (struct plt_entry **)
14601 (local_got_ents + symtab_hdr->sh_info);
14602 unsigned char *local_got_tls_masks = (unsigned char *)
14603 (local_plt + symtab_hdr->sh_info);
14604 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14605 plt_list = local_plt + r_symndx;
14606 }
14607 if (plt_list)
14608 {
14609 struct plt_entry *ent;
14610
14611 for (ent = *plt_list; ent != NULL; ent = ent->next)
14612 if (ent->plt.offset != (bfd_vma) -1
14613 && ent->addend == orig_rel.r_addend)
14614 {
14615 asection *plt;
14616
14617 plt = htab->elf.splt;
14618 if (!htab->elf.dynamic_sections_created
14619 || h == NULL
14620 || h->elf.dynindx == -1)
14621 plt = htab->elf.iplt;
14622 relocation = (plt->output_section->vma
14623 + plt->output_offset
14624 + ent->plt.offset);
14625 addend = 0;
14626 unresolved_reloc = FALSE;
14627 break;
14628 }
14629 }
14630 }
14631 break;
14632
14633 case R_PPC64_TOC:
14634 /* Relocation value is TOC base. */
14635 relocation = TOCstart;
14636 if (r_symndx == STN_UNDEF)
14637 relocation += htab->sec_info[input_section->id].toc_off;
14638 else if (unresolved_reloc)
14639 ;
14640 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14641 relocation += htab->sec_info[sec->id].toc_off;
14642 else
14643 unresolved_reloc = TRUE;
14644 goto dodyn;
14645
14646 /* TOC16 relocs. We want the offset relative to the TOC base,
14647 which is the address of the start of the TOC plus 0x8000.
14648 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14649 in this order. */
14650 case R_PPC64_TOC16:
14651 case R_PPC64_TOC16_LO:
14652 case R_PPC64_TOC16_HI:
14653 case R_PPC64_TOC16_DS:
14654 case R_PPC64_TOC16_LO_DS:
14655 case R_PPC64_TOC16_HA:
14656 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14657 break;
14658
14659 /* Relocate against the beginning of the section. */
14660 case R_PPC64_SECTOFF:
14661 case R_PPC64_SECTOFF_LO:
14662 case R_PPC64_SECTOFF_HI:
14663 case R_PPC64_SECTOFF_DS:
14664 case R_PPC64_SECTOFF_LO_DS:
14665 case R_PPC64_SECTOFF_HA:
14666 if (sec != NULL)
14667 addend -= sec->output_section->vma;
14668 break;
14669
14670 case R_PPC64_REL16:
14671 case R_PPC64_REL16_LO:
14672 case R_PPC64_REL16_HI:
14673 case R_PPC64_REL16_HA:
14674 case R_PPC64_REL16DX_HA:
14675 break;
14676
14677 case R_PPC64_REL14:
14678 case R_PPC64_REL14_BRNTAKEN:
14679 case R_PPC64_REL14_BRTAKEN:
14680 case R_PPC64_REL24:
14681 break;
14682
14683 case R_PPC64_TPREL16:
14684 case R_PPC64_TPREL16_LO:
14685 case R_PPC64_TPREL16_HI:
14686 case R_PPC64_TPREL16_HA:
14687 case R_PPC64_TPREL16_DS:
14688 case R_PPC64_TPREL16_LO_DS:
14689 case R_PPC64_TPREL16_HIGH:
14690 case R_PPC64_TPREL16_HIGHA:
14691 case R_PPC64_TPREL16_HIGHER:
14692 case R_PPC64_TPREL16_HIGHERA:
14693 case R_PPC64_TPREL16_HIGHEST:
14694 case R_PPC64_TPREL16_HIGHESTA:
14695 if (h != NULL
14696 && h->elf.root.type == bfd_link_hash_undefweak
14697 && h->elf.dynindx == -1)
14698 {
14699 /* Make this relocation against an undefined weak symbol
14700 resolve to zero. This is really just a tweak, since
14701 code using weak externs ought to check that they are
14702 defined before using them. */
14703 bfd_byte *p = contents + rel->r_offset - d_offset;
14704
14705 insn = bfd_get_32 (input_bfd, p);
14706 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14707 if (insn != 0)
14708 bfd_put_32 (input_bfd, insn, p);
14709 break;
14710 }
14711 if (htab->elf.tls_sec != NULL)
14712 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14713 if (bfd_link_pic (info))
14714 /* The TPREL16 relocs shouldn't really be used in shared
14715 libs as they will result in DT_TEXTREL being set, but
14716 support them anyway. */
14717 goto dodyn;
14718 break;
14719
14720 case R_PPC64_DTPREL16:
14721 case R_PPC64_DTPREL16_LO:
14722 case R_PPC64_DTPREL16_HI:
14723 case R_PPC64_DTPREL16_HA:
14724 case R_PPC64_DTPREL16_DS:
14725 case R_PPC64_DTPREL16_LO_DS:
14726 case R_PPC64_DTPREL16_HIGH:
14727 case R_PPC64_DTPREL16_HIGHA:
14728 case R_PPC64_DTPREL16_HIGHER:
14729 case R_PPC64_DTPREL16_HIGHERA:
14730 case R_PPC64_DTPREL16_HIGHEST:
14731 case R_PPC64_DTPREL16_HIGHESTA:
14732 if (htab->elf.tls_sec != NULL)
14733 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14734 break;
14735
14736 case R_PPC64_ADDR64_LOCAL:
14737 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14738 ? h->elf.other
14739 : sym->st_other);
14740 break;
14741
14742 case R_PPC64_DTPMOD64:
14743 relocation = 1;
14744 addend = 0;
14745 goto dodyn;
14746
14747 case R_PPC64_TPREL64:
14748 if (htab->elf.tls_sec != NULL)
14749 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14750 goto dodyn;
14751
14752 case R_PPC64_DTPREL64:
14753 if (htab->elf.tls_sec != NULL)
14754 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14755 /* Fall through. */
14756
14757 /* Relocations that may need to be propagated if this is a
14758 dynamic object. */
14759 case R_PPC64_REL30:
14760 case R_PPC64_REL32:
14761 case R_PPC64_REL64:
14762 case R_PPC64_ADDR14:
14763 case R_PPC64_ADDR14_BRNTAKEN:
14764 case R_PPC64_ADDR14_BRTAKEN:
14765 case R_PPC64_ADDR16:
14766 case R_PPC64_ADDR16_DS:
14767 case R_PPC64_ADDR16_HA:
14768 case R_PPC64_ADDR16_HI:
14769 case R_PPC64_ADDR16_HIGH:
14770 case R_PPC64_ADDR16_HIGHA:
14771 case R_PPC64_ADDR16_HIGHER:
14772 case R_PPC64_ADDR16_HIGHERA:
14773 case R_PPC64_ADDR16_HIGHEST:
14774 case R_PPC64_ADDR16_HIGHESTA:
14775 case R_PPC64_ADDR16_LO:
14776 case R_PPC64_ADDR16_LO_DS:
14777 case R_PPC64_ADDR24:
14778 case R_PPC64_ADDR32:
14779 case R_PPC64_ADDR64:
14780 case R_PPC64_UADDR16:
14781 case R_PPC64_UADDR32:
14782 case R_PPC64_UADDR64:
14783 dodyn:
14784 if ((input_section->flags & SEC_ALLOC) == 0)
14785 break;
14786
14787 if (NO_OPD_RELOCS && is_opd)
14788 break;
14789
14790 if (bfd_link_pic (info)
14791 ? ((h != NULL && pc_dynrelocs (h))
14792 || must_be_dyn_reloc (info, r_type))
14793 : (h != NULL
14794 ? h->dyn_relocs != NULL
14795 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14796 {
14797 bfd_boolean skip, relocate;
14798 asection *sreloc;
14799 bfd_vma out_off;
14800
14801 /* When generating a dynamic object, these relocations
14802 are copied into the output file to be resolved at run
14803 time. */
14804
14805 skip = FALSE;
14806 relocate = FALSE;
14807
14808 out_off = _bfd_elf_section_offset (output_bfd, info,
14809 input_section, rel->r_offset);
14810 if (out_off == (bfd_vma) -1)
14811 skip = TRUE;
14812 else if (out_off == (bfd_vma) -2)
14813 skip = TRUE, relocate = TRUE;
14814 out_off += (input_section->output_section->vma
14815 + input_section->output_offset);
14816 outrel.r_offset = out_off;
14817 outrel.r_addend = rel->r_addend;
14818
14819 /* Optimize unaligned reloc use. */
14820 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14821 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14822 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14823 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14824 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14825 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14826 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14827 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14828 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14829
14830 if (skip)
14831 memset (&outrel, 0, sizeof outrel);
14832 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14833 && !is_opd
14834 && r_type != R_PPC64_TOC)
14835 {
14836 BFD_ASSERT (h->elf.dynindx != -1);
14837 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14838 }
14839 else
14840 {
14841 /* This symbol is local, or marked to become local,
14842 or this is an opd section reloc which must point
14843 at a local function. */
14844 outrel.r_addend += relocation;
14845 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14846 {
14847 if (is_opd && h != NULL)
14848 {
14849 /* Lie about opd entries. This case occurs
14850 when building shared libraries and we
14851 reference a function in another shared
14852 lib. The same thing happens for a weak
14853 definition in an application that's
14854 overridden by a strong definition in a
14855 shared lib. (I believe this is a generic
14856 bug in binutils handling of weak syms.)
14857 In these cases we won't use the opd
14858 entry in this lib. */
14859 unresolved_reloc = FALSE;
14860 }
14861 if (!is_opd
14862 && r_type == R_PPC64_ADDR64
14863 && (h != NULL
14864 ? h->elf.type == STT_GNU_IFUNC
14865 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14866 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14867 else
14868 {
14869 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14870
14871 /* We need to relocate .opd contents for ld.so.
14872 Prelink also wants simple and consistent rules
14873 for relocs. This make all RELATIVE relocs have
14874 *r_offset equal to r_addend. */
14875 relocate = TRUE;
14876 }
14877 }
14878 else
14879 {
14880 long indx = 0;
14881
14882 if (h != NULL
14883 ? h->elf.type == STT_GNU_IFUNC
14884 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14885 {
14886 info->callbacks->einfo
14887 /* xgettext:c-format */
14888 (_("%P: %H: %s for indirect "
14889 "function `%T' unsupported\n"),
14890 input_bfd, input_section, rel->r_offset,
14891 ppc64_elf_howto_table[r_type]->name,
14892 sym_name);
14893 ret = FALSE;
14894 }
14895 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14896 ;
14897 else if (sec == NULL || sec->owner == NULL)
14898 {
14899 bfd_set_error (bfd_error_bad_value);
14900 return FALSE;
14901 }
14902 else
14903 {
14904 asection *osec;
14905
14906 osec = sec->output_section;
14907 indx = elf_section_data (osec)->dynindx;
14908
14909 if (indx == 0)
14910 {
14911 if ((osec->flags & SEC_READONLY) == 0
14912 && htab->elf.data_index_section != NULL)
14913 osec = htab->elf.data_index_section;
14914 else
14915 osec = htab->elf.text_index_section;
14916 indx = elf_section_data (osec)->dynindx;
14917 }
14918 BFD_ASSERT (indx != 0);
14919
14920 /* We are turning this relocation into one
14921 against a section symbol, so subtract out
14922 the output section's address but not the
14923 offset of the input section in the output
14924 section. */
14925 outrel.r_addend -= osec->vma;
14926 }
14927
14928 outrel.r_info = ELF64_R_INFO (indx, r_type);
14929 }
14930 }
14931
14932 sreloc = elf_section_data (input_section)->sreloc;
14933 if (h != NULL
14934 ? h->elf.type == STT_GNU_IFUNC
14935 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14936 sreloc = htab->elf.irelplt;
14937 if (sreloc == NULL)
14938 abort ();
14939
14940 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14941 >= sreloc->size)
14942 abort ();
14943 loc = sreloc->contents;
14944 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14945 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14946
14947 /* If this reloc is against an external symbol, it will
14948 be computed at runtime, so there's no need to do
14949 anything now. However, for the sake of prelink ensure
14950 that the section contents are a known value. */
14951 if (! relocate)
14952 {
14953 unresolved_reloc = FALSE;
14954 /* The value chosen here is quite arbitrary as ld.so
14955 ignores section contents except for the special
14956 case of .opd where the contents might be accessed
14957 before relocation. Choose zero, as that won't
14958 cause reloc overflow. */
14959 relocation = 0;
14960 addend = 0;
14961 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14962 to improve backward compatibility with older
14963 versions of ld. */
14964 if (r_type == R_PPC64_ADDR64)
14965 addend = outrel.r_addend;
14966 /* Adjust pc_relative relocs to have zero in *r_offset. */
14967 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14968 addend = (input_section->output_section->vma
14969 + input_section->output_offset
14970 + rel->r_offset);
14971 }
14972 }
14973 break;
14974
14975 case R_PPC64_COPY:
14976 case R_PPC64_GLOB_DAT:
14977 case R_PPC64_JMP_SLOT:
14978 case R_PPC64_JMP_IREL:
14979 case R_PPC64_RELATIVE:
14980 /* We shouldn't ever see these dynamic relocs in relocatable
14981 files. */
14982 /* Fall through. */
14983
14984 case R_PPC64_PLTGOT16:
14985 case R_PPC64_PLTGOT16_DS:
14986 case R_PPC64_PLTGOT16_HA:
14987 case R_PPC64_PLTGOT16_HI:
14988 case R_PPC64_PLTGOT16_LO:
14989 case R_PPC64_PLTGOT16_LO_DS:
14990 case R_PPC64_PLTREL32:
14991 case R_PPC64_PLTREL64:
14992 /* These ones haven't been implemented yet. */
14993
14994 info->callbacks->einfo
14995 /* xgettext:c-format */
14996 (_("%P: %B: %s is not supported for `%T'\n"),
14997 input_bfd,
14998 ppc64_elf_howto_table[r_type]->name, sym_name);
14999
15000 bfd_set_error (bfd_error_invalid_operation);
15001 ret = FALSE;
15002 goto copy_reloc;
15003 }
15004
15005 /* Multi-instruction sequences that access the TOC can be
15006 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15007 to nop; addi rb,r2,x; */
15008 switch (r_type)
15009 {
15010 default:
15011 break;
15012
15013 case R_PPC64_GOT_TLSLD16_HI:
15014 case R_PPC64_GOT_TLSGD16_HI:
15015 case R_PPC64_GOT_TPREL16_HI:
15016 case R_PPC64_GOT_DTPREL16_HI:
15017 case R_PPC64_GOT16_HI:
15018 case R_PPC64_TOC16_HI:
15019 /* These relocs would only be useful if building up an
15020 offset to later add to r2, perhaps in an indexed
15021 addressing mode instruction. Don't try to optimize.
15022 Unfortunately, the possibility of someone building up an
15023 offset like this or even with the HA relocs, means that
15024 we need to check the high insn when optimizing the low
15025 insn. */
15026 break;
15027
15028 case R_PPC64_GOT_TLSLD16_HA:
15029 case R_PPC64_GOT_TLSGD16_HA:
15030 case R_PPC64_GOT_TPREL16_HA:
15031 case R_PPC64_GOT_DTPREL16_HA:
15032 case R_PPC64_GOT16_HA:
15033 case R_PPC64_TOC16_HA:
15034 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15035 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15036 {
15037 bfd_byte *p = contents + (rel->r_offset & ~3);
15038 bfd_put_32 (input_bfd, NOP, p);
15039 }
15040 break;
15041
15042 case R_PPC64_GOT_TLSLD16_LO:
15043 case R_PPC64_GOT_TLSGD16_LO:
15044 case R_PPC64_GOT_TPREL16_LO_DS:
15045 case R_PPC64_GOT_DTPREL16_LO_DS:
15046 case R_PPC64_GOT16_LO:
15047 case R_PPC64_GOT16_LO_DS:
15048 case R_PPC64_TOC16_LO:
15049 case R_PPC64_TOC16_LO_DS:
15050 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15051 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15052 {
15053 bfd_byte *p = contents + (rel->r_offset & ~3);
15054 insn = bfd_get_32 (input_bfd, p);
15055 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15056 {
15057 /* Transform addic to addi when we change reg. */
15058 insn &= ~((0x3f << 26) | (0x1f << 16));
15059 insn |= (14u << 26) | (2 << 16);
15060 }
15061 else
15062 {
15063 insn &= ~(0x1f << 16);
15064 insn |= 2 << 16;
15065 }
15066 bfd_put_32 (input_bfd, insn, p);
15067 }
15068 break;
15069 }
15070
15071 /* Do any further special processing. */
15072 howto = ppc64_elf_howto_table[(int) r_type];
15073 switch (r_type)
15074 {
15075 default:
15076 break;
15077
15078 case R_PPC64_REL16_HA:
15079 case R_PPC64_REL16DX_HA:
15080 case R_PPC64_ADDR16_HA:
15081 case R_PPC64_ADDR16_HIGHA:
15082 case R_PPC64_ADDR16_HIGHERA:
15083 case R_PPC64_ADDR16_HIGHESTA:
15084 case R_PPC64_TOC16_HA:
15085 case R_PPC64_SECTOFF_HA:
15086 case R_PPC64_TPREL16_HA:
15087 case R_PPC64_TPREL16_HIGHA:
15088 case R_PPC64_TPREL16_HIGHERA:
15089 case R_PPC64_TPREL16_HIGHESTA:
15090 case R_PPC64_DTPREL16_HA:
15091 case R_PPC64_DTPREL16_HIGHA:
15092 case R_PPC64_DTPREL16_HIGHERA:
15093 case R_PPC64_DTPREL16_HIGHESTA:
15094 /* It's just possible that this symbol is a weak symbol
15095 that's not actually defined anywhere. In that case,
15096 'sec' would be NULL, and we should leave the symbol
15097 alone (it will be set to zero elsewhere in the link). */
15098 if (sec == NULL)
15099 break;
15100 /* Fall through. */
15101
15102 case R_PPC64_GOT16_HA:
15103 case R_PPC64_PLTGOT16_HA:
15104 case R_PPC64_PLT16_HA:
15105 case R_PPC64_GOT_TLSGD16_HA:
15106 case R_PPC64_GOT_TLSLD16_HA:
15107 case R_PPC64_GOT_TPREL16_HA:
15108 case R_PPC64_GOT_DTPREL16_HA:
15109 /* Add 0x10000 if sign bit in 0:15 is set.
15110 Bits 0:15 are not used. */
15111 addend += 0x8000;
15112 break;
15113
15114 case R_PPC64_ADDR16_DS:
15115 case R_PPC64_ADDR16_LO_DS:
15116 case R_PPC64_GOT16_DS:
15117 case R_PPC64_GOT16_LO_DS:
15118 case R_PPC64_PLT16_LO_DS:
15119 case R_PPC64_SECTOFF_DS:
15120 case R_PPC64_SECTOFF_LO_DS:
15121 case R_PPC64_TOC16_DS:
15122 case R_PPC64_TOC16_LO_DS:
15123 case R_PPC64_PLTGOT16_DS:
15124 case R_PPC64_PLTGOT16_LO_DS:
15125 case R_PPC64_GOT_TPREL16_DS:
15126 case R_PPC64_GOT_TPREL16_LO_DS:
15127 case R_PPC64_GOT_DTPREL16_DS:
15128 case R_PPC64_GOT_DTPREL16_LO_DS:
15129 case R_PPC64_TPREL16_DS:
15130 case R_PPC64_TPREL16_LO_DS:
15131 case R_PPC64_DTPREL16_DS:
15132 case R_PPC64_DTPREL16_LO_DS:
15133 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15134 mask = 3;
15135 /* If this reloc is against an lq, lxv, or stxv insn, then
15136 the value must be a multiple of 16. This is somewhat of
15137 a hack, but the "correct" way to do this by defining _DQ
15138 forms of all the _DS relocs bloats all reloc switches in
15139 this file. It doesn't make much sense to use these
15140 relocs in data, so testing the insn should be safe. */
15141 if ((insn & (0x3f << 26)) == (56u << 26)
15142 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15143 mask = 15;
15144 relocation += addend;
15145 addend = insn & (mask ^ 3);
15146 if ((relocation & mask) != 0)
15147 {
15148 relocation ^= relocation & mask;
15149 info->callbacks->einfo
15150 /* xgettext:c-format */
15151 (_("%P: %H: error: %s not a multiple of %u\n"),
15152 input_bfd, input_section, rel->r_offset,
15153 howto->name,
15154 mask + 1);
15155 bfd_set_error (bfd_error_bad_value);
15156 ret = FALSE;
15157 goto copy_reloc;
15158 }
15159 break;
15160 }
15161
15162 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15163 because such sections are not SEC_ALLOC and thus ld.so will
15164 not process them. */
15165 if (unresolved_reloc
15166 && !((input_section->flags & SEC_DEBUGGING) != 0
15167 && h->elf.def_dynamic)
15168 && _bfd_elf_section_offset (output_bfd, info, input_section,
15169 rel->r_offset) != (bfd_vma) -1)
15170 {
15171 info->callbacks->einfo
15172 /* xgettext:c-format */
15173 (_("%P: %H: unresolvable %s against `%T'\n"),
15174 input_bfd, input_section, rel->r_offset,
15175 howto->name,
15176 h->elf.root.root.string);
15177 ret = FALSE;
15178 }
15179
15180 /* 16-bit fields in insns mostly have signed values, but a
15181 few insns have 16-bit unsigned values. Really, we should
15182 have different reloc types. */
15183 if (howto->complain_on_overflow != complain_overflow_dont
15184 && howto->dst_mask == 0xffff
15185 && (input_section->flags & SEC_CODE) != 0)
15186 {
15187 enum complain_overflow complain = complain_overflow_signed;
15188
15189 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15190 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15191 complain = complain_overflow_bitfield;
15192 else if (howto->rightshift == 0
15193 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15194 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15195 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15196 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15197 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15198 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15199 complain = complain_overflow_unsigned;
15200 if (howto->complain_on_overflow != complain)
15201 {
15202 alt_howto = *howto;
15203 alt_howto.complain_on_overflow = complain;
15204 howto = &alt_howto;
15205 }
15206 }
15207
15208 if (r_type == R_PPC64_REL16DX_HA)
15209 {
15210 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15211 if (rel->r_offset + 4 > input_section->size)
15212 r = bfd_reloc_outofrange;
15213 else
15214 {
15215 relocation += addend;
15216 relocation -= (rel->r_offset
15217 + input_section->output_offset
15218 + input_section->output_section->vma);
15219 relocation = (bfd_signed_vma) relocation >> 16;
15220 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15221 insn &= ~0x1fffc1;
15222 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15223 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15224 r = bfd_reloc_ok;
15225 if (relocation + 0x8000 > 0xffff)
15226 r = bfd_reloc_overflow;
15227 }
15228 }
15229 else
15230 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15231 rel->r_offset, relocation, addend);
15232
15233 if (r != bfd_reloc_ok)
15234 {
15235 char *more_info = NULL;
15236 const char *reloc_name = howto->name;
15237
15238 if (reloc_dest != DEST_NORMAL)
15239 {
15240 more_info = bfd_malloc (strlen (reloc_name) + 8);
15241 if (more_info != NULL)
15242 {
15243 strcpy (more_info, reloc_name);
15244 strcat (more_info, (reloc_dest == DEST_OPD
15245 ? " (OPD)" : " (stub)"));
15246 reloc_name = more_info;
15247 }
15248 }
15249
15250 if (r == bfd_reloc_overflow)
15251 {
15252 /* On code like "if (foo) foo();" don't report overflow
15253 on a branch to zero when foo is undefined. */
15254 if (!warned
15255 && (reloc_dest == DEST_STUB
15256 || !(h != NULL
15257 && (h->elf.root.type == bfd_link_hash_undefweak
15258 || h->elf.root.type == bfd_link_hash_undefined)
15259 && is_branch_reloc (r_type))))
15260 info->callbacks->reloc_overflow (info, &h->elf.root,
15261 sym_name, reloc_name,
15262 orig_rel.r_addend,
15263 input_bfd, input_section,
15264 rel->r_offset);
15265 }
15266 else
15267 {
15268 info->callbacks->einfo
15269 /* xgettext:c-format */
15270 (_("%P: %H: %s against `%T': error %d\n"),
15271 input_bfd, input_section, rel->r_offset,
15272 reloc_name, sym_name, (int) r);
15273 ret = FALSE;
15274 }
15275 if (more_info != NULL)
15276 free (more_info);
15277 }
15278 copy_reloc:
15279 if (wrel != rel)
15280 *wrel = *rel;
15281 }
15282
15283 if (wrel != rel)
15284 {
15285 Elf_Internal_Shdr *rel_hdr;
15286 size_t deleted = rel - wrel;
15287
15288 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15289 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15290 if (rel_hdr->sh_size == 0)
15291 {
15292 /* It is too late to remove an empty reloc section. Leave
15293 one NONE reloc.
15294 ??? What is wrong with an empty section??? */
15295 rel_hdr->sh_size = rel_hdr->sh_entsize;
15296 deleted -= 1;
15297 }
15298 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15299 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15300 input_section->reloc_count -= deleted;
15301 }
15302
15303 /* If we're emitting relocations, then shortly after this function
15304 returns, reloc offsets and addends for this section will be
15305 adjusted. Worse, reloc symbol indices will be for the output
15306 file rather than the input. Save a copy of the relocs for
15307 opd_entry_value. */
15308 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15309 {
15310 bfd_size_type amt;
15311 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15312 rel = bfd_alloc (input_bfd, amt);
15313 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15314 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15315 if (rel == NULL)
15316 return FALSE;
15317 memcpy (rel, relocs, amt);
15318 }
15319 return ret;
15320 }
15321
15322 /* Adjust the value of any local symbols in opd sections. */
15323
15324 static int
15325 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15326 const char *name ATTRIBUTE_UNUSED,
15327 Elf_Internal_Sym *elfsym,
15328 asection *input_sec,
15329 struct elf_link_hash_entry *h)
15330 {
15331 struct _opd_sec_data *opd;
15332 long adjust;
15333 bfd_vma value;
15334
15335 if (h != NULL)
15336 return 1;
15337
15338 opd = get_opd_info (input_sec);
15339 if (opd == NULL || opd->adjust == NULL)
15340 return 1;
15341
15342 value = elfsym->st_value - input_sec->output_offset;
15343 if (!bfd_link_relocatable (info))
15344 value -= input_sec->output_section->vma;
15345
15346 adjust = opd->adjust[OPD_NDX (value)];
15347 if (adjust == -1)
15348 return 2;
15349
15350 elfsym->st_value += adjust;
15351 return 1;
15352 }
15353
15354 /* Finish up dynamic symbol handling. We set the contents of various
15355 dynamic sections here. */
15356
15357 static bfd_boolean
15358 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15359 struct bfd_link_info *info,
15360 struct elf_link_hash_entry *h,
15361 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15362 {
15363 struct ppc_link_hash_table *htab;
15364 struct plt_entry *ent;
15365 Elf_Internal_Rela rela;
15366 bfd_byte *loc;
15367
15368 htab = ppc_hash_table (info);
15369 if (htab == NULL)
15370 return FALSE;
15371
15372 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15373 if (ent->plt.offset != (bfd_vma) -1)
15374 {
15375 /* This symbol has an entry in the procedure linkage
15376 table. Set it up. */
15377 if (!htab->elf.dynamic_sections_created
15378 || h->dynindx == -1)
15379 {
15380 BFD_ASSERT (h->type == STT_GNU_IFUNC
15381 && h->def_regular
15382 && (h->root.type == bfd_link_hash_defined
15383 || h->root.type == bfd_link_hash_defweak));
15384 rela.r_offset = (htab->elf.iplt->output_section->vma
15385 + htab->elf.iplt->output_offset
15386 + ent->plt.offset);
15387 if (htab->opd_abi)
15388 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15389 else
15390 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15391 rela.r_addend = (h->root.u.def.value
15392 + h->root.u.def.section->output_offset
15393 + h->root.u.def.section->output_section->vma
15394 + ent->addend);
15395 loc = (htab->elf.irelplt->contents
15396 + (htab->elf.irelplt->reloc_count++
15397 * sizeof (Elf64_External_Rela)));
15398 }
15399 else
15400 {
15401 rela.r_offset = (htab->elf.splt->output_section->vma
15402 + htab->elf.splt->output_offset
15403 + ent->plt.offset);
15404 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15405 rela.r_addend = ent->addend;
15406 loc = (htab->elf.srelplt->contents
15407 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15408 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15409 }
15410 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15411
15412 if (!htab->opd_abi)
15413 {
15414 if (!h->def_regular)
15415 {
15416 /* Mark the symbol as undefined, rather than as
15417 defined in glink. Leave the value if there were
15418 any relocations where pointer equality matters
15419 (this is a clue for the dynamic linker, to make
15420 function pointer comparisons work between an
15421 application and shared library), otherwise set it
15422 to zero. */
15423 sym->st_shndx = SHN_UNDEF;
15424 if (!h->pointer_equality_needed)
15425 sym->st_value = 0;
15426 else if (!h->ref_regular_nonweak)
15427 {
15428 /* This breaks function pointer comparisons, but
15429 that is better than breaking tests for a NULL
15430 function pointer. */
15431 sym->st_value = 0;
15432 }
15433 }
15434 }
15435 }
15436
15437 if (h->needs_copy)
15438 {
15439 /* This symbol needs a copy reloc. Set it up. */
15440
15441 if (h->dynindx == -1
15442 || (h->root.type != bfd_link_hash_defined
15443 && h->root.type != bfd_link_hash_defweak)
15444 || htab->relbss == NULL)
15445 abort ();
15446
15447 rela.r_offset = (h->root.u.def.value
15448 + h->root.u.def.section->output_section->vma
15449 + h->root.u.def.section->output_offset);
15450 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15451 rela.r_addend = 0;
15452 loc = htab->relbss->contents;
15453 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15454 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15455 }
15456
15457 return TRUE;
15458 }
15459
15460 /* Used to decide how to sort relocs in an optimal manner for the
15461 dynamic linker, before writing them out. */
15462
15463 static enum elf_reloc_type_class
15464 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15465 const asection *rel_sec,
15466 const Elf_Internal_Rela *rela)
15467 {
15468 enum elf_ppc64_reloc_type r_type;
15469 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15470
15471 if (rel_sec == htab->elf.irelplt)
15472 return reloc_class_ifunc;
15473
15474 r_type = ELF64_R_TYPE (rela->r_info);
15475 switch (r_type)
15476 {
15477 case R_PPC64_RELATIVE:
15478 return reloc_class_relative;
15479 case R_PPC64_JMP_SLOT:
15480 return reloc_class_plt;
15481 case R_PPC64_COPY:
15482 return reloc_class_copy;
15483 default:
15484 return reloc_class_normal;
15485 }
15486 }
15487
15488 /* Finish up the dynamic sections. */
15489
15490 static bfd_boolean
15491 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15492 struct bfd_link_info *info)
15493 {
15494 struct ppc_link_hash_table *htab;
15495 bfd *dynobj;
15496 asection *sdyn;
15497
15498 htab = ppc_hash_table (info);
15499 if (htab == NULL)
15500 return FALSE;
15501
15502 dynobj = htab->elf.dynobj;
15503 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15504
15505 if (htab->elf.dynamic_sections_created)
15506 {
15507 Elf64_External_Dyn *dyncon, *dynconend;
15508
15509 if (sdyn == NULL || htab->elf.sgot == NULL)
15510 abort ();
15511
15512 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15513 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15514 for (; dyncon < dynconend; dyncon++)
15515 {
15516 Elf_Internal_Dyn dyn;
15517 asection *s;
15518
15519 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15520
15521 switch (dyn.d_tag)
15522 {
15523 default:
15524 continue;
15525
15526 case DT_PPC64_GLINK:
15527 s = htab->glink;
15528 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15529 /* We stupidly defined DT_PPC64_GLINK to be the start
15530 of glink rather than the first entry point, which is
15531 what ld.so needs, and now have a bigger stub to
15532 support automatic multiple TOCs. */
15533 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15534 break;
15535
15536 case DT_PPC64_OPD:
15537 s = bfd_get_section_by_name (output_bfd, ".opd");
15538 if (s == NULL)
15539 continue;
15540 dyn.d_un.d_ptr = s->vma;
15541 break;
15542
15543 case DT_PPC64_OPT:
15544 if (htab->do_multi_toc && htab->multi_toc_needed)
15545 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15546 break;
15547
15548 case DT_PPC64_OPDSZ:
15549 s = bfd_get_section_by_name (output_bfd, ".opd");
15550 if (s == NULL)
15551 continue;
15552 dyn.d_un.d_val = s->size;
15553 break;
15554
15555 case DT_PLTGOT:
15556 s = htab->elf.splt;
15557 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15558 break;
15559
15560 case DT_JMPREL:
15561 s = htab->elf.srelplt;
15562 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15563 break;
15564
15565 case DT_PLTRELSZ:
15566 dyn.d_un.d_val = htab->elf.srelplt->size;
15567 break;
15568 }
15569
15570 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15571 }
15572 }
15573
15574 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15575 {
15576 /* Fill in the first entry in the global offset table.
15577 We use it to hold the link-time TOCbase. */
15578 bfd_put_64 (output_bfd,
15579 elf_gp (output_bfd) + TOC_BASE_OFF,
15580 htab->elf.sgot->contents);
15581
15582 /* Set .got entry size. */
15583 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15584 }
15585
15586 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15587 {
15588 /* Set .plt entry size. */
15589 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15590 = PLT_ENTRY_SIZE (htab);
15591 }
15592
15593 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15594 brlt ourselves if emitrelocations. */
15595 if (htab->brlt != NULL
15596 && htab->brlt->reloc_count != 0
15597 && !_bfd_elf_link_output_relocs (output_bfd,
15598 htab->brlt,
15599 elf_section_data (htab->brlt)->rela.hdr,
15600 elf_section_data (htab->brlt)->relocs,
15601 NULL))
15602 return FALSE;
15603
15604 if (htab->glink != NULL
15605 && htab->glink->reloc_count != 0
15606 && !_bfd_elf_link_output_relocs (output_bfd,
15607 htab->glink,
15608 elf_section_data (htab->glink)->rela.hdr,
15609 elf_section_data (htab->glink)->relocs,
15610 NULL))
15611 return FALSE;
15612
15613 if (htab->glink_eh_frame != NULL
15614 && htab->glink_eh_frame->size != 0)
15615 {
15616 bfd_vma val;
15617 bfd_byte *p;
15618 asection *stub_sec;
15619
15620 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15621 for (stub_sec = htab->params->stub_bfd->sections;
15622 stub_sec != NULL;
15623 stub_sec = stub_sec->next)
15624 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15625 {
15626 /* FDE length. */
15627 p += 4;
15628 /* CIE pointer. */
15629 p += 4;
15630 /* Offset to stub section. */
15631 val = (stub_sec->output_section->vma
15632 + stub_sec->output_offset);
15633 val -= (htab->glink_eh_frame->output_section->vma
15634 + htab->glink_eh_frame->output_offset
15635 + (p - htab->glink_eh_frame->contents));
15636 if (val + 0x80000000 > 0xffffffff)
15637 {
15638 info->callbacks->einfo
15639 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15640 stub_sec->name);
15641 return FALSE;
15642 }
15643 bfd_put_32 (dynobj, val, p);
15644 p += 4;
15645 /* stub section size. */
15646 p += 4;
15647 /* Augmentation. */
15648 p += 1;
15649 /* Pad. */
15650 p += 7;
15651 }
15652 if (htab->glink != NULL && htab->glink->size != 0)
15653 {
15654 /* FDE length. */
15655 p += 4;
15656 /* CIE pointer. */
15657 p += 4;
15658 /* Offset to .glink. */
15659 val = (htab->glink->output_section->vma
15660 + htab->glink->output_offset
15661 + 8);
15662 val -= (htab->glink_eh_frame->output_section->vma
15663 + htab->glink_eh_frame->output_offset
15664 + (p - htab->glink_eh_frame->contents));
15665 if (val + 0x80000000 > 0xffffffff)
15666 {
15667 info->callbacks->einfo
15668 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15669 htab->glink->name);
15670 return FALSE;
15671 }
15672 bfd_put_32 (dynobj, val, p);
15673 p += 4;
15674 /* .glink size. */
15675 p += 4;
15676 /* Augmentation. */
15677 p += 1;
15678 /* Ops. */
15679 p += 7;
15680 }
15681
15682 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15683 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15684 htab->glink_eh_frame,
15685 htab->glink_eh_frame->contents))
15686 return FALSE;
15687 }
15688
15689 /* We need to handle writing out multiple GOT sections ourselves,
15690 since we didn't add them to DYNOBJ. We know dynobj is the first
15691 bfd. */
15692 while ((dynobj = dynobj->link.next) != NULL)
15693 {
15694 asection *s;
15695
15696 if (!is_ppc64_elf (dynobj))
15697 continue;
15698
15699 s = ppc64_elf_tdata (dynobj)->got;
15700 if (s != NULL
15701 && s->size != 0
15702 && s->output_section != bfd_abs_section_ptr
15703 && !bfd_set_section_contents (output_bfd, s->output_section,
15704 s->contents, s->output_offset,
15705 s->size))
15706 return FALSE;
15707 s = ppc64_elf_tdata (dynobj)->relgot;
15708 if (s != NULL
15709 && s->size != 0
15710 && s->output_section != bfd_abs_section_ptr
15711 && !bfd_set_section_contents (output_bfd, s->output_section,
15712 s->contents, s->output_offset,
15713 s->size))
15714 return FALSE;
15715 }
15716
15717 return TRUE;
15718 }
15719
15720 #include "elf64-target.h"
15721
15722 /* FreeBSD support */
15723
15724 #undef TARGET_LITTLE_SYM
15725 #undef TARGET_LITTLE_NAME
15726
15727 #undef TARGET_BIG_SYM
15728 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15729 #undef TARGET_BIG_NAME
15730 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15731
15732 #undef ELF_OSABI
15733 #define ELF_OSABI ELFOSABI_FREEBSD
15734
15735 #undef elf64_bed
15736 #define elf64_bed elf64_powerpc_fbsd_bed
15737
15738 #include "elf64-target.h"
15739
GDB Binutils - Deliverables
This page took 0.472733 seconds and 5 git commands to generate.