projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Return void from linker callbacks
[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_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
89
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_before_check_relocs
98 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
108 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
110 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
120
121 /* The name of the dynamic interpreter. This is put in the .interp
122 section. */
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
124
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
127
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
130
131 /* Offsets to some stack save slots. */
132 #define STK_LR 16
133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
134 /* This one is dodgy. ELFv2 does not have a linker word, so use the
135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
138
139 /* TOC base pointers offset from start of TOC. */
140 #define TOC_BASE_OFF 0x8000
141 /* TOC base alignment. */
142 #define TOC_BASE_ALIGN 256
143
144 /* Offset of tp and dtp pointers from start of TLS block. */
145 #define TP_OFFSET 0x7000
146 #define DTP_OFFSET 0x8000
147
148 /* .plt call stub instructions. The normal stub is like this, but
149 sometimes the .plt entry crosses a 64k boundary and we need to
150 insert an addi to adjust r11. */
151 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
152 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
153 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
154 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
155 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
156 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
157 #define BCTR 0x4e800420 /* bctr */
158
159 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
160 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
161 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
162
163 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
164 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
165 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
166 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
167 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
168 #define BNECTR 0x4ca20420 /* bnectr+ */
169 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
170
171 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
172 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
173 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
174
175 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
176 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
177 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
178
179 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
180 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
181 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
182 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
183 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
184
185 /* glink call stub instructions. We enter with the index in R0. */
186 #define GLINK_CALL_STUB_SIZE (16*4)
187 /* 0: */
188 /* .quad plt0-1f */
189 /* __glink: */
190 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
191 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
192 /* 1: */
193 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
194 /* ld %2,(0b-1b)(%11) */
195 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
196 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
197 /* ld %12,0(%11) */
198 /* ld %2,8(%11) */
199 /* mtctr %12 */
200 /* ld %11,16(%11) */
201 /* bctr */
202 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
203 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
204 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
205 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
206 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
207
208 /* Pad with this. */
209 #define NOP 0x60000000
210
211 /* Some other nops. */
212 #define CROR_151515 0x4def7b82
213 #define CROR_313131 0x4ffffb82
214
215 /* .glink entries for the first 32k functions are two instructions. */
216 #define LI_R0_0 0x38000000 /* li %r0,0 */
217 #define B_DOT 0x48000000 /* b . */
218
219 /* After that, we need two instructions to load the index, followed by
220 a branch. */
221 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
222 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
223
224 /* Instructions used by the save and restore reg functions. */
225 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
226 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
227 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
228 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
229 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
230 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
231 #define LI_R12_0 0x39800000 /* li %r12,0 */
232 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
233 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
234 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
235 #define BLR 0x4e800020 /* blr */
236
237 /* Since .opd is an array of descriptors and each entry will end up
238 with identical R_PPC64_RELATIVE relocs, there is really no need to
239 propagate .opd relocs; The dynamic linker should be taught to
240 relocate .opd without reloc entries. */
241 #ifndef NO_OPD_RELOCS
242 #define NO_OPD_RELOCS 0
243 #endif
244
245 #ifndef ARRAY_SIZE
246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
247 #endif
248
249 static inline int
250 abiversion (bfd *abfd)
251 {
252 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
253 }
254
255 static inline void
256 set_abiversion (bfd *abfd, int ver)
257 {
258 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
259 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
260 }
261 \f
262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
263
264 /* Relocation HOWTO's. */
265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
266
267 static reloc_howto_type ppc64_elf_howto_raw[] = {
268 /* This reloc does nothing. */
269 HOWTO (R_PPC64_NONE, /* type */
270 0, /* rightshift */
271 3, /* size (0 = byte, 1 = short, 2 = long) */
272 0, /* bitsize */
273 FALSE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_dont, /* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_PPC64_NONE", /* name */
278 FALSE, /* partial_inplace */
279 0, /* src_mask */
280 0, /* dst_mask */
281 FALSE), /* pcrel_offset */
282
283 /* A standard 32 bit relocation. */
284 HOWTO (R_PPC64_ADDR32, /* type */
285 0, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 32, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_bitfield, /* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_PPC64_ADDR32", /* name */
293 FALSE, /* partial_inplace */
294 0, /* src_mask */
295 0xffffffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* An absolute 26 bit branch; the lower two bits must be zero.
299 FIXME: we don't check that, we just clear them. */
300 HOWTO (R_PPC64_ADDR24, /* type */
301 0, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 26, /* bitsize */
304 FALSE, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_PPC64_ADDR24", /* name */
309 FALSE, /* partial_inplace */
310 0, /* src_mask */
311 0x03fffffc, /* dst_mask */
312 FALSE), /* pcrel_offset */
313
314 /* A standard 16 bit relocation. */
315 HOWTO (R_PPC64_ADDR16, /* type */
316 0, /* rightshift */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
318 16, /* bitsize */
319 FALSE, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_bitfield, /* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_PPC64_ADDR16", /* name */
324 FALSE, /* partial_inplace */
325 0, /* src_mask */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328
329 /* A 16 bit relocation without overflow. */
330 HOWTO (R_PPC64_ADDR16_LO, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_dont,/* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_PPC64_ADDR16_LO", /* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343
344 /* Bits 16-31 of an address. */
345 HOWTO (R_PPC64_ADDR16_HI, /* type */
346 16, /* rightshift */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
348 16, /* bitsize */
349 FALSE, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_signed, /* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_PPC64_ADDR16_HI", /* name */
354 FALSE, /* partial_inplace */
355 0, /* src_mask */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358
359 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
360 bits, treated as a signed number, is negative. */
361 HOWTO (R_PPC64_ADDR16_HA, /* type */
362 16, /* rightshift */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_signed, /* complain_on_overflow */
368 ppc64_elf_ha_reloc, /* special_function */
369 "R_PPC64_ADDR16_HA", /* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0xffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* An absolute 16 bit branch; the lower two bits must be zero.
376 FIXME: we don't check that, we just clear them. */
377 HOWTO (R_PPC64_ADDR14, /* type */
378 0, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 16, /* bitsize */
381 FALSE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_signed, /* complain_on_overflow */
384 ppc64_elf_branch_reloc, /* special_function */
385 "R_PPC64_ADDR14", /* name */
386 FALSE, /* partial_inplace */
387 0, /* src_mask */
388 0x0000fffc, /* dst_mask */
389 FALSE), /* pcrel_offset */
390
391 /* An absolute 16 bit branch, for which bit 10 should be set to
392 indicate that the branch is expected to be taken. The lower two
393 bits must be zero. */
394 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 16, /* bitsize */
398 FALSE, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_signed, /* complain_on_overflow */
401 ppc64_elf_brtaken_reloc, /* special_function */
402 "R_PPC64_ADDR14_BRTAKEN",/* name */
403 FALSE, /* partial_inplace */
404 0, /* src_mask */
405 0x0000fffc, /* dst_mask */
406 FALSE), /* pcrel_offset */
407
408 /* An absolute 16 bit branch, for which bit 10 should be set to
409 indicate that the branch is not expected to be taken. The lower
410 two bits must be zero. */
411 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
412 0, /* rightshift */
413 2, /* size (0 = byte, 1 = short, 2 = long) */
414 16, /* bitsize */
415 FALSE, /* pc_relative */
416 0, /* bitpos */
417 complain_overflow_signed, /* complain_on_overflow */
418 ppc64_elf_brtaken_reloc, /* special_function */
419 "R_PPC64_ADDR14_BRNTAKEN",/* name */
420 FALSE, /* partial_inplace */
421 0, /* src_mask */
422 0x0000fffc, /* dst_mask */
423 FALSE), /* pcrel_offset */
424
425 /* A relative 26 bit branch; the lower two bits must be zero. */
426 HOWTO (R_PPC64_REL24, /* type */
427 0, /* rightshift */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
429 26, /* bitsize */
430 TRUE, /* pc_relative */
431 0, /* bitpos */
432 complain_overflow_signed, /* complain_on_overflow */
433 ppc64_elf_branch_reloc, /* special_function */
434 "R_PPC64_REL24", /* name */
435 FALSE, /* partial_inplace */
436 0, /* src_mask */
437 0x03fffffc, /* dst_mask */
438 TRUE), /* pcrel_offset */
439
440 /* A relative 16 bit branch; the lower two bits must be zero. */
441 HOWTO (R_PPC64_REL14, /* type */
442 0, /* rightshift */
443 2, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
445 TRUE, /* pc_relative */
446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_branch_reloc, /* special_function */
449 "R_PPC64_REL14", /* name */
450 FALSE, /* partial_inplace */
451 0, /* src_mask */
452 0x0000fffc, /* dst_mask */
453 TRUE), /* pcrel_offset */
454
455 /* A relative 16 bit branch. Bit 10 should be set to indicate that
456 the branch is expected to be taken. The lower two bits must be
457 zero. */
458 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
459 0, /* rightshift */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
461 16, /* bitsize */
462 TRUE, /* pc_relative */
463 0, /* bitpos */
464 complain_overflow_signed, /* complain_on_overflow */
465 ppc64_elf_brtaken_reloc, /* special_function */
466 "R_PPC64_REL14_BRTAKEN", /* name */
467 FALSE, /* partial_inplace */
468 0, /* src_mask */
469 0x0000fffc, /* dst_mask */
470 TRUE), /* pcrel_offset */
471
472 /* A relative 16 bit branch. Bit 10 should be set to indicate that
473 the branch is not expected to be taken. The lower two bits must
474 be zero. */
475 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
476 0, /* rightshift */
477 2, /* size (0 = byte, 1 = short, 2 = long) */
478 16, /* bitsize */
479 TRUE, /* pc_relative */
480 0, /* bitpos */
481 complain_overflow_signed, /* complain_on_overflow */
482 ppc64_elf_brtaken_reloc, /* special_function */
483 "R_PPC64_REL14_BRNTAKEN",/* name */
484 FALSE, /* partial_inplace */
485 0, /* src_mask */
486 0x0000fffc, /* dst_mask */
487 TRUE), /* pcrel_offset */
488
489 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
490 symbol. */
491 HOWTO (R_PPC64_GOT16, /* type */
492 0, /* rightshift */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 FALSE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_unhandled_reloc, /* special_function */
499 "R_PPC64_GOT16", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
504
505 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
506 the symbol. */
507 HOWTO (R_PPC64_GOT16_LO, /* type */
508 0, /* rightshift */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
510 16, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_dont, /* complain_on_overflow */
514 ppc64_elf_unhandled_reloc, /* special_function */
515 "R_PPC64_GOT16_LO", /* name */
516 FALSE, /* partial_inplace */
517 0, /* src_mask */
518 0xffff, /* dst_mask */
519 FALSE), /* pcrel_offset */
520
521 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
522 the symbol. */
523 HOWTO (R_PPC64_GOT16_HI, /* type */
524 16, /* rightshift */
525 1, /* size (0 = byte, 1 = short, 2 = long) */
526 16, /* bitsize */
527 FALSE, /* pc_relative */
528 0, /* bitpos */
529 complain_overflow_signed,/* complain_on_overflow */
530 ppc64_elf_unhandled_reloc, /* special_function */
531 "R_PPC64_GOT16_HI", /* name */
532 FALSE, /* partial_inplace */
533 0, /* src_mask */
534 0xffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
536
537 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
538 the symbol. */
539 HOWTO (R_PPC64_GOT16_HA, /* type */
540 16, /* rightshift */
541 1, /* size (0 = byte, 1 = short, 2 = long) */
542 16, /* bitsize */
543 FALSE, /* pc_relative */
544 0, /* bitpos */
545 complain_overflow_signed,/* complain_on_overflow */
546 ppc64_elf_unhandled_reloc, /* special_function */
547 "R_PPC64_GOT16_HA", /* name */
548 FALSE, /* partial_inplace */
549 0, /* src_mask */
550 0xffff, /* dst_mask */
551 FALSE), /* pcrel_offset */
552
553 /* This is used only by the dynamic linker. The symbol should exist
554 both in the object being run and in some shared library. The
555 dynamic linker copies the data addressed by the symbol from the
556 shared library into the object, because the object being
557 run has to have the data at some particular address. */
558 HOWTO (R_PPC64_COPY, /* type */
559 0, /* rightshift */
560 0, /* this one is variable size */
561 0, /* bitsize */
562 FALSE, /* pc_relative */
563 0, /* bitpos */
564 complain_overflow_dont, /* complain_on_overflow */
565 ppc64_elf_unhandled_reloc, /* special_function */
566 "R_PPC64_COPY", /* name */
567 FALSE, /* partial_inplace */
568 0, /* src_mask */
569 0, /* dst_mask */
570 FALSE), /* pcrel_offset */
571
572 /* Like R_PPC64_ADDR64, but used when setting global offset table
573 entries. */
574 HOWTO (R_PPC64_GLOB_DAT, /* type */
575 0, /* rightshift */
576 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
577 64, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_dont, /* complain_on_overflow */
581 ppc64_elf_unhandled_reloc, /* special_function */
582 "R_PPC64_GLOB_DAT", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 ONES (64), /* dst_mask */
586 FALSE), /* pcrel_offset */
587
588 /* Created by the link editor. Marks a procedure linkage table
589 entry for a symbol. */
590 HOWTO (R_PPC64_JMP_SLOT, /* type */
591 0, /* rightshift */
592 0, /* size (0 = byte, 1 = short, 2 = long) */
593 0, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont, /* complain_on_overflow */
597 ppc64_elf_unhandled_reloc, /* special_function */
598 "R_PPC64_JMP_SLOT", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* Used only by the dynamic linker. When the object is run, this
605 doubleword64 is set to the load address of the object, plus the
606 addend. */
607 HOWTO (R_PPC64_RELATIVE, /* type */
608 0, /* rightshift */
609 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
610 64, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_dont, /* complain_on_overflow */
614 bfd_elf_generic_reloc, /* special_function */
615 "R_PPC64_RELATIVE", /* name */
616 FALSE, /* partial_inplace */
617 0, /* src_mask */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Like R_PPC64_ADDR32, but may be unaligned. */
622 HOWTO (R_PPC64_UADDR32, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 32, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_bitfield, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_PPC64_UADDR32", /* name */
631 FALSE, /* partial_inplace */
632 0, /* src_mask */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 /* Like R_PPC64_ADDR16, but may be unaligned. */
637 HOWTO (R_PPC64_UADDR16, /* type */
638 0, /* rightshift */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_PPC64_UADDR16", /* name */
646 FALSE, /* partial_inplace */
647 0, /* src_mask */
648 0xffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
650
651 /* 32-bit PC relative. */
652 HOWTO (R_PPC64_REL32, /* type */
653 0, /* rightshift */
654 2, /* size (0 = byte, 1 = short, 2 = long) */
655 32, /* bitsize */
656 TRUE, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_signed, /* complain_on_overflow */
659 bfd_elf_generic_reloc, /* special_function */
660 "R_PPC64_REL32", /* name */
661 FALSE, /* partial_inplace */
662 0, /* src_mask */
663 0xffffffff, /* dst_mask */
664 TRUE), /* pcrel_offset */
665
666 /* 32-bit relocation to the symbol's procedure linkage table. */
667 HOWTO (R_PPC64_PLT32, /* type */
668 0, /* rightshift */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
670 32, /* bitsize */
671 FALSE, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_bitfield, /* complain_on_overflow */
674 ppc64_elf_unhandled_reloc, /* special_function */
675 "R_PPC64_PLT32", /* name */
676 FALSE, /* partial_inplace */
677 0, /* src_mask */
678 0xffffffff, /* dst_mask */
679 FALSE), /* pcrel_offset */
680
681 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
682 FIXME: R_PPC64_PLTREL32 not supported. */
683 HOWTO (R_PPC64_PLTREL32, /* type */
684 0, /* rightshift */
685 2, /* size (0 = byte, 1 = short, 2 = long) */
686 32, /* bitsize */
687 TRUE, /* pc_relative */
688 0, /* bitpos */
689 complain_overflow_signed, /* complain_on_overflow */
690 bfd_elf_generic_reloc, /* special_function */
691 "R_PPC64_PLTREL32", /* name */
692 FALSE, /* partial_inplace */
693 0, /* src_mask */
694 0xffffffff, /* dst_mask */
695 TRUE), /* pcrel_offset */
696
697 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
698 the symbol. */
699 HOWTO (R_PPC64_PLT16_LO, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_dont, /* complain_on_overflow */
706 ppc64_elf_unhandled_reloc, /* special_function */
707 "R_PPC64_PLT16_LO", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
714 the symbol. */
715 HOWTO (R_PPC64_PLT16_HI, /* type */
716 16, /* rightshift */
717 1, /* size (0 = byte, 1 = short, 2 = long) */
718 16, /* bitsize */
719 FALSE, /* pc_relative */
720 0, /* bitpos */
721 complain_overflow_signed, /* complain_on_overflow */
722 ppc64_elf_unhandled_reloc, /* special_function */
723 "R_PPC64_PLT16_HI", /* name */
724 FALSE, /* partial_inplace */
725 0, /* src_mask */
726 0xffff, /* dst_mask */
727 FALSE), /* pcrel_offset */
728
729 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
730 the symbol. */
731 HOWTO (R_PPC64_PLT16_HA, /* type */
732 16, /* rightshift */
733 1, /* size (0 = byte, 1 = short, 2 = long) */
734 16, /* bitsize */
735 FALSE, /* pc_relative */
736 0, /* bitpos */
737 complain_overflow_signed, /* complain_on_overflow */
738 ppc64_elf_unhandled_reloc, /* special_function */
739 "R_PPC64_PLT16_HA", /* name */
740 FALSE, /* partial_inplace */
741 0, /* src_mask */
742 0xffff, /* dst_mask */
743 FALSE), /* pcrel_offset */
744
745 /* 16-bit section relative relocation. */
746 HOWTO (R_PPC64_SECTOFF, /* type */
747 0, /* rightshift */
748 1, /* size (0 = byte, 1 = short, 2 = long) */
749 16, /* bitsize */
750 FALSE, /* pc_relative */
751 0, /* bitpos */
752 complain_overflow_signed, /* complain_on_overflow */
753 ppc64_elf_sectoff_reloc, /* special_function */
754 "R_PPC64_SECTOFF", /* name */
755 FALSE, /* partial_inplace */
756 0, /* src_mask */
757 0xffff, /* dst_mask */
758 FALSE), /* pcrel_offset */
759
760 /* Like R_PPC64_SECTOFF, but no overflow warning. */
761 HOWTO (R_PPC64_SECTOFF_LO, /* type */
762 0, /* rightshift */
763 1, /* size (0 = byte, 1 = short, 2 = long) */
764 16, /* bitsize */
765 FALSE, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 ppc64_elf_sectoff_reloc, /* special_function */
769 "R_PPC64_SECTOFF_LO", /* name */
770 FALSE, /* partial_inplace */
771 0, /* src_mask */
772 0xffff, /* dst_mask */
773 FALSE), /* pcrel_offset */
774
775 /* 16-bit upper half section relative relocation. */
776 HOWTO (R_PPC64_SECTOFF_HI, /* type */
777 16, /* rightshift */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
780 FALSE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_signed, /* complain_on_overflow */
783 ppc64_elf_sectoff_reloc, /* special_function */
784 "R_PPC64_SECTOFF_HI", /* name */
785 FALSE, /* partial_inplace */
786 0, /* src_mask */
787 0xffff, /* dst_mask */
788 FALSE), /* pcrel_offset */
789
790 /* 16-bit upper half adjusted section relative relocation. */
791 HOWTO (R_PPC64_SECTOFF_HA, /* type */
792 16, /* rightshift */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
794 16, /* bitsize */
795 FALSE, /* pc_relative */
796 0, /* bitpos */
797 complain_overflow_signed, /* complain_on_overflow */
798 ppc64_elf_sectoff_ha_reloc, /* special_function */
799 "R_PPC64_SECTOFF_HA", /* name */
800 FALSE, /* partial_inplace */
801 0, /* src_mask */
802 0xffff, /* dst_mask */
803 FALSE), /* pcrel_offset */
804
805 /* Like R_PPC64_REL24 without touching the two least significant bits. */
806 HOWTO (R_PPC64_REL30, /* type */
807 2, /* rightshift */
808 2, /* size (0 = byte, 1 = short, 2 = long) */
809 30, /* bitsize */
810 TRUE, /* pc_relative */
811 0, /* bitpos */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_PPC64_REL30", /* name */
815 FALSE, /* partial_inplace */
816 0, /* src_mask */
817 0xfffffffc, /* dst_mask */
818 TRUE), /* pcrel_offset */
819
820 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
821
822 /* A standard 64-bit relocation. */
823 HOWTO (R_PPC64_ADDR64, /* type */
824 0, /* rightshift */
825 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
826 64, /* bitsize */
827 FALSE, /* pc_relative */
828 0, /* bitpos */
829 complain_overflow_dont, /* complain_on_overflow */
830 bfd_elf_generic_reloc, /* special_function */
831 "R_PPC64_ADDR64", /* name */
832 FALSE, /* partial_inplace */
833 0, /* src_mask */
834 ONES (64), /* dst_mask */
835 FALSE), /* pcrel_offset */
836
837 /* The bits 32-47 of an address. */
838 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
839 32, /* rightshift */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
841 16, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_ADDR16_HIGHER", /* name */
847 FALSE, /* partial_inplace */
848 0, /* src_mask */
849 0xffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* The bits 32-47 of an address, plus 1 if the contents of the low
853 16 bits, treated as a signed number, is negative. */
854 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
855 32, /* rightshift */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
857 16, /* bitsize */
858 FALSE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_dont, /* complain_on_overflow */
861 ppc64_elf_ha_reloc, /* special_function */
862 "R_PPC64_ADDR16_HIGHERA", /* name */
863 FALSE, /* partial_inplace */
864 0, /* src_mask */
865 0xffff, /* dst_mask */
866 FALSE), /* pcrel_offset */
867
868 /* The bits 48-63 of an address. */
869 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
870 48, /* rightshift */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
872 16, /* bitsize */
873 FALSE, /* pc_relative */
874 0, /* bitpos */
875 complain_overflow_dont, /* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_PPC64_ADDR16_HIGHEST", /* name */
878 FALSE, /* partial_inplace */
879 0, /* src_mask */
880 0xffff, /* dst_mask */
881 FALSE), /* pcrel_offset */
882
883 /* The bits 48-63 of an address, plus 1 if the contents of the low
884 16 bits, treated as a signed number, is negative. */
885 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
886 48, /* rightshift */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
888 16, /* bitsize */
889 FALSE, /* pc_relative */
890 0, /* bitpos */
891 complain_overflow_dont, /* complain_on_overflow */
892 ppc64_elf_ha_reloc, /* special_function */
893 "R_PPC64_ADDR16_HIGHESTA", /* name */
894 FALSE, /* partial_inplace */
895 0, /* src_mask */
896 0xffff, /* dst_mask */
897 FALSE), /* pcrel_offset */
898
899 /* Like ADDR64, but may be unaligned. */
900 HOWTO (R_PPC64_UADDR64, /* type */
901 0, /* rightshift */
902 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
903 64, /* bitsize */
904 FALSE, /* pc_relative */
905 0, /* bitpos */
906 complain_overflow_dont, /* complain_on_overflow */
907 bfd_elf_generic_reloc, /* special_function */
908 "R_PPC64_UADDR64", /* name */
909 FALSE, /* partial_inplace */
910 0, /* src_mask */
911 ONES (64), /* dst_mask */
912 FALSE), /* pcrel_offset */
913
914 /* 64-bit relative relocation. */
915 HOWTO (R_PPC64_REL64, /* type */
916 0, /* rightshift */
917 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
918 64, /* bitsize */
919 TRUE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_dont, /* complain_on_overflow */
922 bfd_elf_generic_reloc, /* special_function */
923 "R_PPC64_REL64", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 ONES (64), /* dst_mask */
927 TRUE), /* pcrel_offset */
928
929 /* 64-bit relocation to the symbol's procedure linkage table. */
930 HOWTO (R_PPC64_PLT64, /* type */
931 0, /* rightshift */
932 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
933 64, /* bitsize */
934 FALSE, /* pc_relative */
935 0, /* bitpos */
936 complain_overflow_dont, /* complain_on_overflow */
937 ppc64_elf_unhandled_reloc, /* special_function */
938 "R_PPC64_PLT64", /* name */
939 FALSE, /* partial_inplace */
940 0, /* src_mask */
941 ONES (64), /* dst_mask */
942 FALSE), /* pcrel_offset */
943
944 /* 64-bit PC relative relocation to the symbol's procedure linkage
945 table. */
946 /* FIXME: R_PPC64_PLTREL64 not supported. */
947 HOWTO (R_PPC64_PLTREL64, /* type */
948 0, /* rightshift */
949 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
950 64, /* bitsize */
951 TRUE, /* pc_relative */
952 0, /* bitpos */
953 complain_overflow_dont, /* complain_on_overflow */
954 ppc64_elf_unhandled_reloc, /* special_function */
955 "R_PPC64_PLTREL64", /* name */
956 FALSE, /* partial_inplace */
957 0, /* src_mask */
958 ONES (64), /* dst_mask */
959 TRUE), /* pcrel_offset */
960
961 /* 16 bit TOC-relative relocation. */
962
963 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
964 HOWTO (R_PPC64_TOC16, /* type */
965 0, /* rightshift */
966 1, /* size (0 = byte, 1 = short, 2 = long) */
967 16, /* bitsize */
968 FALSE, /* pc_relative */
969 0, /* bitpos */
970 complain_overflow_signed, /* complain_on_overflow */
971 ppc64_elf_toc_reloc, /* special_function */
972 "R_PPC64_TOC16", /* name */
973 FALSE, /* partial_inplace */
974 0, /* src_mask */
975 0xffff, /* dst_mask */
976 FALSE), /* pcrel_offset */
977
978 /* 16 bit TOC-relative relocation without overflow. */
979
980 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
981 HOWTO (R_PPC64_TOC16_LO, /* type */
982 0, /* rightshift */
983 1, /* size (0 = byte, 1 = short, 2 = long) */
984 16, /* bitsize */
985 FALSE, /* pc_relative */
986 0, /* bitpos */
987 complain_overflow_dont, /* complain_on_overflow */
988 ppc64_elf_toc_reloc, /* special_function */
989 "R_PPC64_TOC16_LO", /* name */
990 FALSE, /* partial_inplace */
991 0, /* src_mask */
992 0xffff, /* dst_mask */
993 FALSE), /* pcrel_offset */
994
995 /* 16 bit TOC-relative relocation, high 16 bits. */
996
997 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
998 HOWTO (R_PPC64_TOC16_HI, /* type */
999 16, /* rightshift */
1000 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 16, /* bitsize */
1002 FALSE, /* pc_relative */
1003 0, /* bitpos */
1004 complain_overflow_signed, /* complain_on_overflow */
1005 ppc64_elf_toc_reloc, /* special_function */
1006 "R_PPC64_TOC16_HI", /* name */
1007 FALSE, /* partial_inplace */
1008 0, /* src_mask */
1009 0xffff, /* dst_mask */
1010 FALSE), /* pcrel_offset */
1011
1012 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013 contents of the low 16 bits, treated as a signed number, is
1014 negative. */
1015
1016 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1017 HOWTO (R_PPC64_TOC16_HA, /* type */
1018 16, /* rightshift */
1019 1, /* size (0 = byte, 1 = short, 2 = long) */
1020 16, /* bitsize */
1021 FALSE, /* pc_relative */
1022 0, /* bitpos */
1023 complain_overflow_signed, /* complain_on_overflow */
1024 ppc64_elf_toc_ha_reloc, /* special_function */
1025 "R_PPC64_TOC16_HA", /* name */
1026 FALSE, /* partial_inplace */
1027 0, /* src_mask */
1028 0xffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1030
1031 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1032
1033 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1034 HOWTO (R_PPC64_TOC, /* type */
1035 0, /* rightshift */
1036 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037 64, /* bitsize */
1038 FALSE, /* pc_relative */
1039 0, /* bitpos */
1040 complain_overflow_dont, /* complain_on_overflow */
1041 ppc64_elf_toc64_reloc, /* special_function */
1042 "R_PPC64_TOC", /* name */
1043 FALSE, /* partial_inplace */
1044 0, /* src_mask */
1045 ONES (64), /* dst_mask */
1046 FALSE), /* pcrel_offset */
1047
1048 /* Like R_PPC64_GOT16, but also informs the link editor that the
1049 value to relocate may (!) refer to a PLT entry which the link
1050 editor (a) may replace with the symbol value. If the link editor
1051 is unable to fully resolve the symbol, it may (b) create a PLT
1052 entry and store the address to the new PLT entry in the GOT.
1053 This permits lazy resolution of function symbols at run time.
1054 The link editor may also skip all of this and just (c) emit a
1055 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1056 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16, /* type */
1058 0, /* rightshift */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1060 16, /* bitsize */
1061 FALSE, /* pc_relative */
1062 0, /* bitpos */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Like R_PPC64_PLTGOT16, but without overflow. */
1072 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1073 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_dont, /* complain_on_overflow */
1080 ppc64_elf_unhandled_reloc, /* special_function */
1081 "R_PPC64_PLTGOT16_LO", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xffff, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1088 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1089 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1090 16, /* rightshift */
1091 1, /* size (0 = byte, 1 = short, 2 = long) */
1092 16, /* bitsize */
1093 FALSE, /* pc_relative */
1094 0, /* bitpos */
1095 complain_overflow_signed, /* complain_on_overflow */
1096 ppc64_elf_unhandled_reloc, /* special_function */
1097 "R_PPC64_PLTGOT16_HI", /* name */
1098 FALSE, /* partial_inplace */
1099 0, /* src_mask */
1100 0xffff, /* dst_mask */
1101 FALSE), /* pcrel_offset */
1102
1103 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104 1 if the contents of the low 16 bits, treated as a signed number,
1105 is negative. */
1106 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1107 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1108 16, /* rightshift */
1109 1, /* size (0 = byte, 1 = short, 2 = long) */
1110 16, /* bitsize */
1111 FALSE, /* pc_relative */
1112 0, /* bitpos */
1113 complain_overflow_signed, /* complain_on_overflow */
1114 ppc64_elf_unhandled_reloc, /* special_function */
1115 "R_PPC64_PLTGOT16_HA", /* name */
1116 FALSE, /* partial_inplace */
1117 0, /* src_mask */
1118 0xffff, /* dst_mask */
1119 FALSE), /* pcrel_offset */
1120
1121 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1122 HOWTO (R_PPC64_ADDR16_DS, /* type */
1123 0, /* rightshift */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1125 16, /* bitsize */
1126 FALSE, /* pc_relative */
1127 0, /* bitpos */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 bfd_elf_generic_reloc, /* special_function */
1130 "R_PPC64_ADDR16_DS", /* name */
1131 FALSE, /* partial_inplace */
1132 0, /* src_mask */
1133 0xfffc, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1135
1136 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1137 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1138 0, /* rightshift */
1139 1, /* size (0 = byte, 1 = short, 2 = long) */
1140 16, /* bitsize */
1141 FALSE, /* pc_relative */
1142 0, /* bitpos */
1143 complain_overflow_dont,/* complain_on_overflow */
1144 bfd_elf_generic_reloc, /* special_function */
1145 "R_PPC64_ADDR16_LO_DS",/* name */
1146 FALSE, /* partial_inplace */
1147 0, /* src_mask */
1148 0xfffc, /* dst_mask */
1149 FALSE), /* pcrel_offset */
1150
1151 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1152 HOWTO (R_PPC64_GOT16_DS, /* type */
1153 0, /* rightshift */
1154 1, /* size (0 = byte, 1 = short, 2 = long) */
1155 16, /* bitsize */
1156 FALSE, /* pc_relative */
1157 0, /* bitpos */
1158 complain_overflow_signed, /* complain_on_overflow */
1159 ppc64_elf_unhandled_reloc, /* special_function */
1160 "R_PPC64_GOT16_DS", /* name */
1161 FALSE, /* partial_inplace */
1162 0, /* src_mask */
1163 0xfffc, /* dst_mask */
1164 FALSE), /* pcrel_offset */
1165
1166 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1167 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1168 0, /* rightshift */
1169 1, /* size (0 = byte, 1 = short, 2 = long) */
1170 16, /* bitsize */
1171 FALSE, /* pc_relative */
1172 0, /* bitpos */
1173 complain_overflow_dont, /* complain_on_overflow */
1174 ppc64_elf_unhandled_reloc, /* special_function */
1175 "R_PPC64_GOT16_LO_DS", /* name */
1176 FALSE, /* partial_inplace */
1177 0, /* src_mask */
1178 0xfffc, /* dst_mask */
1179 FALSE), /* pcrel_offset */
1180
1181 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1182 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1183 0, /* rightshift */
1184 1, /* size (0 = byte, 1 = short, 2 = long) */
1185 16, /* bitsize */
1186 FALSE, /* pc_relative */
1187 0, /* bitpos */
1188 complain_overflow_dont, /* complain_on_overflow */
1189 ppc64_elf_unhandled_reloc, /* special_function */
1190 "R_PPC64_PLT16_LO_DS", /* name */
1191 FALSE, /* partial_inplace */
1192 0, /* src_mask */
1193 0xfffc, /* dst_mask */
1194 FALSE), /* pcrel_offset */
1195
1196 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1197 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1198 0, /* rightshift */
1199 1, /* size (0 = byte, 1 = short, 2 = long) */
1200 16, /* bitsize */
1201 FALSE, /* pc_relative */
1202 0, /* bitpos */
1203 complain_overflow_signed, /* complain_on_overflow */
1204 ppc64_elf_sectoff_reloc, /* special_function */
1205 "R_PPC64_SECTOFF_DS", /* name */
1206 FALSE, /* partial_inplace */
1207 0, /* src_mask */
1208 0xfffc, /* dst_mask */
1209 FALSE), /* pcrel_offset */
1210
1211 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1212 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213 0, /* rightshift */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1215 16, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_sectoff_reloc, /* special_function */
1220 "R_PPC64_SECTOFF_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1222 0, /* src_mask */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1225
1226 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1227 HOWTO (R_PPC64_TOC16_DS, /* type */
1228 0, /* rightshift */
1229 1, /* size (0 = byte, 1 = short, 2 = long) */
1230 16, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_signed, /* complain_on_overflow */
1234 ppc64_elf_toc_reloc, /* special_function */
1235 "R_PPC64_TOC16_DS", /* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0xfffc, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1240
1241 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1242 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1243 0, /* rightshift */
1244 1, /* size (0 = byte, 1 = short, 2 = long) */
1245 16, /* bitsize */
1246 FALSE, /* pc_relative */
1247 0, /* bitpos */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 ppc64_elf_toc_reloc, /* special_function */
1250 "R_PPC64_TOC16_LO_DS", /* name */
1251 FALSE, /* partial_inplace */
1252 0, /* src_mask */
1253 0xfffc, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1255
1256 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1257 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1258 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1259 0, /* rightshift */
1260 1, /* size (0 = byte, 1 = short, 2 = long) */
1261 16, /* bitsize */
1262 FALSE, /* pc_relative */
1263 0, /* bitpos */
1264 complain_overflow_signed, /* complain_on_overflow */
1265 ppc64_elf_unhandled_reloc, /* special_function */
1266 "R_PPC64_PLTGOT16_DS", /* name */
1267 FALSE, /* partial_inplace */
1268 0, /* src_mask */
1269 0xfffc, /* dst_mask */
1270 FALSE), /* pcrel_offset */
1271
1272 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1273 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1274 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275 0, /* rightshift */
1276 1, /* size (0 = byte, 1 = short, 2 = long) */
1277 16, /* bitsize */
1278 FALSE, /* pc_relative */
1279 0, /* bitpos */
1280 complain_overflow_dont, /* complain_on_overflow */
1281 ppc64_elf_unhandled_reloc, /* special_function */
1282 "R_PPC64_PLTGOT16_LO_DS",/* name */
1283 FALSE, /* partial_inplace */
1284 0, /* src_mask */
1285 0xfffc, /* dst_mask */
1286 FALSE), /* pcrel_offset */
1287
1288 /* Marker relocs for TLS. */
1289 HOWTO (R_PPC64_TLS,
1290 0, /* rightshift */
1291 2, /* size (0 = byte, 1 = short, 2 = long) */
1292 32, /* bitsize */
1293 FALSE, /* pc_relative */
1294 0, /* bitpos */
1295 complain_overflow_dont, /* complain_on_overflow */
1296 bfd_elf_generic_reloc, /* special_function */
1297 "R_PPC64_TLS", /* name */
1298 FALSE, /* partial_inplace */
1299 0, /* src_mask */
1300 0, /* dst_mask */
1301 FALSE), /* pcrel_offset */
1302
1303 HOWTO (R_PPC64_TLSGD,
1304 0, /* rightshift */
1305 2, /* size (0 = byte, 1 = short, 2 = long) */
1306 32, /* bitsize */
1307 FALSE, /* pc_relative */
1308 0, /* bitpos */
1309 complain_overflow_dont, /* complain_on_overflow */
1310 bfd_elf_generic_reloc, /* special_function */
1311 "R_PPC64_TLSGD", /* name */
1312 FALSE, /* partial_inplace */
1313 0, /* src_mask */
1314 0, /* dst_mask */
1315 FALSE), /* pcrel_offset */
1316
1317 HOWTO (R_PPC64_TLSLD,
1318 0, /* rightshift */
1319 2, /* size (0 = byte, 1 = short, 2 = long) */
1320 32, /* bitsize */
1321 FALSE, /* pc_relative */
1322 0, /* bitpos */
1323 complain_overflow_dont, /* complain_on_overflow */
1324 bfd_elf_generic_reloc, /* special_function */
1325 "R_PPC64_TLSLD", /* name */
1326 FALSE, /* partial_inplace */
1327 0, /* src_mask */
1328 0, /* dst_mask */
1329 FALSE), /* pcrel_offset */
1330
1331 HOWTO (R_PPC64_TOCSAVE,
1332 0, /* rightshift */
1333 2, /* size (0 = byte, 1 = short, 2 = long) */
1334 32, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 bfd_elf_generic_reloc, /* special_function */
1339 "R_PPC64_TOCSAVE", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Computes the load module index of the load module that contains the
1346 definition of its TLS sym. */
1347 HOWTO (R_PPC64_DTPMOD64,
1348 0, /* rightshift */
1349 4, /* size (0 = byte, 1 = short, 2 = long) */
1350 64, /* bitsize */
1351 FALSE, /* pc_relative */
1352 0, /* bitpos */
1353 complain_overflow_dont, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPMOD64", /* name */
1356 FALSE, /* partial_inplace */
1357 0, /* src_mask */
1358 ONES (64), /* dst_mask */
1359 FALSE), /* pcrel_offset */
1360
1361 /* Computes a dtv-relative displacement, the difference between the value
1362 of sym+add and the base address of the thread-local storage block that
1363 contains the definition of sym, minus 0x8000. */
1364 HOWTO (R_PPC64_DTPREL64,
1365 0, /* rightshift */
1366 4, /* size (0 = byte, 1 = short, 2 = long) */
1367 64, /* bitsize */
1368 FALSE, /* pc_relative */
1369 0, /* bitpos */
1370 complain_overflow_dont, /* complain_on_overflow */
1371 ppc64_elf_unhandled_reloc, /* special_function */
1372 "R_PPC64_DTPREL64", /* name */
1373 FALSE, /* partial_inplace */
1374 0, /* src_mask */
1375 ONES (64), /* dst_mask */
1376 FALSE), /* pcrel_offset */
1377
1378 /* A 16 bit dtprel reloc. */
1379 HOWTO (R_PPC64_DTPREL16,
1380 0, /* rightshift */
1381 1, /* size (0 = byte, 1 = short, 2 = long) */
1382 16, /* bitsize */
1383 FALSE, /* pc_relative */
1384 0, /* bitpos */
1385 complain_overflow_signed, /* complain_on_overflow */
1386 ppc64_elf_unhandled_reloc, /* special_function */
1387 "R_PPC64_DTPREL16", /* name */
1388 FALSE, /* partial_inplace */
1389 0, /* src_mask */
1390 0xffff, /* dst_mask */
1391 FALSE), /* pcrel_offset */
1392
1393 /* Like DTPREL16, but no overflow. */
1394 HOWTO (R_PPC64_DTPREL16_LO,
1395 0, /* rightshift */
1396 1, /* size (0 = byte, 1 = short, 2 = long) */
1397 16, /* bitsize */
1398 FALSE, /* pc_relative */
1399 0, /* bitpos */
1400 complain_overflow_dont, /* complain_on_overflow */
1401 ppc64_elf_unhandled_reloc, /* special_function */
1402 "R_PPC64_DTPREL16_LO", /* name */
1403 FALSE, /* partial_inplace */
1404 0, /* src_mask */
1405 0xffff, /* dst_mask */
1406 FALSE), /* pcrel_offset */
1407
1408 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1409 HOWTO (R_PPC64_DTPREL16_HI,
1410 16, /* rightshift */
1411 1, /* size (0 = byte, 1 = short, 2 = long) */
1412 16, /* bitsize */
1413 FALSE, /* pc_relative */
1414 0, /* bitpos */
1415 complain_overflow_signed, /* complain_on_overflow */
1416 ppc64_elf_unhandled_reloc, /* special_function */
1417 "R_PPC64_DTPREL16_HI", /* name */
1418 FALSE, /* partial_inplace */
1419 0, /* src_mask */
1420 0xffff, /* dst_mask */
1421 FALSE), /* pcrel_offset */
1422
1423 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1424 HOWTO (R_PPC64_DTPREL16_HA,
1425 16, /* rightshift */
1426 1, /* size (0 = byte, 1 = short, 2 = long) */
1427 16, /* bitsize */
1428 FALSE, /* pc_relative */
1429 0, /* bitpos */
1430 complain_overflow_signed, /* complain_on_overflow */
1431 ppc64_elf_unhandled_reloc, /* special_function */
1432 "R_PPC64_DTPREL16_HA", /* name */
1433 FALSE, /* partial_inplace */
1434 0, /* src_mask */
1435 0xffff, /* dst_mask */
1436 FALSE), /* pcrel_offset */
1437
1438 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1439 HOWTO (R_PPC64_DTPREL16_HIGHER,
1440 32, /* rightshift */
1441 1, /* size (0 = byte, 1 = short, 2 = long) */
1442 16, /* bitsize */
1443 FALSE, /* pc_relative */
1444 0, /* bitpos */
1445 complain_overflow_dont, /* complain_on_overflow */
1446 ppc64_elf_unhandled_reloc, /* special_function */
1447 "R_PPC64_DTPREL16_HIGHER", /* name */
1448 FALSE, /* partial_inplace */
1449 0, /* src_mask */
1450 0xffff, /* dst_mask */
1451 FALSE), /* pcrel_offset */
1452
1453 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1454 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455 32, /* rightshift */
1456 1, /* size (0 = byte, 1 = short, 2 = long) */
1457 16, /* bitsize */
1458 FALSE, /* pc_relative */
1459 0, /* bitpos */
1460 complain_overflow_dont, /* complain_on_overflow */
1461 ppc64_elf_unhandled_reloc, /* special_function */
1462 "R_PPC64_DTPREL16_HIGHERA", /* name */
1463 FALSE, /* partial_inplace */
1464 0, /* src_mask */
1465 0xffff, /* dst_mask */
1466 FALSE), /* pcrel_offset */
1467
1468 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1469 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470 48, /* rightshift */
1471 1, /* size (0 = byte, 1 = short, 2 = long) */
1472 16, /* bitsize */
1473 FALSE, /* pc_relative */
1474 0, /* bitpos */
1475 complain_overflow_dont, /* complain_on_overflow */
1476 ppc64_elf_unhandled_reloc, /* special_function */
1477 "R_PPC64_DTPREL16_HIGHEST", /* name */
1478 FALSE, /* partial_inplace */
1479 0, /* src_mask */
1480 0xffff, /* dst_mask */
1481 FALSE), /* pcrel_offset */
1482
1483 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1484 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485 48, /* rightshift */
1486 1, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
1488 FALSE, /* pc_relative */
1489 0, /* bitpos */
1490 complain_overflow_dont, /* complain_on_overflow */
1491 ppc64_elf_unhandled_reloc, /* special_function */
1492 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493 FALSE, /* partial_inplace */
1494 0, /* src_mask */
1495 0xffff, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1497
1498 /* Like DTPREL16, but for insns with a DS field. */
1499 HOWTO (R_PPC64_DTPREL16_DS,
1500 0, /* rightshift */
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 0, /* bitpos */
1505 complain_overflow_signed, /* complain_on_overflow */
1506 ppc64_elf_unhandled_reloc, /* special_function */
1507 "R_PPC64_DTPREL16_DS", /* name */
1508 FALSE, /* partial_inplace */
1509 0, /* src_mask */
1510 0xfffc, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512
1513 /* Like DTPREL16_DS, but no overflow. */
1514 HOWTO (R_PPC64_DTPREL16_LO_DS,
1515 0, /* rightshift */
1516 1, /* size (0 = byte, 1 = short, 2 = long) */
1517 16, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 ppc64_elf_unhandled_reloc, /* special_function */
1522 "R_PPC64_DTPREL16_LO_DS", /* name */
1523 FALSE, /* partial_inplace */
1524 0, /* src_mask */
1525 0xfffc, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 /* Computes a tp-relative displacement, the difference between the value of
1529 sym+add and the value of the thread pointer (r13). */
1530 HOWTO (R_PPC64_TPREL64,
1531 0, /* rightshift */
1532 4, /* size (0 = byte, 1 = short, 2 = long) */
1533 64, /* bitsize */
1534 FALSE, /* pc_relative */
1535 0, /* bitpos */
1536 complain_overflow_dont, /* complain_on_overflow */
1537 ppc64_elf_unhandled_reloc, /* special_function */
1538 "R_PPC64_TPREL64", /* name */
1539 FALSE, /* partial_inplace */
1540 0, /* src_mask */
1541 ONES (64), /* dst_mask */
1542 FALSE), /* pcrel_offset */
1543
1544 /* A 16 bit tprel reloc. */
1545 HOWTO (R_PPC64_TPREL16,
1546 0, /* rightshift */
1547 1, /* size (0 = byte, 1 = short, 2 = long) */
1548 16, /* bitsize */
1549 FALSE, /* pc_relative */
1550 0, /* bitpos */
1551 complain_overflow_signed, /* complain_on_overflow */
1552 ppc64_elf_unhandled_reloc, /* special_function */
1553 "R_PPC64_TPREL16", /* name */
1554 FALSE, /* partial_inplace */
1555 0, /* src_mask */
1556 0xffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1558
1559 /* Like TPREL16, but no overflow. */
1560 HOWTO (R_PPC64_TPREL16_LO,
1561 0, /* rightshift */
1562 1, /* size (0 = byte, 1 = short, 2 = long) */
1563 16, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont, /* complain_on_overflow */
1567 ppc64_elf_unhandled_reloc, /* special_function */
1568 "R_PPC64_TPREL16_LO", /* name */
1569 FALSE, /* partial_inplace */
1570 0, /* src_mask */
1571 0xffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573
1574 /* Like TPREL16_LO, but next higher group of 16 bits. */
1575 HOWTO (R_PPC64_TPREL16_HI,
1576 16, /* rightshift */
1577 1, /* size (0 = byte, 1 = short, 2 = long) */
1578 16, /* bitsize */
1579 FALSE, /* pc_relative */
1580 0, /* bitpos */
1581 complain_overflow_signed, /* complain_on_overflow */
1582 ppc64_elf_unhandled_reloc, /* special_function */
1583 "R_PPC64_TPREL16_HI", /* name */
1584 FALSE, /* partial_inplace */
1585 0, /* src_mask */
1586 0xffff, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1588
1589 /* Like TPREL16_HI, but adjust for low 16 bits. */
1590 HOWTO (R_PPC64_TPREL16_HA,
1591 16, /* rightshift */
1592 1, /* size (0 = byte, 1 = short, 2 = long) */
1593 16, /* bitsize */
1594 FALSE, /* pc_relative */
1595 0, /* bitpos */
1596 complain_overflow_signed, /* complain_on_overflow */
1597 ppc64_elf_unhandled_reloc, /* special_function */
1598 "R_PPC64_TPREL16_HA", /* name */
1599 FALSE, /* partial_inplace */
1600 0, /* src_mask */
1601 0xffff, /* dst_mask */
1602 FALSE), /* pcrel_offset */
1603
1604 /* Like TPREL16_HI, but next higher group of 16 bits. */
1605 HOWTO (R_PPC64_TPREL16_HIGHER,
1606 32, /* rightshift */
1607 1, /* size (0 = byte, 1 = short, 2 = long) */
1608 16, /* bitsize */
1609 FALSE, /* pc_relative */
1610 0, /* bitpos */
1611 complain_overflow_dont, /* complain_on_overflow */
1612 ppc64_elf_unhandled_reloc, /* special_function */
1613 "R_PPC64_TPREL16_HIGHER", /* name */
1614 FALSE, /* partial_inplace */
1615 0, /* src_mask */
1616 0xffff, /* dst_mask */
1617 FALSE), /* pcrel_offset */
1618
1619 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1620 HOWTO (R_PPC64_TPREL16_HIGHERA,
1621 32, /* rightshift */
1622 1, /* size (0 = byte, 1 = short, 2 = long) */
1623 16, /* bitsize */
1624 FALSE, /* pc_relative */
1625 0, /* bitpos */
1626 complain_overflow_dont, /* complain_on_overflow */
1627 ppc64_elf_unhandled_reloc, /* special_function */
1628 "R_PPC64_TPREL16_HIGHERA", /* name */
1629 FALSE, /* partial_inplace */
1630 0, /* src_mask */
1631 0xffff, /* dst_mask */
1632 FALSE), /* pcrel_offset */
1633
1634 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1635 HOWTO (R_PPC64_TPREL16_HIGHEST,
1636 48, /* rightshift */
1637 1, /* size (0 = byte, 1 = short, 2 = long) */
1638 16, /* bitsize */
1639 FALSE, /* pc_relative */
1640 0, /* bitpos */
1641 complain_overflow_dont, /* complain_on_overflow */
1642 ppc64_elf_unhandled_reloc, /* special_function */
1643 "R_PPC64_TPREL16_HIGHEST", /* name */
1644 FALSE, /* partial_inplace */
1645 0, /* src_mask */
1646 0xffff, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1648
1649 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1650 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651 48, /* rightshift */
1652 1, /* size (0 = byte, 1 = short, 2 = long) */
1653 16, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_dont, /* complain_on_overflow */
1657 ppc64_elf_unhandled_reloc, /* special_function */
1658 "R_PPC64_TPREL16_HIGHESTA", /* name */
1659 FALSE, /* partial_inplace */
1660 0, /* src_mask */
1661 0xffff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663
1664 /* Like TPREL16, but for insns with a DS field. */
1665 HOWTO (R_PPC64_TPREL16_DS,
1666 0, /* rightshift */
1667 1, /* size (0 = byte, 1 = short, 2 = long) */
1668 16, /* bitsize */
1669 FALSE, /* pc_relative */
1670 0, /* bitpos */
1671 complain_overflow_signed, /* complain_on_overflow */
1672 ppc64_elf_unhandled_reloc, /* special_function */
1673 "R_PPC64_TPREL16_DS", /* name */
1674 FALSE, /* partial_inplace */
1675 0, /* src_mask */
1676 0xfffc, /* dst_mask */
1677 FALSE), /* pcrel_offset */
1678
1679 /* Like TPREL16_DS, but no overflow. */
1680 HOWTO (R_PPC64_TPREL16_LO_DS,
1681 0, /* rightshift */
1682 1, /* size (0 = byte, 1 = short, 2 = long) */
1683 16, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont, /* complain_on_overflow */
1687 ppc64_elf_unhandled_reloc, /* special_function */
1688 "R_PPC64_TPREL16_LO_DS", /* name */
1689 FALSE, /* partial_inplace */
1690 0, /* src_mask */
1691 0xfffc, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696 to the first entry relative to the TOC base (r2). */
1697 HOWTO (R_PPC64_GOT_TLSGD16,
1698 0, /* rightshift */
1699 1, /* size (0 = byte, 1 = short, 2 = long) */
1700 16, /* bitsize */
1701 FALSE, /* pc_relative */
1702 0, /* bitpos */
1703 complain_overflow_signed, /* complain_on_overflow */
1704 ppc64_elf_unhandled_reloc, /* special_function */
1705 "R_PPC64_GOT_TLSGD16", /* name */
1706 FALSE, /* partial_inplace */
1707 0, /* src_mask */
1708 0xffff, /* dst_mask */
1709 FALSE), /* pcrel_offset */
1710
1711 /* Like GOT_TLSGD16, but no overflow. */
1712 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713 0, /* rightshift */
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1715 16, /* bitsize */
1716 FALSE, /* pc_relative */
1717 0, /* bitpos */
1718 complain_overflow_dont, /* complain_on_overflow */
1719 ppc64_elf_unhandled_reloc, /* special_function */
1720 "R_PPC64_GOT_TLSGD16_LO", /* name */
1721 FALSE, /* partial_inplace */
1722 0, /* src_mask */
1723 0xffff, /* dst_mask */
1724 FALSE), /* pcrel_offset */
1725
1726 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1727 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728 16, /* rightshift */
1729 1, /* size (0 = byte, 1 = short, 2 = long) */
1730 16, /* bitsize */
1731 FALSE, /* pc_relative */
1732 0, /* bitpos */
1733 complain_overflow_signed, /* complain_on_overflow */
1734 ppc64_elf_unhandled_reloc, /* special_function */
1735 "R_PPC64_GOT_TLSGD16_HI", /* name */
1736 FALSE, /* partial_inplace */
1737 0, /* src_mask */
1738 0xffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1740
1741 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1742 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743 16, /* rightshift */
1744 1, /* size (0 = byte, 1 = short, 2 = long) */
1745 16, /* bitsize */
1746 FALSE, /* pc_relative */
1747 0, /* bitpos */
1748 complain_overflow_signed, /* complain_on_overflow */
1749 ppc64_elf_unhandled_reloc, /* special_function */
1750 "R_PPC64_GOT_TLSGD16_HA", /* name */
1751 FALSE, /* partial_inplace */
1752 0, /* src_mask */
1753 0xffff, /* dst_mask */
1754 FALSE), /* pcrel_offset */
1755
1756 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757 with values (sym+add)@dtpmod and zero, and computes the offset to the
1758 first entry relative to the TOC base (r2). */
1759 HOWTO (R_PPC64_GOT_TLSLD16,
1760 0, /* rightshift */
1761 1, /* size (0 = byte, 1 = short, 2 = long) */
1762 16, /* bitsize */
1763 FALSE, /* pc_relative */
1764 0, /* bitpos */
1765 complain_overflow_signed, /* complain_on_overflow */
1766 ppc64_elf_unhandled_reloc, /* special_function */
1767 "R_PPC64_GOT_TLSLD16", /* name */
1768 FALSE, /* partial_inplace */
1769 0, /* src_mask */
1770 0xffff, /* dst_mask */
1771 FALSE), /* pcrel_offset */
1772
1773 /* Like GOT_TLSLD16, but no overflow. */
1774 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775 0, /* rightshift */
1776 1, /* size (0 = byte, 1 = short, 2 = long) */
1777 16, /* bitsize */
1778 FALSE, /* pc_relative */
1779 0, /* bitpos */
1780 complain_overflow_dont, /* complain_on_overflow */
1781 ppc64_elf_unhandled_reloc, /* special_function */
1782 "R_PPC64_GOT_TLSLD16_LO", /* name */
1783 FALSE, /* partial_inplace */
1784 0, /* src_mask */
1785 0xffff, /* dst_mask */
1786 FALSE), /* pcrel_offset */
1787
1788 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1789 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790 16, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1792 16, /* bitsize */
1793 FALSE, /* pc_relative */
1794 0, /* bitpos */
1795 complain_overflow_signed, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_TLSLD16_HI", /* name */
1798 FALSE, /* partial_inplace */
1799 0, /* src_mask */
1800 0xffff, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1802
1803 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1804 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805 16, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1807 16, /* bitsize */
1808 FALSE, /* pc_relative */
1809 0, /* bitpos */
1810 complain_overflow_signed, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_TLSLD16_HA", /* name */
1813 FALSE, /* partial_inplace */
1814 0, /* src_mask */
1815 0xffff, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1817
1818 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819 the offset to the entry relative to the TOC base (r2). */
1820 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821 0, /* rightshift */
1822 1, /* size (0 = byte, 1 = short, 2 = long) */
1823 16, /* bitsize */
1824 FALSE, /* pc_relative */
1825 0, /* bitpos */
1826 complain_overflow_signed, /* complain_on_overflow */
1827 ppc64_elf_unhandled_reloc, /* special_function */
1828 "R_PPC64_GOT_DTPREL16_DS", /* name */
1829 FALSE, /* partial_inplace */
1830 0, /* src_mask */
1831 0xfffc, /* dst_mask */
1832 FALSE), /* pcrel_offset */
1833
1834 /* Like GOT_DTPREL16_DS, but no overflow. */
1835 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836 0, /* rightshift */
1837 1, /* size (0 = byte, 1 = short, 2 = long) */
1838 16, /* bitsize */
1839 FALSE, /* pc_relative */
1840 0, /* bitpos */
1841 complain_overflow_dont, /* complain_on_overflow */
1842 ppc64_elf_unhandled_reloc, /* special_function */
1843 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844 FALSE, /* partial_inplace */
1845 0, /* src_mask */
1846 0xfffc, /* dst_mask */
1847 FALSE), /* pcrel_offset */
1848
1849 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1850 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851 16, /* rightshift */
1852 1, /* size (0 = byte, 1 = short, 2 = long) */
1853 16, /* bitsize */
1854 FALSE, /* pc_relative */
1855 0, /* bitpos */
1856 complain_overflow_signed, /* complain_on_overflow */
1857 ppc64_elf_unhandled_reloc, /* special_function */
1858 "R_PPC64_GOT_DTPREL16_HI", /* name */
1859 FALSE, /* partial_inplace */
1860 0, /* src_mask */
1861 0xffff, /* dst_mask */
1862 FALSE), /* pcrel_offset */
1863
1864 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1865 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866 16, /* rightshift */
1867 1, /* size (0 = byte, 1 = short, 2 = long) */
1868 16, /* bitsize */
1869 FALSE, /* pc_relative */
1870 0, /* bitpos */
1871 complain_overflow_signed, /* complain_on_overflow */
1872 ppc64_elf_unhandled_reloc, /* special_function */
1873 "R_PPC64_GOT_DTPREL16_HA", /* name */
1874 FALSE, /* partial_inplace */
1875 0, /* src_mask */
1876 0xffff, /* dst_mask */
1877 FALSE), /* pcrel_offset */
1878
1879 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880 offset to the entry relative to the TOC base (r2). */
1881 HOWTO (R_PPC64_GOT_TPREL16_DS,
1882 0, /* rightshift */
1883 1, /* size (0 = byte, 1 = short, 2 = long) */
1884 16, /* bitsize */
1885 FALSE, /* pc_relative */
1886 0, /* bitpos */
1887 complain_overflow_signed, /* complain_on_overflow */
1888 ppc64_elf_unhandled_reloc, /* special_function */
1889 "R_PPC64_GOT_TPREL16_DS", /* name */
1890 FALSE, /* partial_inplace */
1891 0, /* src_mask */
1892 0xfffc, /* dst_mask */
1893 FALSE), /* pcrel_offset */
1894
1895 /* Like GOT_TPREL16_DS, but no overflow. */
1896 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897 0, /* rightshift */
1898 1, /* size (0 = byte, 1 = short, 2 = long) */
1899 16, /* bitsize */
1900 FALSE, /* pc_relative */
1901 0, /* bitpos */
1902 complain_overflow_dont, /* complain_on_overflow */
1903 ppc64_elf_unhandled_reloc, /* special_function */
1904 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905 FALSE, /* partial_inplace */
1906 0, /* src_mask */
1907 0xfffc, /* dst_mask */
1908 FALSE), /* pcrel_offset */
1909
1910 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1911 HOWTO (R_PPC64_GOT_TPREL16_HI,
1912 16, /* rightshift */
1913 1, /* size (0 = byte, 1 = short, 2 = long) */
1914 16, /* bitsize */
1915 FALSE, /* pc_relative */
1916 0, /* bitpos */
1917 complain_overflow_signed, /* complain_on_overflow */
1918 ppc64_elf_unhandled_reloc, /* special_function */
1919 "R_PPC64_GOT_TPREL16_HI", /* name */
1920 FALSE, /* partial_inplace */
1921 0, /* src_mask */
1922 0xffff, /* dst_mask */
1923 FALSE), /* pcrel_offset */
1924
1925 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1926 HOWTO (R_PPC64_GOT_TPREL16_HA,
1927 16, /* rightshift */
1928 1, /* size (0 = byte, 1 = short, 2 = long) */
1929 16, /* bitsize */
1930 FALSE, /* pc_relative */
1931 0, /* bitpos */
1932 complain_overflow_signed, /* complain_on_overflow */
1933 ppc64_elf_unhandled_reloc, /* special_function */
1934 "R_PPC64_GOT_TPREL16_HA", /* name */
1935 FALSE, /* partial_inplace */
1936 0, /* src_mask */
1937 0xffff, /* dst_mask */
1938 FALSE), /* pcrel_offset */
1939
1940 HOWTO (R_PPC64_JMP_IREL, /* type */
1941 0, /* rightshift */
1942 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943 0, /* bitsize */
1944 FALSE, /* pc_relative */
1945 0, /* bitpos */
1946 complain_overflow_dont, /* complain_on_overflow */
1947 ppc64_elf_unhandled_reloc, /* special_function */
1948 "R_PPC64_JMP_IREL", /* name */
1949 FALSE, /* partial_inplace */
1950 0, /* src_mask */
1951 0, /* dst_mask */
1952 FALSE), /* pcrel_offset */
1953
1954 HOWTO (R_PPC64_IRELATIVE, /* type */
1955 0, /* rightshift */
1956 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957 64, /* bitsize */
1958 FALSE, /* pc_relative */
1959 0, /* bitpos */
1960 complain_overflow_dont, /* complain_on_overflow */
1961 bfd_elf_generic_reloc, /* special_function */
1962 "R_PPC64_IRELATIVE", /* name */
1963 FALSE, /* partial_inplace */
1964 0, /* src_mask */
1965 ONES (64), /* dst_mask */
1966 FALSE), /* pcrel_offset */
1967
1968 /* A 16 bit relative relocation. */
1969 HOWTO (R_PPC64_REL16, /* type */
1970 0, /* rightshift */
1971 1, /* size (0 = byte, 1 = short, 2 = long) */
1972 16, /* bitsize */
1973 TRUE, /* pc_relative */
1974 0, /* bitpos */
1975 complain_overflow_signed, /* complain_on_overflow */
1976 bfd_elf_generic_reloc, /* special_function */
1977 "R_PPC64_REL16", /* name */
1978 FALSE, /* partial_inplace */
1979 0, /* src_mask */
1980 0xffff, /* dst_mask */
1981 TRUE), /* pcrel_offset */
1982
1983 /* A 16 bit relative relocation without overflow. */
1984 HOWTO (R_PPC64_REL16_LO, /* type */
1985 0, /* rightshift */
1986 1, /* size (0 = byte, 1 = short, 2 = long) */
1987 16, /* bitsize */
1988 TRUE, /* pc_relative */
1989 0, /* bitpos */
1990 complain_overflow_dont,/* complain_on_overflow */
1991 bfd_elf_generic_reloc, /* special_function */
1992 "R_PPC64_REL16_LO", /* name */
1993 FALSE, /* partial_inplace */
1994 0, /* src_mask */
1995 0xffff, /* dst_mask */
1996 TRUE), /* pcrel_offset */
1997
1998 /* The high order 16 bits of a relative address. */
1999 HOWTO (R_PPC64_REL16_HI, /* type */
2000 16, /* rightshift */
2001 1, /* size (0 = byte, 1 = short, 2 = long) */
2002 16, /* bitsize */
2003 TRUE, /* pc_relative */
2004 0, /* bitpos */
2005 complain_overflow_signed, /* complain_on_overflow */
2006 bfd_elf_generic_reloc, /* special_function */
2007 "R_PPC64_REL16_HI", /* name */
2008 FALSE, /* partial_inplace */
2009 0, /* src_mask */
2010 0xffff, /* dst_mask */
2011 TRUE), /* pcrel_offset */
2012
2013 /* The high order 16 bits of a relative address, plus 1 if the contents of
2014 the low 16 bits, treated as a signed number, is negative. */
2015 HOWTO (R_PPC64_REL16_HA, /* type */
2016 16, /* rightshift */
2017 1, /* size (0 = byte, 1 = short, 2 = long) */
2018 16, /* bitsize */
2019 TRUE, /* pc_relative */
2020 0, /* bitpos */
2021 complain_overflow_signed, /* complain_on_overflow */
2022 ppc64_elf_ha_reloc, /* special_function */
2023 "R_PPC64_REL16_HA", /* name */
2024 FALSE, /* partial_inplace */
2025 0, /* src_mask */
2026 0xffff, /* dst_mask */
2027 TRUE), /* pcrel_offset */
2028
2029 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2030 HOWTO (R_PPC64_REL16DX_HA, /* type */
2031 16, /* rightshift */
2032 2, /* size (0 = byte, 1 = short, 2 = long) */
2033 16, /* bitsize */
2034 TRUE, /* pc_relative */
2035 0, /* bitpos */
2036 complain_overflow_signed, /* complain_on_overflow */
2037 ppc64_elf_ha_reloc, /* special_function */
2038 "R_PPC64_REL16DX_HA", /* name */
2039 FALSE, /* partial_inplace */
2040 0, /* src_mask */
2041 0x1fffc1, /* dst_mask */
2042 TRUE), /* pcrel_offset */
2043
2044 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2045 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2046 16, /* rightshift */
2047 1, /* size (0 = byte, 1 = short, 2 = long) */
2048 16, /* bitsize */
2049 FALSE, /* pc_relative */
2050 0, /* bitpos */
2051 complain_overflow_dont, /* complain_on_overflow */
2052 bfd_elf_generic_reloc, /* special_function */
2053 "R_PPC64_ADDR16_HIGH", /* name */
2054 FALSE, /* partial_inplace */
2055 0, /* src_mask */
2056 0xffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2058
2059 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2060 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2061 16, /* rightshift */
2062 1, /* size (0 = byte, 1 = short, 2 = long) */
2063 16, /* bitsize */
2064 FALSE, /* pc_relative */
2065 0, /* bitpos */
2066 complain_overflow_dont, /* complain_on_overflow */
2067 ppc64_elf_ha_reloc, /* special_function */
2068 "R_PPC64_ADDR16_HIGHA", /* name */
2069 FALSE, /* partial_inplace */
2070 0, /* src_mask */
2071 0xffff, /* dst_mask */
2072 FALSE), /* pcrel_offset */
2073
2074 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2075 HOWTO (R_PPC64_DTPREL16_HIGH,
2076 16, /* rightshift */
2077 1, /* size (0 = byte, 1 = short, 2 = long) */
2078 16, /* bitsize */
2079 FALSE, /* pc_relative */
2080 0, /* bitpos */
2081 complain_overflow_dont, /* complain_on_overflow */
2082 ppc64_elf_unhandled_reloc, /* special_function */
2083 "R_PPC64_DTPREL16_HIGH", /* name */
2084 FALSE, /* partial_inplace */
2085 0, /* src_mask */
2086 0xffff, /* dst_mask */
2087 FALSE), /* pcrel_offset */
2088
2089 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2090 HOWTO (R_PPC64_DTPREL16_HIGHA,
2091 16, /* rightshift */
2092 1, /* size (0 = byte, 1 = short, 2 = long) */
2093 16, /* bitsize */
2094 FALSE, /* pc_relative */
2095 0, /* bitpos */
2096 complain_overflow_dont, /* complain_on_overflow */
2097 ppc64_elf_unhandled_reloc, /* special_function */
2098 "R_PPC64_DTPREL16_HIGHA", /* name */
2099 FALSE, /* partial_inplace */
2100 0, /* src_mask */
2101 0xffff, /* dst_mask */
2102 FALSE), /* pcrel_offset */
2103
2104 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2105 HOWTO (R_PPC64_TPREL16_HIGH,
2106 16, /* rightshift */
2107 1, /* size (0 = byte, 1 = short, 2 = long) */
2108 16, /* bitsize */
2109 FALSE, /* pc_relative */
2110 0, /* bitpos */
2111 complain_overflow_dont, /* complain_on_overflow */
2112 ppc64_elf_unhandled_reloc, /* special_function */
2113 "R_PPC64_TPREL16_HIGH", /* name */
2114 FALSE, /* partial_inplace */
2115 0, /* src_mask */
2116 0xffff, /* dst_mask */
2117 FALSE), /* pcrel_offset */
2118
2119 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2120 HOWTO (R_PPC64_TPREL16_HIGHA,
2121 16, /* rightshift */
2122 1, /* size (0 = byte, 1 = short, 2 = long) */
2123 16, /* bitsize */
2124 FALSE, /* pc_relative */
2125 0, /* bitpos */
2126 complain_overflow_dont, /* complain_on_overflow */
2127 ppc64_elf_unhandled_reloc, /* special_function */
2128 "R_PPC64_TPREL16_HIGHA", /* name */
2129 FALSE, /* partial_inplace */
2130 0, /* src_mask */
2131 0xffff, /* dst_mask */
2132 FALSE), /* pcrel_offset */
2133
2134 /* Marker reloc on ELFv2 large-model function entry. */
2135 HOWTO (R_PPC64_ENTRY,
2136 0, /* rightshift */
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2138 32, /* bitsize */
2139 FALSE, /* pc_relative */
2140 0, /* bitpos */
2141 complain_overflow_dont, /* complain_on_overflow */
2142 bfd_elf_generic_reloc, /* special_function */
2143 "R_PPC64_ENTRY", /* name */
2144 FALSE, /* partial_inplace */
2145 0, /* src_mask */
2146 0, /* dst_mask */
2147 FALSE), /* pcrel_offset */
2148
2149 /* Like ADDR64, but use local entry point of function. */
2150 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2151 0, /* rightshift */
2152 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153 64, /* bitsize */
2154 FALSE, /* pc_relative */
2155 0, /* bitpos */
2156 complain_overflow_dont, /* complain_on_overflow */
2157 bfd_elf_generic_reloc, /* special_function */
2158 "R_PPC64_ADDR64_LOCAL", /* name */
2159 FALSE, /* partial_inplace */
2160 0, /* src_mask */
2161 ONES (64), /* dst_mask */
2162 FALSE), /* pcrel_offset */
2163
2164 /* GNU extension to record C++ vtable hierarchy. */
2165 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166 0, /* rightshift */
2167 0, /* size (0 = byte, 1 = short, 2 = long) */
2168 0, /* bitsize */
2169 FALSE, /* pc_relative */
2170 0, /* bitpos */
2171 complain_overflow_dont, /* complain_on_overflow */
2172 NULL, /* special_function */
2173 "R_PPC64_GNU_VTINHERIT", /* name */
2174 FALSE, /* partial_inplace */
2175 0, /* src_mask */
2176 0, /* dst_mask */
2177 FALSE), /* pcrel_offset */
2178
2179 /* GNU extension to record C++ vtable member usage. */
2180 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2181 0, /* rightshift */
2182 0, /* size (0 = byte, 1 = short, 2 = long) */
2183 0, /* bitsize */
2184 FALSE, /* pc_relative */
2185 0, /* bitpos */
2186 complain_overflow_dont, /* complain_on_overflow */
2187 NULL, /* special_function */
2188 "R_PPC64_GNU_VTENTRY", /* name */
2189 FALSE, /* partial_inplace */
2190 0, /* src_mask */
2191 0, /* dst_mask */
2192 FALSE), /* pcrel_offset */
2193 };
2194
2195 \f
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197 be done. */
2198
2199 static void
2200 ppc_howto_init (void)
2201 {
2202 unsigned int i, type;
2203
2204 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205 {
2206 type = ppc64_elf_howto_raw[i].type;
2207 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209 }
2210 }
2211
2212 static reloc_howto_type *
2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214 bfd_reloc_code_real_type code)
2215 {
2216 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219 /* Initialize howto table if needed. */
2220 ppc_howto_init ();
2221
2222 switch (code)
2223 {
2224 default:
2225 return NULL;
2226
2227 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2228 break;
2229 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2230 break;
2231 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2232 break;
2233 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2234 break;
2235 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2236 break;
2237 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2238 break;
2239 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2240 break;
2241 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2242 break;
2243 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2244 break;
2245 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2246 break;
2247 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2248 break;
2249 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2250 break;
2251 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2252 break;
2253 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2254 break;
2255 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2256 break;
2257 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2258 break;
2259 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2260 break;
2261 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2262 break;
2263 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2264 break;
2265 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2266 break;
2267 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2268 break;
2269 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2270 break;
2271 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2272 break;
2273 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2274 break;
2275 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2276 break;
2277 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2278 break;
2279 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2280 break;
2281 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2282 break;
2283 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2284 break;
2285 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2286 break;
2287 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2288 break;
2289 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2290 break;
2291 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2292 break;
2293 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2294 break;
2295 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2296 break;
2297 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2298 break;
2299 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2300 break;
2301 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2302 break;
2303 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2304 break;
2305 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2306 break;
2307 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2308 break;
2309 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2310 break;
2311 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2312 break;
2313 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2314 break;
2315 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2316 break;
2317 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2318 break;
2319 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2320 break;
2321 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2322 break;
2323 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2324 break;
2325 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2326 break;
2327 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2328 break;
2329 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2330 break;
2331 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2332 break;
2333 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2334 break;
2335 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2336 break;
2337 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2338 break;
2339 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2340 break;
2341 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2342 break;
2343 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2344 break;
2345 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2346 break;
2347 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2348 break;
2349 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2350 break;
2351 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2352 break;
2353 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2354 break;
2355 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2356 break;
2357 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2358 break;
2359 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2360 break;
2361 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2362 break;
2363 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2364 break;
2365 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2366 break;
2367 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2368 break;
2369 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2370 break;
2371 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2372 break;
2373 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2374 break;
2375 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2376 break;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2378 break;
2379 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2380 break;
2381 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2382 break;
2383 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2384 break;
2385 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2386 break;
2387 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2388 break;
2389 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2390 break;
2391 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2392 break;
2393 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2394 break;
2395 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2396 break;
2397 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2398 break;
2399 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2400 break;
2401 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2402 break;
2403 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2404 break;
2405 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2406 break;
2407 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2408 break;
2409 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2410 break;
2411 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2412 break;
2413 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2414 break;
2415 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2416 break;
2417 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2418 break;
2419 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2420 break;
2421 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2422 break;
2423 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2424 break;
2425 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2426 break;
2427 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2428 break;
2429 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2430 break;
2431 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2432 break;
2433 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2434 break;
2435 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2436 break;
2437 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2438 break;
2439 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2440 break;
2441 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2442 break;
2443 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2444 break;
2445 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2446 break;
2447 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2448 break;
2449 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2450 break;
2451 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2452 break;
2453 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2454 break;
2455 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2456 break;
2457 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2458 break;
2459 }
2460
2461 return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466 const char *r_name)
2467 {
2468 unsigned int i;
2469
2470 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471 if (ppc64_elf_howto_raw[i].name != NULL
2472 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473 return &ppc64_elf_howto_raw[i];
2474
2475 return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc. */
2479
2480 static void
2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482 Elf_Internal_Rela *dst)
2483 {
2484 unsigned int type;
2485
2486 /* Initialize howto table if needed. */
2487 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488 ppc_howto_init ();
2489
2490 type = ELF64_R_TYPE (dst->r_info);
2491 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492 {
2493 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494 abfd, (int) type);
2495 type = R_PPC64_NONE;
2496 }
2497 cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2501
2502 static bfd_reloc_status_type
2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504 void *data, asection *input_section,
2505 bfd *output_bfd, char **error_message)
2506 {
2507 enum elf_ppc64_reloc_type r_type;
2508 long insn;
2509 bfd_size_type octets;
2510 bfd_vma value;
2511
2512 /* If this is a relocatable link (output_bfd test tells us), just
2513 call the generic function. Any adjustment will be done at final
2514 link time. */
2515 if (output_bfd != NULL)
2516 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517 input_section, output_bfd, error_message);
2518
2519 /* Adjust the addend for sign extension of the low 16 bits.
2520 We won't actually be using the low 16 bits, so trashing them
2521 doesn't matter. */
2522 reloc_entry->addend += 0x8000;
2523 r_type = reloc_entry->howto->type;
2524 if (r_type != R_PPC64_REL16DX_HA)
2525 return bfd_reloc_continue;
2526
2527 value = 0;
2528 if (!bfd_is_com_section (symbol->section))
2529 value = symbol->value;
2530 value += (reloc_entry->addend
2531 + symbol->section->output_offset
2532 + symbol->section->output_section->vma);
2533 value -= (reloc_entry->address
2534 + input_section->output_offset
2535 + input_section->output_section->vma);
2536 value = (bfd_signed_vma) value >> 16;
2537
2538 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540 insn &= ~0x1fffc1;
2541 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543 if (value + 0x8000 > 0xffff)
2544 return bfd_reloc_overflow;
2545 return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550 void *data, asection *input_section,
2551 bfd *output_bfd, char **error_message)
2552 {
2553 if (output_bfd != NULL)
2554 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555 input_section, output_bfd, error_message);
2556
2557 if (strcmp (symbol->section->name, ".opd") == 0
2558 && (symbol->section->owner->flags & DYNAMIC) == 0)
2559 {
2560 bfd_vma dest = opd_entry_value (symbol->section,
2561 symbol->value + reloc_entry->addend,
2562 NULL, NULL, FALSE);
2563 if (dest != (bfd_vma) -1)
2564 reloc_entry->addend = dest - (symbol->value
2565 + symbol->section->output_section->vma
2566 + symbol->section->output_offset);
2567 }
2568 else
2569 {
2570 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572 if (symbol->section->owner != abfd
2573 && symbol->section->owner != NULL
2574 && abiversion (symbol->section->owner) >= 2)
2575 {
2576 unsigned int i;
2577
2578 for (i = 0; i < symbol->section->owner->symcount; ++i)
2579 {
2580 asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582 if (strcmp (symdef->name, symbol->name) == 0)
2583 {
2584 elfsym = (elf_symbol_type *) symdef;
2585 break;
2586 }
2587 }
2588 }
2589 reloc_entry->addend
2590 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591 }
2592 return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597 void *data, asection *input_section,
2598 bfd *output_bfd, char **error_message)
2599 {
2600 long insn;
2601 enum elf_ppc64_reloc_type r_type;
2602 bfd_size_type octets;
2603 /* Assume 'at' branch hints. */
2604 bfd_boolean is_isa_v2 = TRUE;
2605
2606 /* If this is a relocatable link (output_bfd test tells us), just
2607 call the generic function. Any adjustment will be done at final
2608 link time. */
2609 if (output_bfd != NULL)
2610 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611 input_section, output_bfd, error_message);
2612
2613 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615 insn &= ~(0x01 << 21);
2616 r_type = reloc_entry->howto->type;
2617 if (r_type == R_PPC64_ADDR14_BRTAKEN
2618 || r_type == R_PPC64_REL14_BRTAKEN)
2619 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2620
2621 if (is_isa_v2)
2622 {
2623 /* Set 'a' bit. This is 0b00010 in BO field for branch
2624 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625 for branch on CTR insns (BO == 1a00t or 1a01t). */
2626 if ((insn & (0x14 << 21)) == (0x04 << 21))
2627 insn |= 0x02 << 21;
2628 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629 insn |= 0x08 << 21;
2630 else
2631 goto out;
2632 }
2633 else
2634 {
2635 bfd_vma target = 0;
2636 bfd_vma from;
2637
2638 if (!bfd_is_com_section (symbol->section))
2639 target = symbol->value;
2640 target += symbol->section->output_section->vma;
2641 target += symbol->section->output_offset;
2642 target += reloc_entry->addend;
2643
2644 from = (reloc_entry->address
2645 + input_section->output_offset
2646 + input_section->output_section->vma);
2647
2648 /* Invert 'y' bit if not the default. */
2649 if ((bfd_signed_vma) (target - from) < 0)
2650 insn ^= 0x01 << 21;
2651 }
2652 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653 out:
2654 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655 input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660 void *data, asection *input_section,
2661 bfd *output_bfd, char **error_message)
2662 {
2663 /* If this is a relocatable link (output_bfd test tells us), just
2664 call the generic function. Any adjustment will be done at final
2665 link time. */
2666 if (output_bfd != NULL)
2667 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668 input_section, output_bfd, error_message);
2669
2670 /* Subtract the symbol section base address. */
2671 reloc_entry->addend -= symbol->section->output_section->vma;
2672 return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677 void *data, asection *input_section,
2678 bfd *output_bfd, char **error_message)
2679 {
2680 /* If this is a relocatable link (output_bfd test tells us), just
2681 call the generic function. Any adjustment will be done at final
2682 link time. */
2683 if (output_bfd != NULL)
2684 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685 input_section, output_bfd, error_message);
2686
2687 /* Subtract the symbol section base address. */
2688 reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690 /* Adjust the addend for sign extension of the low 16 bits. */
2691 reloc_entry->addend += 0x8000;
2692 return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697 void *data, asection *input_section,
2698 bfd *output_bfd, char **error_message)
2699 {
2700 bfd_vma TOCstart;
2701
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2704 link time. */
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2708
2709 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710 if (TOCstart == 0)
2711 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713 /* Subtract the TOC base address. */
2714 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715 return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720 void *data, asection *input_section,
2721 bfd *output_bfd, char **error_message)
2722 {
2723 bfd_vma TOCstart;
2724
2725 /* If this is a relocatable link (output_bfd test tells us), just
2726 call the generic function. Any adjustment will be done at final
2727 link time. */
2728 if (output_bfd != NULL)
2729 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730 input_section, output_bfd, error_message);
2731
2732 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 if (TOCstart == 0)
2734 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736 /* Subtract the TOC base address. */
2737 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739 /* Adjust the addend for sign extension of the low 16 bits. */
2740 reloc_entry->addend += 0x8000;
2741 return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746 void *data, asection *input_section,
2747 bfd *output_bfd, char **error_message)
2748 {
2749 bfd_vma TOCstart;
2750 bfd_size_type octets;
2751
2752 /* If this is a relocatable link (output_bfd test tells us), just
2753 call the generic function. Any adjustment will be done at final
2754 link time. */
2755 if (output_bfd != NULL)
2756 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757 input_section, output_bfd, error_message);
2758
2759 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760 if (TOCstart == 0)
2761 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765 return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770 void *data, asection *input_section,
2771 bfd *output_bfd, char **error_message)
2772 {
2773 /* If this is a relocatable link (output_bfd test tells us), just
2774 call the generic function. Any adjustment will be done at final
2775 link time. */
2776 if (output_bfd != NULL)
2777 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778 input_section, output_bfd, error_message);
2779
2780 if (error_message != NULL)
2781 {
2782 static char buf[60];
2783 sprintf (buf, "generic linker can't handle %s",
2784 reloc_entry->howto->name);
2785 *error_message = buf;
2786 }
2787 return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol. We might need more
2791 than one got entry per symbol. */
2792 struct got_entry
2793 {
2794 struct got_entry *next;
2795
2796 /* The symbol addend that we'll be placing in the GOT. */
2797 bfd_vma addend;
2798
2799 /* Unlike other ELF targets, we use separate GOT entries for the same
2800 symbol referenced from different input files. This is to support
2801 automatic multiple TOC/GOT sections, where the TOC base can vary
2802 from one input file to another. After partitioning into TOC groups
2803 we merge entries within the group.
2804
2805 Point to the BFD owning this GOT entry. */
2806 bfd *owner;
2807
2808 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809 TLS_TPREL or TLS_DTPREL for tls entries. */
2810 unsigned char tls_type;
2811
2812 /* Non-zero if got.ent points to real entry. */
2813 unsigned char is_indirect;
2814
2815 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2816 union
2817 {
2818 bfd_signed_vma refcount;
2819 bfd_vma offset;
2820 struct got_entry *ent;
2821 } got;
2822 };
2823
2824 /* The same for PLT. */
2825 struct plt_entry
2826 {
2827 struct plt_entry *next;
2828
2829 bfd_vma addend;
2830
2831 union
2832 {
2833 bfd_signed_vma refcount;
2834 bfd_vma offset;
2835 } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840 struct elf_obj_tdata elf;
2841
2842 /* Shortcuts to dynamic linker sections. */
2843 asection *got;
2844 asection *relgot;
2845
2846 /* Used during garbage collection. We attach global symbols defined
2847 on removed .opd entries to this section so that the sym is removed. */
2848 asection *deleted_section;
2849
2850 /* TLS local dynamic got entry handling. Support for multiple GOT
2851 sections means we potentially need one of these for each input bfd. */
2852 struct got_entry tlsld_got;
2853
2854 union {
2855 /* A copy of relocs before they are modified for --emit-relocs. */
2856 Elf_Internal_Rela *relocs;
2857
2858 /* Section contents. */
2859 bfd_byte *contents;
2860 } opd;
2861
2862 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863 the reloc to be in the range -32768 to 32767. */
2864 unsigned int has_small_toc_reloc : 1;
2865
2866 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867 instruction not one we handle. */
2868 unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875 (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879 && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras. */
2882
2883 static bfd_boolean
2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887 PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891 default is 32 bit. */
2892
2893 static bfd_boolean
2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2897 {
2898 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2899
2900 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2901 {
2902 /* Relies on arch after 32 bit default being 64 bit default. */
2903 abfd->arch_info = abfd->arch_info->next;
2904 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2905 }
2906 }
2907 return TRUE;
2908 }
2909
2910 /* Support for core dump NOTE sections. */
2911
2912 static bfd_boolean
2913 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2914 {
2915 size_t offset, size;
2916
2917 if (note->descsz != 504)
2918 return FALSE;
2919
2920 /* pr_cursig */
2921 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2922
2923 /* pr_pid */
2924 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2925
2926 /* pr_reg */
2927 offset = 112;
2928 size = 384;
2929
2930 /* Make a ".reg/999" section. */
2931 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2932 size, note->descpos + offset);
2933 }
2934
2935 static bfd_boolean
2936 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2937 {
2938 if (note->descsz != 136)
2939 return FALSE;
2940
2941 elf_tdata (abfd)->core->pid
2942 = bfd_get_32 (abfd, note->descdata + 24);
2943 elf_tdata (abfd)->core->program
2944 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2945 elf_tdata (abfd)->core->command
2946 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2947
2948 return TRUE;
2949 }
2950
2951 static char *
2952 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2953 ...)
2954 {
2955 switch (note_type)
2956 {
2957 default:
2958 return NULL;
2959
2960 case NT_PRPSINFO:
2961 {
2962 char data[136];
2963 va_list ap;
2964
2965 va_start (ap, note_type);
2966 memset (data, 0, sizeof (data));
2967 strncpy (data + 40, va_arg (ap, const char *), 16);
2968 strncpy (data + 56, va_arg (ap, const char *), 80);
2969 va_end (ap);
2970 return elfcore_write_note (abfd, buf, bufsiz,
2971 "CORE", note_type, data, sizeof (data));
2972 }
2973
2974 case NT_PRSTATUS:
2975 {
2976 char data[504];
2977 va_list ap;
2978 long pid;
2979 int cursig;
2980 const void *greg;
2981
2982 va_start (ap, note_type);
2983 memset (data, 0, 112);
2984 pid = va_arg (ap, long);
2985 bfd_put_32 (abfd, pid, data + 32);
2986 cursig = va_arg (ap, int);
2987 bfd_put_16 (abfd, cursig, data + 12);
2988 greg = va_arg (ap, const void *);
2989 memcpy (data + 112, greg, 384);
2990 memset (data + 496, 0, 8);
2991 va_end (ap);
2992 return elfcore_write_note (abfd, buf, bufsiz,
2993 "CORE", note_type, data, sizeof (data));
2994 }
2995 }
2996 }
2997
2998 /* Add extra PPC sections. */
2999
3000 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3001 {
3002 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3003 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3004 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3005 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3006 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3007 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3008 { NULL, 0, 0, 0, 0 }
3009 };
3010
3011 enum _ppc64_sec_type {
3012 sec_normal = 0,
3013 sec_opd = 1,
3014 sec_toc = 2
3015 };
3016
3017 struct _ppc64_elf_section_data
3018 {
3019 struct bfd_elf_section_data elf;
3020
3021 union
3022 {
3023 /* An array with one entry for each opd function descriptor,
3024 and some spares since opd entries may be either 16 or 24 bytes. */
3025 #define OPD_NDX(OFF) ((OFF) >> 4)
3026 struct _opd_sec_data
3027 {
3028 /* Points to the function code section for local opd entries. */
3029 asection **func_sec;
3030
3031 /* After editing .opd, adjust references to opd local syms. */
3032 long *adjust;
3033 } opd;
3034
3035 /* An array for toc sections, indexed by offset/8. */
3036 struct _toc_sec_data
3037 {
3038 /* Specifies the relocation symbol index used at a given toc offset. */
3039 unsigned *symndx;
3040
3041 /* And the relocation addend. */
3042 bfd_vma *add;
3043 } toc;
3044 } u;
3045
3046 enum _ppc64_sec_type sec_type:2;
3047
3048 /* Flag set when small branches are detected. Used to
3049 select suitable defaults for the stub group size. */
3050 unsigned int has_14bit_branch:1;
3051 };
3052
3053 #define ppc64_elf_section_data(sec) \
3054 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3055
3056 static bfd_boolean
3057 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3058 {
3059 if (!sec->used_by_bfd)
3060 {
3061 struct _ppc64_elf_section_data *sdata;
3062 bfd_size_type amt = sizeof (*sdata);
3063
3064 sdata = bfd_zalloc (abfd, amt);
3065 if (sdata == NULL)
3066 return FALSE;
3067 sec->used_by_bfd = sdata;
3068 }
3069
3070 return _bfd_elf_new_section_hook (abfd, sec);
3071 }
3072
3073 static struct _opd_sec_data *
3074 get_opd_info (asection * sec)
3075 {
3076 if (sec != NULL
3077 && ppc64_elf_section_data (sec) != NULL
3078 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3079 return &ppc64_elf_section_data (sec)->u.opd;
3080 return NULL;
3081 }
3082 \f
3083 /* Parameters for the qsort hook. */
3084 static bfd_boolean synthetic_relocatable;
3085
3086 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3087
3088 static int
3089 compare_symbols (const void *ap, const void *bp)
3090 {
3091 const asymbol *a = * (const asymbol **) ap;
3092 const asymbol *b = * (const asymbol **) bp;
3093
3094 /* Section symbols first. */
3095 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3096 return -1;
3097 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3098 return 1;
3099
3100 /* then .opd symbols. */
3101 if (strcmp (a->section->name, ".opd") == 0
3102 && strcmp (b->section->name, ".opd") != 0)
3103 return -1;
3104 if (strcmp (a->section->name, ".opd") != 0
3105 && strcmp (b->section->name, ".opd") == 0)
3106 return 1;
3107
3108 /* then other code symbols. */
3109 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3110 == (SEC_CODE | SEC_ALLOC)
3111 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3112 != (SEC_CODE | SEC_ALLOC))
3113 return -1;
3114
3115 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3116 != (SEC_CODE | SEC_ALLOC)
3117 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3118 == (SEC_CODE | SEC_ALLOC))
3119 return 1;
3120
3121 if (synthetic_relocatable)
3122 {
3123 if (a->section->id < b->section->id)
3124 return -1;
3125
3126 if (a->section->id > b->section->id)
3127 return 1;
3128 }
3129
3130 if (a->value + a->section->vma < b->value + b->section->vma)
3131 return -1;
3132
3133 if (a->value + a->section->vma > b->value + b->section->vma)
3134 return 1;
3135
3136 /* For syms with the same value, prefer strong dynamic global function
3137 syms over other syms. */
3138 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3139 return -1;
3140
3141 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3142 return 1;
3143
3144 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3145 return -1;
3146
3147 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3148 return 1;
3149
3150 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3151 return -1;
3152
3153 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3154 return 1;
3155
3156 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3157 return -1;
3158
3159 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3160 return 1;
3161
3162 return 0;
3163 }
3164
3165 /* Search SYMS for a symbol of the given VALUE. */
3166
3167 static asymbol *
3168 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3169 {
3170 long mid;
3171
3172 if (id == (unsigned) -1)
3173 {
3174 while (lo < hi)
3175 {
3176 mid = (lo + hi) >> 1;
3177 if (syms[mid]->value + syms[mid]->section->vma < value)
3178 lo = mid + 1;
3179 else if (syms[mid]->value + syms[mid]->section->vma > value)
3180 hi = mid;
3181 else
3182 return syms[mid];
3183 }
3184 }
3185 else
3186 {
3187 while (lo < hi)
3188 {
3189 mid = (lo + hi) >> 1;
3190 if (syms[mid]->section->id < id)
3191 lo = mid + 1;
3192 else if (syms[mid]->section->id > id)
3193 hi = mid;
3194 else if (syms[mid]->value < value)
3195 lo = mid + 1;
3196 else if (syms[mid]->value > value)
3197 hi = mid;
3198 else
3199 return syms[mid];
3200 }
3201 }
3202 return NULL;
3203 }
3204
3205 static bfd_boolean
3206 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3207 {
3208 bfd_vma vma = *(bfd_vma *) ptr;
3209 return ((section->flags & SEC_ALLOC) != 0
3210 && section->vma <= vma
3211 && vma < section->vma + section->size);
3212 }
3213
3214 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3215 entry syms. Also generate @plt symbols for the glink branch table.
3216 Returns count of synthetic symbols in RET or -1 on error. */
3217
3218 static long
3219 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3220 long static_count, asymbol **static_syms,
3221 long dyn_count, asymbol **dyn_syms,
3222 asymbol **ret)
3223 {
3224 asymbol *s;
3225 long i;
3226 long count;
3227 char *names;
3228 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3229 asection *opd = NULL;
3230 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3231 asymbol **syms;
3232 int abi = abiversion (abfd);
3233
3234 *ret = NULL;
3235
3236 if (abi < 2)
3237 {
3238 opd = bfd_get_section_by_name (abfd, ".opd");
3239 if (opd == NULL && abi == 1)
3240 return 0;
3241 }
3242
3243 symcount = static_count;
3244 if (!relocatable)
3245 symcount += dyn_count;
3246 if (symcount == 0)
3247 return 0;
3248
3249 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3250 if (syms == NULL)
3251 return -1;
3252
3253 if (!relocatable && static_count != 0 && dyn_count != 0)
3254 {
3255 /* Use both symbol tables. */
3256 memcpy (syms, static_syms, static_count * sizeof (*syms));
3257 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3258 }
3259 else if (!relocatable && static_count == 0)
3260 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3261 else
3262 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3263
3264 synthetic_relocatable = relocatable;
3265 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3266
3267 if (!relocatable && symcount > 1)
3268 {
3269 long j;
3270 /* Trim duplicate syms, since we may have merged the normal and
3271 dynamic symbols. Actually, we only care about syms that have
3272 different values, so trim any with the same value. */
3273 for (i = 1, j = 1; i < symcount; ++i)
3274 if (syms[i - 1]->value + syms[i - 1]->section->vma
3275 != syms[i]->value + syms[i]->section->vma)
3276 syms[j++] = syms[i];
3277 symcount = j;
3278 }
3279
3280 i = 0;
3281 if (strcmp (syms[i]->section->name, ".opd") == 0)
3282 ++i;
3283 codesecsym = i;
3284
3285 for (; i < symcount; ++i)
3286 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3287 != (SEC_CODE | SEC_ALLOC))
3288 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3289 break;
3290 codesecsymend = i;
3291
3292 for (; i < symcount; ++i)
3293 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3294 break;
3295 secsymend = i;
3296
3297 for (; i < symcount; ++i)
3298 if (strcmp (syms[i]->section->name, ".opd") != 0)
3299 break;
3300 opdsymend = i;
3301
3302 for (; i < symcount; ++i)
3303 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3304 != (SEC_CODE | SEC_ALLOC))
3305 break;
3306 symcount = i;
3307
3308 count = 0;
3309
3310 if (relocatable)
3311 {
3312 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3313 arelent *r;
3314 size_t size;
3315 long relcount;
3316
3317 if (opdsymend == secsymend)
3318 goto done;
3319
3320 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3321 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3322 if (relcount == 0)
3323 goto done;
3324
3325 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3326 {
3327 count = -1;
3328 goto done;
3329 }
3330
3331 size = 0;
3332 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3333 {
3334 asymbol *sym;
3335
3336 while (r < opd->relocation + relcount
3337 && r->address < syms[i]->value + opd->vma)
3338 ++r;
3339
3340 if (r == opd->relocation + relcount)
3341 break;
3342
3343 if (r->address != syms[i]->value + opd->vma)
3344 continue;
3345
3346 if (r->howto->type != R_PPC64_ADDR64)
3347 continue;
3348
3349 sym = *r->sym_ptr_ptr;
3350 if (!sym_exists_at (syms, opdsymend, symcount,
3351 sym->section->id, sym->value + r->addend))
3352 {
3353 ++count;
3354 size += sizeof (asymbol);
3355 size += strlen (syms[i]->name) + 2;
3356 }
3357 }
3358
3359 if (size == 0)
3360 goto done;
3361 s = *ret = bfd_malloc (size);
3362 if (s == NULL)
3363 {
3364 count = -1;
3365 goto done;
3366 }
3367
3368 names = (char *) (s + count);
3369
3370 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3371 {
3372 asymbol *sym;
3373
3374 while (r < opd->relocation + relcount
3375 && r->address < syms[i]->value + opd->vma)
3376 ++r;
3377
3378 if (r == opd->relocation + relcount)
3379 break;
3380
3381 if (r->address != syms[i]->value + opd->vma)
3382 continue;
3383
3384 if (r->howto->type != R_PPC64_ADDR64)
3385 continue;
3386
3387 sym = *r->sym_ptr_ptr;
3388 if (!sym_exists_at (syms, opdsymend, symcount,
3389 sym->section->id, sym->value + r->addend))
3390 {
3391 size_t len;
3392
3393 *s = *syms[i];
3394 s->flags |= BSF_SYNTHETIC;
3395 s->section = sym->section;
3396 s->value = sym->value + r->addend;
3397 s->name = names;
3398 *names++ = '.';
3399 len = strlen (syms[i]->name);
3400 memcpy (names, syms[i]->name, len + 1);
3401 names += len + 1;
3402 /* Have udata.p point back to the original symbol this
3403 synthetic symbol was derived from. */
3404 s->udata.p = syms[i];
3405 s++;
3406 }
3407 }
3408 }
3409 else
3410 {
3411 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3412 bfd_byte *contents = NULL;
3413 size_t size;
3414 long plt_count = 0;
3415 bfd_vma glink_vma = 0, resolv_vma = 0;
3416 asection *dynamic, *glink = NULL, *relplt = NULL;
3417 arelent *p;
3418
3419 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3420 {
3421 free_contents_and_exit_err:
3422 count = -1;
3423 free_contents_and_exit:
3424 if (contents)
3425 free (contents);
3426 goto done;
3427 }
3428
3429 size = 0;
3430 for (i = secsymend; i < opdsymend; ++i)
3431 {
3432 bfd_vma ent;
3433
3434 /* Ignore bogus symbols. */
3435 if (syms[i]->value > opd->size - 8)
3436 continue;
3437
3438 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3439 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3440 {
3441 ++count;
3442 size += sizeof (asymbol);
3443 size += strlen (syms[i]->name) + 2;
3444 }
3445 }
3446
3447 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3448 if (dyn_count != 0
3449 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3450 {
3451 bfd_byte *dynbuf, *extdyn, *extdynend;
3452 size_t extdynsize;
3453 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3454
3455 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3456 goto free_contents_and_exit_err;
3457
3458 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3459 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3460
3461 extdyn = dynbuf;
3462 extdynend = extdyn + dynamic->size;
3463 for (; extdyn < extdynend; extdyn += extdynsize)
3464 {
3465 Elf_Internal_Dyn dyn;
3466 (*swap_dyn_in) (abfd, extdyn, &dyn);
3467
3468 if (dyn.d_tag == DT_NULL)
3469 break;
3470
3471 if (dyn.d_tag == DT_PPC64_GLINK)
3472 {
3473 /* The first glink stub starts at offset 32; see
3474 comment in ppc64_elf_finish_dynamic_sections. */
3475 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3476 /* The .glink section usually does not survive the final
3477 link; search for the section (usually .text) where the
3478 glink stubs now reside. */
3479 glink = bfd_sections_find_if (abfd, section_covers_vma,
3480 &glink_vma);
3481 break;
3482 }
3483 }
3484
3485 free (dynbuf);
3486 }
3487
3488 if (glink != NULL)
3489 {
3490 /* Determine __glink trampoline by reading the relative branch
3491 from the first glink stub. */
3492 bfd_byte buf[4];
3493 unsigned int off = 0;
3494
3495 while (bfd_get_section_contents (abfd, glink, buf,
3496 glink_vma + off - glink->vma, 4))
3497 {
3498 unsigned int insn = bfd_get_32 (abfd, buf);
3499 insn ^= B_DOT;
3500 if ((insn & ~0x3fffffc) == 0)
3501 {
3502 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3503 break;
3504 }
3505 off += 4;
3506 if (off > 4)
3507 break;
3508 }
3509
3510 if (resolv_vma)
3511 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3512
3513 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3514 if (relplt != NULL)
3515 {
3516 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3517 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3518 goto free_contents_and_exit_err;
3519
3520 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3521 size += plt_count * sizeof (asymbol);
3522
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3525 {
3526 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3527 if (p->addend != 0)
3528 size += sizeof ("+0x") - 1 + 16;
3529 }
3530 }
3531 }
3532
3533 if (size == 0)
3534 goto free_contents_and_exit;
3535 s = *ret = bfd_malloc (size);
3536 if (s == NULL)
3537 goto free_contents_and_exit_err;
3538
3539 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3540
3541 for (i = secsymend; i < opdsymend; ++i)
3542 {
3543 bfd_vma ent;
3544
3545 if (syms[i]->value > opd->size - 8)
3546 continue;
3547
3548 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3549 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3550 {
3551 long lo, hi;
3552 size_t len;
3553 asection *sec = abfd->sections;
3554
3555 *s = *syms[i];
3556 lo = codesecsym;
3557 hi = codesecsymend;
3558 while (lo < hi)
3559 {
3560 long mid = (lo + hi) >> 1;
3561 if (syms[mid]->section->vma < ent)
3562 lo = mid + 1;
3563 else if (syms[mid]->section->vma > ent)
3564 hi = mid;
3565 else
3566 {
3567 sec = syms[mid]->section;
3568 break;
3569 }
3570 }
3571
3572 if (lo >= hi && lo > codesecsym)
3573 sec = syms[lo - 1]->section;
3574
3575 for (; sec != NULL; sec = sec->next)
3576 {
3577 if (sec->vma > ent)
3578 break;
3579 /* SEC_LOAD may not be set if SEC is from a separate debug
3580 info file. */
3581 if ((sec->flags & SEC_ALLOC) == 0)
3582 break;
3583 if ((sec->flags & SEC_CODE) != 0)
3584 s->section = sec;
3585 }
3586 s->flags |= BSF_SYNTHETIC;
3587 s->value = ent - s->section->vma;
3588 s->name = names;
3589 *names++ = '.';
3590 len = strlen (syms[i]->name);
3591 memcpy (names, syms[i]->name, len + 1);
3592 names += len + 1;
3593 /* Have udata.p point back to the original symbol this
3594 synthetic symbol was derived from. */
3595 s->udata.p = syms[i];
3596 s++;
3597 }
3598 }
3599 free (contents);
3600
3601 if (glink != NULL && relplt != NULL)
3602 {
3603 if (resolv_vma)
3604 {
3605 /* Add a symbol for the main glink trampoline. */
3606 memset (s, 0, sizeof *s);
3607 s->the_bfd = abfd;
3608 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3609 s->section = glink;
3610 s->value = resolv_vma - glink->vma;
3611 s->name = names;
3612 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3613 names += sizeof ("__glink_PLTresolve");
3614 s++;
3615 count++;
3616 }
3617
3618 /* FIXME: It would be very much nicer to put sym@plt on the
3619 stub rather than on the glink branch table entry. The
3620 objdump disassembler would then use a sensible symbol
3621 name on plt calls. The difficulty in doing so is
3622 a) finding the stubs, and,
3623 b) matching stubs against plt entries, and,
3624 c) there can be multiple stubs for a given plt entry.
3625
3626 Solving (a) could be done by code scanning, but older
3627 ppc64 binaries used different stubs to current code.
3628 (b) is the tricky one since you need to known the toc
3629 pointer for at least one function that uses a pic stub to
3630 be able to calculate the plt address referenced.
3631 (c) means gdb would need to set multiple breakpoints (or
3632 find the glink branch itself) when setting breakpoints
3633 for pending shared library loads. */
3634 p = relplt->relocation;
3635 for (i = 0; i < plt_count; i++, p++)
3636 {
3637 size_t len;
3638
3639 *s = **p->sym_ptr_ptr;
3640 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3641 we are defining a symbol, ensure one of them is set. */
3642 if ((s->flags & BSF_LOCAL) == 0)
3643 s->flags |= BSF_GLOBAL;
3644 s->flags |= BSF_SYNTHETIC;
3645 s->section = glink;
3646 s->value = glink_vma - glink->vma;
3647 s->name = names;
3648 s->udata.p = NULL;
3649 len = strlen ((*p->sym_ptr_ptr)->name);
3650 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3651 names += len;
3652 if (p->addend != 0)
3653 {
3654 memcpy (names, "+0x", sizeof ("+0x") - 1);
3655 names += sizeof ("+0x") - 1;
3656 bfd_sprintf_vma (abfd, names, p->addend);
3657 names += strlen (names);
3658 }
3659 memcpy (names, "@plt", sizeof ("@plt"));
3660 names += sizeof ("@plt");
3661 s++;
3662 if (abi < 2)
3663 {
3664 glink_vma += 8;
3665 if (i >= 0x8000)
3666 glink_vma += 4;
3667 }
3668 else
3669 glink_vma += 4;
3670 }
3671 count += plt_count;
3672 }
3673 }
3674
3675 done:
3676 free (syms);
3677 return count;
3678 }
3679 \f
3680 /* The following functions are specific to the ELF linker, while
3681 functions above are used generally. Those named ppc64_elf_* are
3682 called by the main ELF linker code. They appear in this file more
3683 or less in the order in which they are called. eg.
3684 ppc64_elf_check_relocs is called early in the link process,
3685 ppc64_elf_finish_dynamic_sections is one of the last functions
3686 called.
3687
3688 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3689 functions have both a function code symbol and a function descriptor
3690 symbol. A call to foo in a relocatable object file looks like:
3691
3692 . .text
3693 . x:
3694 . bl .foo
3695 . nop
3696
3697 The function definition in another object file might be:
3698
3699 . .section .opd
3700 . foo: .quad .foo
3701 . .quad .TOC.@tocbase
3702 . .quad 0
3703 .
3704 . .text
3705 . .foo: blr
3706
3707 When the linker resolves the call during a static link, the branch
3708 unsurprisingly just goes to .foo and the .opd information is unused.
3709 If the function definition is in a shared library, things are a little
3710 different: The call goes via a plt call stub, the opd information gets
3711 copied to the plt, and the linker patches the nop.
3712
3713 . x:
3714 . bl .foo_stub
3715 . ld 2,40(1)
3716 .
3717 .
3718 . .foo_stub:
3719 . std 2,40(1) # in practice, the call stub
3720 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3721 . addi 11,11,Lfoo@toc@l # this is the general idea
3722 . ld 12,0(11)
3723 . ld 2,8(11)
3724 . mtctr 12
3725 . ld 11,16(11)
3726 . bctr
3727 .
3728 . .section .plt
3729 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3730
3731 The "reloc ()" notation is supposed to indicate that the linker emits
3732 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3733 copying.
3734
3735 What are the difficulties here? Well, firstly, the relocations
3736 examined by the linker in check_relocs are against the function code
3737 sym .foo, while the dynamic relocation in the plt is emitted against
3738 the function descriptor symbol, foo. Somewhere along the line, we need
3739 to carefully copy dynamic link information from one symbol to the other.
3740 Secondly, the generic part of the elf linker will make .foo a dynamic
3741 symbol as is normal for most other backends. We need foo dynamic
3742 instead, at least for an application final link. However, when
3743 creating a shared library containing foo, we need to have both symbols
3744 dynamic so that references to .foo are satisfied during the early
3745 stages of linking. Otherwise the linker might decide to pull in a
3746 definition from some other object, eg. a static library.
3747
3748 Update: As of August 2004, we support a new convention. Function
3749 calls may use the function descriptor symbol, ie. "bl foo". This
3750 behaves exactly as "bl .foo". */
3751
3752 /* Of those relocs that might be copied as dynamic relocs, this function
3753 selects those that must be copied when linking a shared library,
3754 even when the symbol is local. */
3755
3756 static int
3757 must_be_dyn_reloc (struct bfd_link_info *info,
3758 enum elf_ppc64_reloc_type r_type)
3759 {
3760 switch (r_type)
3761 {
3762 default:
3763 return 1;
3764
3765 case R_PPC64_REL32:
3766 case R_PPC64_REL64:
3767 case R_PPC64_REL30:
3768 return 0;
3769
3770 case R_PPC64_TPREL16:
3771 case R_PPC64_TPREL16_LO:
3772 case R_PPC64_TPREL16_HI:
3773 case R_PPC64_TPREL16_HA:
3774 case R_PPC64_TPREL16_DS:
3775 case R_PPC64_TPREL16_LO_DS:
3776 case R_PPC64_TPREL16_HIGH:
3777 case R_PPC64_TPREL16_HIGHA:
3778 case R_PPC64_TPREL16_HIGHER:
3779 case R_PPC64_TPREL16_HIGHERA:
3780 case R_PPC64_TPREL16_HIGHEST:
3781 case R_PPC64_TPREL16_HIGHESTA:
3782 case R_PPC64_TPREL64:
3783 return !bfd_link_executable (info);
3784 }
3785 }
3786
3787 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3788 copying dynamic variables from a shared lib into an app's dynbss
3789 section, and instead use a dynamic relocation to point into the
3790 shared lib. With code that gcc generates, it's vital that this be
3791 enabled; In the PowerPC64 ABI, the address of a function is actually
3792 the address of a function descriptor, which resides in the .opd
3793 section. gcc uses the descriptor directly rather than going via the
3794 GOT as some other ABI's do, which means that initialized function
3795 pointers must reference the descriptor. Thus, a function pointer
3796 initialized to the address of a function in a shared library will
3797 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3798 redefines the function descriptor symbol to point to the copy. This
3799 presents a problem as a plt entry for that function is also
3800 initialized from the function descriptor symbol and the copy reloc
3801 may not be initialized first. */
3802 #define ELIMINATE_COPY_RELOCS 1
3803
3804 /* Section name for stubs is the associated section name plus this
3805 string. */
3806 #define STUB_SUFFIX ".stub"
3807
3808 /* Linker stubs.
3809 ppc_stub_long_branch:
3810 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3811 destination, but a 24 bit branch in a stub section will reach.
3812 . b dest
3813
3814 ppc_stub_plt_branch:
3815 Similar to the above, but a 24 bit branch in the stub section won't
3816 reach its destination.
3817 . addis %r11,%r2,xxx@toc@ha
3818 . ld %r12,xxx@toc@l(%r11)
3819 . mtctr %r12
3820 . bctr
3821
3822 ppc_stub_plt_call:
3823 Used to call a function in a shared library. If it so happens that
3824 the plt entry referenced crosses a 64k boundary, then an extra
3825 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3826 . std %r2,40(%r1)
3827 . addis %r11,%r2,xxx@toc@ha
3828 . ld %r12,xxx+0@toc@l(%r11)
3829 . mtctr %r12
3830 . ld %r2,xxx+8@toc@l(%r11)
3831 . ld %r11,xxx+16@toc@l(%r11)
3832 . bctr
3833
3834 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3835 code to adjust the value and save r2 to support multiple toc sections.
3836 A ppc_stub_long_branch with an r2 offset looks like:
3837 . std %r2,40(%r1)
3838 . addis %r2,%r2,off@ha
3839 . addi %r2,%r2,off@l
3840 . b dest
3841
3842 A ppc_stub_plt_branch with an r2 offset looks like:
3843 . std %r2,40(%r1)
3844 . addis %r11,%r2,xxx@toc@ha
3845 . ld %r12,xxx@toc@l(%r11)
3846 . addis %r2,%r2,off@ha
3847 . addi %r2,%r2,off@l
3848 . mtctr %r12
3849 . bctr
3850
3851 In cases where the "addis" instruction would add zero, the "addis" is
3852 omitted and following instructions modified slightly in some cases.
3853 */
3854
3855 enum ppc_stub_type {
3856 ppc_stub_none,
3857 ppc_stub_long_branch,
3858 ppc_stub_long_branch_r2off,
3859 ppc_stub_plt_branch,
3860 ppc_stub_plt_branch_r2off,
3861 ppc_stub_plt_call,
3862 ppc_stub_plt_call_r2save,
3863 ppc_stub_global_entry,
3864 ppc_stub_save_res
3865 };
3866
3867 /* Information on stub grouping. */
3868 struct map_stub
3869 {
3870 /* The stub section. */
3871 asection *stub_sec;
3872 /* This is the section to which stubs in the group will be attached. */
3873 asection *link_sec;
3874 /* Next group. */
3875 struct map_stub *next;
3876 /* Whether to emit a copy of register save/restore functions in this
3877 group. */
3878 int needs_save_res;
3879 };
3880
3881 struct ppc_stub_hash_entry {
3882
3883 /* Base hash table entry structure. */
3884 struct bfd_hash_entry root;
3885
3886 enum ppc_stub_type stub_type;
3887
3888 /* Group information. */
3889 struct map_stub *group;
3890
3891 /* Offset within stub_sec of the beginning of this stub. */
3892 bfd_vma stub_offset;
3893
3894 /* Given the symbol's value and its section we can determine its final
3895 value when building the stubs (so the stub knows where to jump. */
3896 bfd_vma target_value;
3897 asection *target_section;
3898
3899 /* The symbol table entry, if any, that this was derived from. */
3900 struct ppc_link_hash_entry *h;
3901 struct plt_entry *plt_ent;
3902
3903 /* Symbol st_other. */
3904 unsigned char other;
3905 };
3906
3907 struct ppc_branch_hash_entry {
3908
3909 /* Base hash table entry structure. */
3910 struct bfd_hash_entry root;
3911
3912 /* Offset within branch lookup table. */
3913 unsigned int offset;
3914
3915 /* Generation marker. */
3916 unsigned int iter;
3917 };
3918
3919 /* Used to track dynamic relocations for local symbols. */
3920 struct ppc_dyn_relocs
3921 {
3922 struct ppc_dyn_relocs *next;
3923
3924 /* The input section of the reloc. */
3925 asection *sec;
3926
3927 /* Total number of relocs copied for the input section. */
3928 unsigned int count : 31;
3929
3930 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3931 unsigned int ifunc : 1;
3932 };
3933
3934 struct ppc_link_hash_entry
3935 {
3936 struct elf_link_hash_entry elf;
3937
3938 union {
3939 /* A pointer to the most recently used stub hash entry against this
3940 symbol. */
3941 struct ppc_stub_hash_entry *stub_cache;
3942
3943 /* A pointer to the next symbol starting with a '.' */
3944 struct ppc_link_hash_entry *next_dot_sym;
3945 } u;
3946
3947 /* Track dynamic relocs copied for this symbol. */
3948 struct elf_dyn_relocs *dyn_relocs;
3949
3950 /* Link between function code and descriptor symbols. */
3951 struct ppc_link_hash_entry *oh;
3952
3953 /* Flag function code and descriptor symbols. */
3954 unsigned int is_func:1;
3955 unsigned int is_func_descriptor:1;
3956 unsigned int fake:1;
3957
3958 /* Whether global opd/toc sym has been adjusted or not.
3959 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3960 should be set for all globals defined in any opd/toc section. */
3961 unsigned int adjust_done:1;
3962
3963 /* Set if we twiddled this symbol to weak at some stage. */
3964 unsigned int was_undefined:1;
3965
3966 /* Set if this is an out-of-line register save/restore function,
3967 with non-standard calling convention. */
3968 unsigned int save_res:1;
3969
3970 /* Contexts in which symbol is used in the GOT (or TOC).
3971 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3972 corresponding relocs are encountered during check_relocs.
3973 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3974 indicate the corresponding GOT entry type is not needed.
3975 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3976 a TPREL one. We use a separate flag rather than setting TPREL
3977 just for convenience in distinguishing the two cases. */
3978 #define TLS_GD 1 /* GD reloc. */
3979 #define TLS_LD 2 /* LD reloc. */
3980 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3981 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3982 #define TLS_TLS 16 /* Any TLS reloc. */
3983 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3984 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3985 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3986 unsigned char tls_mask;
3987 };
3988
3989 /* ppc64 ELF linker hash table. */
3990
3991 struct ppc_link_hash_table
3992 {
3993 struct elf_link_hash_table elf;
3994
3995 /* The stub hash table. */
3996 struct bfd_hash_table stub_hash_table;
3997
3998 /* Another hash table for plt_branch stubs. */
3999 struct bfd_hash_table branch_hash_table;
4000
4001 /* Hash table for function prologue tocsave. */
4002 htab_t tocsave_htab;
4003
4004 /* Various options and other info passed from the linker. */
4005 struct ppc64_elf_params *params;
4006
4007 /* The size of sec_info below. */
4008 unsigned int sec_info_arr_size;
4009
4010 /* Per-section array of extra section info. Done this way rather
4011 than as part of ppc64_elf_section_data so we have the info for
4012 non-ppc64 sections. */
4013 struct
4014 {
4015 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4016 bfd_vma toc_off;
4017
4018 union
4019 {
4020 /* The section group that this section belongs to. */
4021 struct map_stub *group;
4022 /* A temp section list pointer. */
4023 asection *list;
4024 } u;
4025 } *sec_info;
4026
4027 /* Linked list of groups. */
4028 struct map_stub *group;
4029
4030 /* Temp used when calculating TOC pointers. */
4031 bfd_vma toc_curr;
4032 bfd *toc_bfd;
4033 asection *toc_first_sec;
4034
4035 /* Used when adding symbols. */
4036 struct ppc_link_hash_entry *dot_syms;
4037
4038 /* Shortcuts to get to dynamic linker sections. */
4039 asection *dynbss;
4040 asection *relbss;
4041 asection *glink;
4042 asection *sfpr;
4043 asection *brlt;
4044 asection *relbrlt;
4045 asection *glink_eh_frame;
4046
4047 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4048 struct ppc_link_hash_entry *tls_get_addr;
4049 struct ppc_link_hash_entry *tls_get_addr_fd;
4050
4051 /* The size of reliplt used by got entry relocs. */
4052 bfd_size_type got_reli_size;
4053
4054 /* Statistics. */
4055 unsigned long stub_count[ppc_stub_global_entry];
4056
4057 /* Number of stubs against global syms. */
4058 unsigned long stub_globals;
4059
4060 /* Set if we're linking code with function descriptors. */
4061 unsigned int opd_abi:1;
4062
4063 /* Support for multiple toc sections. */
4064 unsigned int do_multi_toc:1;
4065 unsigned int multi_toc_needed:1;
4066 unsigned int second_toc_pass:1;
4067 unsigned int do_toc_opt:1;
4068
4069 /* Set on error. */
4070 unsigned int stub_error:1;
4071
4072 /* Temp used by ppc64_elf_before_check_relocs. */
4073 unsigned int twiddled_syms:1;
4074
4075 /* Incremented every time we size stubs. */
4076 unsigned int stub_iteration;
4077
4078 /* Small local sym cache. */
4079 struct sym_cache sym_cache;
4080 };
4081
4082 /* Rename some of the generic section flags to better document how they
4083 are used here. */
4084
4085 /* Nonzero if this section has TLS related relocations. */
4086 #define has_tls_reloc sec_flg0
4087
4088 /* Nonzero if this section has a call to __tls_get_addr. */
4089 #define has_tls_get_addr_call sec_flg1
4090
4091 /* Nonzero if this section has any toc or got relocs. */
4092 #define has_toc_reloc sec_flg2
4093
4094 /* Nonzero if this section has a call to another section that uses
4095 the toc or got. */
4096 #define makes_toc_func_call sec_flg3
4097
4098 /* Recursion protection when determining above flag. */
4099 #define call_check_in_progress sec_flg4
4100 #define call_check_done sec_flg5
4101
4102 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4103
4104 #define ppc_hash_table(p) \
4105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4106 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4107
4108 #define ppc_stub_hash_lookup(table, string, create, copy) \
4109 ((struct ppc_stub_hash_entry *) \
4110 bfd_hash_lookup ((table), (string), (create), (copy)))
4111
4112 #define ppc_branch_hash_lookup(table, string, create, copy) \
4113 ((struct ppc_branch_hash_entry *) \
4114 bfd_hash_lookup ((table), (string), (create), (copy)))
4115
4116 /* Create an entry in the stub hash table. */
4117
4118 static struct bfd_hash_entry *
4119 stub_hash_newfunc (struct bfd_hash_entry *entry,
4120 struct bfd_hash_table *table,
4121 const char *string)
4122 {
4123 /* Allocate the structure if it has not already been allocated by a
4124 subclass. */
4125 if (entry == NULL)
4126 {
4127 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4128 if (entry == NULL)
4129 return entry;
4130 }
4131
4132 /* Call the allocation method of the superclass. */
4133 entry = bfd_hash_newfunc (entry, table, string);
4134 if (entry != NULL)
4135 {
4136 struct ppc_stub_hash_entry *eh;
4137
4138 /* Initialize the local fields. */
4139 eh = (struct ppc_stub_hash_entry *) entry;
4140 eh->stub_type = ppc_stub_none;
4141 eh->group = NULL;
4142 eh->stub_offset = 0;
4143 eh->target_value = 0;
4144 eh->target_section = NULL;
4145 eh->h = NULL;
4146 eh->plt_ent = NULL;
4147 eh->other = 0;
4148 }
4149
4150 return entry;
4151 }
4152
4153 /* Create an entry in the branch hash table. */
4154
4155 static struct bfd_hash_entry *
4156 branch_hash_newfunc (struct bfd_hash_entry *entry,
4157 struct bfd_hash_table *table,
4158 const char *string)
4159 {
4160 /* Allocate the structure if it has not already been allocated by a
4161 subclass. */
4162 if (entry == NULL)
4163 {
4164 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4165 if (entry == NULL)
4166 return entry;
4167 }
4168
4169 /* Call the allocation method of the superclass. */
4170 entry = bfd_hash_newfunc (entry, table, string);
4171 if (entry != NULL)
4172 {
4173 struct ppc_branch_hash_entry *eh;
4174
4175 /* Initialize the local fields. */
4176 eh = (struct ppc_branch_hash_entry *) entry;
4177 eh->offset = 0;
4178 eh->iter = 0;
4179 }
4180
4181 return entry;
4182 }
4183
4184 /* Create an entry in a ppc64 ELF linker hash table. */
4185
4186 static struct bfd_hash_entry *
4187 link_hash_newfunc (struct bfd_hash_entry *entry,
4188 struct bfd_hash_table *table,
4189 const char *string)
4190 {
4191 /* Allocate the structure if it has not already been allocated by a
4192 subclass. */
4193 if (entry == NULL)
4194 {
4195 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4196 if (entry == NULL)
4197 return entry;
4198 }
4199
4200 /* Call the allocation method of the superclass. */
4201 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4202 if (entry != NULL)
4203 {
4204 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4205
4206 memset (&eh->u.stub_cache, 0,
4207 (sizeof (struct ppc_link_hash_entry)
4208 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4209
4210 /* When making function calls, old ABI code references function entry
4211 points (dot symbols), while new ABI code references the function
4212 descriptor symbol. We need to make any combination of reference and
4213 definition work together, without breaking archive linking.
4214
4215 For a defined function "foo" and an undefined call to "bar":
4216 An old object defines "foo" and ".foo", references ".bar" (possibly
4217 "bar" too).
4218 A new object defines "foo" and references "bar".
4219
4220 A new object thus has no problem with its undefined symbols being
4221 satisfied by definitions in an old object. On the other hand, the
4222 old object won't have ".bar" satisfied by a new object.
4223
4224 Keep a list of newly added dot-symbols. */
4225
4226 if (string[0] == '.')
4227 {
4228 struct ppc_link_hash_table *htab;
4229
4230 htab = (struct ppc_link_hash_table *) table;
4231 eh->u.next_dot_sym = htab->dot_syms;
4232 htab->dot_syms = eh;
4233 }
4234 }
4235
4236 return entry;
4237 }
4238
4239 struct tocsave_entry {
4240 asection *sec;
4241 bfd_vma offset;
4242 };
4243
4244 static hashval_t
4245 tocsave_htab_hash (const void *p)
4246 {
4247 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4248 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4249 }
4250
4251 static int
4252 tocsave_htab_eq (const void *p1, const void *p2)
4253 {
4254 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4255 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4256 return e1->sec == e2->sec && e1->offset == e2->offset;
4257 }
4258
4259 /* Destroy a ppc64 ELF linker hash table. */
4260
4261 static void
4262 ppc64_elf_link_hash_table_free (bfd *obfd)
4263 {
4264 struct ppc_link_hash_table *htab;
4265
4266 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4267 if (htab->tocsave_htab)
4268 htab_delete (htab->tocsave_htab);
4269 bfd_hash_table_free (&htab->branch_hash_table);
4270 bfd_hash_table_free (&htab->stub_hash_table);
4271 _bfd_elf_link_hash_table_free (obfd);
4272 }
4273
4274 /* Create a ppc64 ELF linker hash table. */
4275
4276 static struct bfd_link_hash_table *
4277 ppc64_elf_link_hash_table_create (bfd *abfd)
4278 {
4279 struct ppc_link_hash_table *htab;
4280 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4281
4282 htab = bfd_zmalloc (amt);
4283 if (htab == NULL)
4284 return NULL;
4285
4286 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4287 sizeof (struct ppc_link_hash_entry),
4288 PPC64_ELF_DATA))
4289 {
4290 free (htab);
4291 return NULL;
4292 }
4293
4294 /* Init the stub hash table too. */
4295 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4296 sizeof (struct ppc_stub_hash_entry)))
4297 {
4298 _bfd_elf_link_hash_table_free (abfd);
4299 return NULL;
4300 }
4301
4302 /* And the branch hash table. */
4303 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4304 sizeof (struct ppc_branch_hash_entry)))
4305 {
4306 bfd_hash_table_free (&htab->stub_hash_table);
4307 _bfd_elf_link_hash_table_free (abfd);
4308 return NULL;
4309 }
4310
4311 htab->tocsave_htab = htab_try_create (1024,
4312 tocsave_htab_hash,
4313 tocsave_htab_eq,
4314 NULL);
4315 if (htab->tocsave_htab == NULL)
4316 {
4317 ppc64_elf_link_hash_table_free (abfd);
4318 return NULL;
4319 }
4320 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4321
4322 /* Initializing two fields of the union is just cosmetic. We really
4323 only care about glist, but when compiled on a 32-bit host the
4324 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4325 debugger inspection of these fields look nicer. */
4326 htab->elf.init_got_refcount.refcount = 0;
4327 htab->elf.init_got_refcount.glist = NULL;
4328 htab->elf.init_plt_refcount.refcount = 0;
4329 htab->elf.init_plt_refcount.glist = NULL;
4330 htab->elf.init_got_offset.offset = 0;
4331 htab->elf.init_got_offset.glist = NULL;
4332 htab->elf.init_plt_offset.offset = 0;
4333 htab->elf.init_plt_offset.glist = NULL;
4334
4335 return &htab->elf.root;
4336 }
4337
4338 /* Create sections for linker generated code. */
4339
4340 static bfd_boolean
4341 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4342 {
4343 struct ppc_link_hash_table *htab;
4344 flagword flags;
4345
4346 htab = ppc_hash_table (info);
4347
4348 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4349 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4350 if (htab->params->save_restore_funcs)
4351 {
4352 /* Create .sfpr for code to save and restore fp regs. */
4353 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4354 flags);
4355 if (htab->sfpr == NULL
4356 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4357 return FALSE;
4358 }
4359
4360 if (bfd_link_relocatable (info))
4361 return TRUE;
4362
4363 /* Create .glink for lazy dynamic linking support. */
4364 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4365 flags);
4366 if (htab->glink == NULL
4367 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4368 return FALSE;
4369
4370 if (!info->no_ld_generated_unwind_info)
4371 {
4372 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4373 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4374 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4375 ".eh_frame",
4376 flags);
4377 if (htab->glink_eh_frame == NULL
4378 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4379 return FALSE;
4380 }
4381
4382 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4383 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4384 if (htab->elf.iplt == NULL
4385 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4386 return FALSE;
4387
4388 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4389 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4390 htab->elf.irelplt
4391 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4392 if (htab->elf.irelplt == NULL
4393 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4394 return FALSE;
4395
4396 /* Create branch lookup table for plt_branch stubs. */
4397 flags = (SEC_ALLOC | SEC_LOAD
4398 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4399 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4400 flags);
4401 if (htab->brlt == NULL
4402 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4403 return FALSE;
4404
4405 if (!bfd_link_pic (info))
4406 return TRUE;
4407
4408 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4409 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4410 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4411 ".rela.branch_lt",
4412 flags);
4413 if (htab->relbrlt == NULL
4414 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4415 return FALSE;
4416
4417 return TRUE;
4418 }
4419
4420 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4421
4422 bfd_boolean
4423 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4424 struct ppc64_elf_params *params)
4425 {
4426 struct ppc_link_hash_table *htab;
4427
4428 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4429
4430 /* Always hook our dynamic sections into the first bfd, which is the
4431 linker created stub bfd. This ensures that the GOT header is at
4432 the start of the output TOC section. */
4433 htab = ppc_hash_table (info);
4434 htab->elf.dynobj = params->stub_bfd;
4435 htab->params = params;
4436
4437 return create_linkage_sections (htab->elf.dynobj, info);
4438 }
4439
4440 /* Build a name for an entry in the stub hash table. */
4441
4442 static char *
4443 ppc_stub_name (const asection *input_section,
4444 const asection *sym_sec,
4445 const struct ppc_link_hash_entry *h,
4446 const Elf_Internal_Rela *rel)
4447 {
4448 char *stub_name;
4449 ssize_t len;
4450
4451 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4452 offsets from a sym as a branch target? In fact, we could
4453 probably assume the addend is always zero. */
4454 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4455
4456 if (h)
4457 {
4458 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4459 stub_name = bfd_malloc (len);
4460 if (stub_name == NULL)
4461 return stub_name;
4462
4463 len = sprintf (stub_name, "%08x.%s+%x",
4464 input_section->id & 0xffffffff,
4465 h->elf.root.root.string,
4466 (int) rel->r_addend & 0xffffffff);
4467 }
4468 else
4469 {
4470 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4471 stub_name = bfd_malloc (len);
4472 if (stub_name == NULL)
4473 return stub_name;
4474
4475 len = sprintf (stub_name, "%08x.%x:%x+%x",
4476 input_section->id & 0xffffffff,
4477 sym_sec->id & 0xffffffff,
4478 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4479 (int) rel->r_addend & 0xffffffff);
4480 }
4481 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4482 stub_name[len - 2] = 0;
4483 return stub_name;
4484 }
4485
4486 /* Look up an entry in the stub hash. Stub entries are cached because
4487 creating the stub name takes a bit of time. */
4488
4489 static struct ppc_stub_hash_entry *
4490 ppc_get_stub_entry (const asection *input_section,
4491 const asection *sym_sec,
4492 struct ppc_link_hash_entry *h,
4493 const Elf_Internal_Rela *rel,
4494 struct ppc_link_hash_table *htab)
4495 {
4496 struct ppc_stub_hash_entry *stub_entry;
4497 struct map_stub *group;
4498
4499 /* If this input section is part of a group of sections sharing one
4500 stub section, then use the id of the first section in the group.
4501 Stub names need to include a section id, as there may well be
4502 more than one stub used to reach say, printf, and we need to
4503 distinguish between them. */
4504 group = htab->sec_info[input_section->id].u.group;
4505
4506 if (h != NULL && h->u.stub_cache != NULL
4507 && h->u.stub_cache->h == h
4508 && h->u.stub_cache->group == group)
4509 {
4510 stub_entry = h->u.stub_cache;
4511 }
4512 else
4513 {
4514 char *stub_name;
4515
4516 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4517 if (stub_name == NULL)
4518 return NULL;
4519
4520 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4521 stub_name, FALSE, FALSE);
4522 if (h != NULL)
4523 h->u.stub_cache = stub_entry;
4524
4525 free (stub_name);
4526 }
4527
4528 return stub_entry;
4529 }
4530
4531 /* Add a new stub entry to the stub hash. Not all fields of the new
4532 stub entry are initialised. */
4533
4534 static struct ppc_stub_hash_entry *
4535 ppc_add_stub (const char *stub_name,
4536 asection *section,
4537 struct bfd_link_info *info)
4538 {
4539 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4540 struct map_stub *group;
4541 asection *link_sec;
4542 asection *stub_sec;
4543 struct ppc_stub_hash_entry *stub_entry;
4544
4545 group = htab->sec_info[section->id].u.group;
4546 link_sec = group->link_sec;
4547 stub_sec = group->stub_sec;
4548 if (stub_sec == NULL)
4549 {
4550 size_t namelen;
4551 bfd_size_type len;
4552 char *s_name;
4553
4554 namelen = strlen (link_sec->name);
4555 len = namelen + sizeof (STUB_SUFFIX);
4556 s_name = bfd_alloc (htab->params->stub_bfd, len);
4557 if (s_name == NULL)
4558 return NULL;
4559
4560 memcpy (s_name, link_sec->name, namelen);
4561 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4562 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4563 if (stub_sec == NULL)
4564 return NULL;
4565 group->stub_sec = stub_sec;
4566 }
4567
4568 /* Enter this entry into the linker stub hash table. */
4569 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4570 TRUE, FALSE);
4571 if (stub_entry == NULL)
4572 {
4573 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4574 section->owner, stub_name);
4575 return NULL;
4576 }
4577
4578 stub_entry->group = group;
4579 stub_entry->stub_offset = 0;
4580 return stub_entry;
4581 }
4582
4583 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4584 not already done. */
4585
4586 static bfd_boolean
4587 create_got_section (bfd *abfd, struct bfd_link_info *info)
4588 {
4589 asection *got, *relgot;
4590 flagword flags;
4591 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4592
4593 if (!is_ppc64_elf (abfd))
4594 return FALSE;
4595 if (htab == NULL)
4596 return FALSE;
4597
4598 if (!htab->elf.sgot
4599 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4600 return FALSE;
4601
4602 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4603 | SEC_LINKER_CREATED);
4604
4605 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4606 if (!got
4607 || !bfd_set_section_alignment (abfd, got, 3))
4608 return FALSE;
4609
4610 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4611 flags | SEC_READONLY);
4612 if (!relgot
4613 || ! bfd_set_section_alignment (abfd, relgot, 3))
4614 return FALSE;
4615
4616 ppc64_elf_tdata (abfd)->got = got;
4617 ppc64_elf_tdata (abfd)->relgot = relgot;
4618 return TRUE;
4619 }
4620
4621 /* Create the dynamic sections, and set up shortcuts. */
4622
4623 static bfd_boolean
4624 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4625 {
4626 struct ppc_link_hash_table *htab;
4627
4628 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4629 return FALSE;
4630
4631 htab = ppc_hash_table (info);
4632 if (htab == NULL)
4633 return FALSE;
4634
4635 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4636 if (!bfd_link_pic (info))
4637 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4638
4639 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4640 || (!bfd_link_pic (info) && !htab->relbss))
4641 abort ();
4642
4643 return TRUE;
4644 }
4645
4646 /* Follow indirect and warning symbol links. */
4647
4648 static inline struct bfd_link_hash_entry *
4649 follow_link (struct bfd_link_hash_entry *h)
4650 {
4651 while (h->type == bfd_link_hash_indirect
4652 || h->type == bfd_link_hash_warning)
4653 h = h->u.i.link;
4654 return h;
4655 }
4656
4657 static inline struct elf_link_hash_entry *
4658 elf_follow_link (struct elf_link_hash_entry *h)
4659 {
4660 return (struct elf_link_hash_entry *) follow_link (&h->root);
4661 }
4662
4663 static inline struct ppc_link_hash_entry *
4664 ppc_follow_link (struct ppc_link_hash_entry *h)
4665 {
4666 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4667 }
4668
4669 /* Merge PLT info on FROM with that on TO. */
4670
4671 static void
4672 move_plt_plist (struct ppc_link_hash_entry *from,
4673 struct ppc_link_hash_entry *to)
4674 {
4675 if (from->elf.plt.plist != NULL)
4676 {
4677 if (to->elf.plt.plist != NULL)
4678 {
4679 struct plt_entry **entp;
4680 struct plt_entry *ent;
4681
4682 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4683 {
4684 struct plt_entry *dent;
4685
4686 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4687 if (dent->addend == ent->addend)
4688 {
4689 dent->plt.refcount += ent->plt.refcount;
4690 *entp = ent->next;
4691 break;
4692 }
4693 if (dent == NULL)
4694 entp = &ent->next;
4695 }
4696 *entp = to->elf.plt.plist;
4697 }
4698
4699 to->elf.plt.plist = from->elf.plt.plist;
4700 from->elf.plt.plist = NULL;
4701 }
4702 }
4703
4704 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4705
4706 static void
4707 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4708 struct elf_link_hash_entry *dir,
4709 struct elf_link_hash_entry *ind)
4710 {
4711 struct ppc_link_hash_entry *edir, *eind;
4712
4713 edir = (struct ppc_link_hash_entry *) dir;
4714 eind = (struct ppc_link_hash_entry *) ind;
4715
4716 edir->is_func |= eind->is_func;
4717 edir->is_func_descriptor |= eind->is_func_descriptor;
4718 edir->tls_mask |= eind->tls_mask;
4719 if (eind->oh != NULL)
4720 edir->oh = ppc_follow_link (eind->oh);
4721
4722 /* If called to transfer flags for a weakdef during processing
4723 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4724 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4725 if (!(ELIMINATE_COPY_RELOCS
4726 && eind->elf.root.type != bfd_link_hash_indirect
4727 && edir->elf.dynamic_adjusted))
4728 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4729
4730 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4731 edir->elf.ref_regular |= eind->elf.ref_regular;
4732 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4733 edir->elf.needs_plt |= eind->elf.needs_plt;
4734 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4735
4736 /* Copy over any dynamic relocs we may have on the indirect sym. */
4737 if (eind->dyn_relocs != NULL)
4738 {
4739 if (edir->dyn_relocs != NULL)
4740 {
4741 struct elf_dyn_relocs **pp;
4742 struct elf_dyn_relocs *p;
4743
4744 /* Add reloc counts against the indirect sym to the direct sym
4745 list. Merge any entries against the same section. */
4746 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4747 {
4748 struct elf_dyn_relocs *q;
4749
4750 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4751 if (q->sec == p->sec)
4752 {
4753 q->pc_count += p->pc_count;
4754 q->count += p->count;
4755 *pp = p->next;
4756 break;
4757 }
4758 if (q == NULL)
4759 pp = &p->next;
4760 }
4761 *pp = edir->dyn_relocs;
4762 }
4763
4764 edir->dyn_relocs = eind->dyn_relocs;
4765 eind->dyn_relocs = NULL;
4766 }
4767
4768 /* If we were called to copy over info for a weak sym, that's all.
4769 You might think dyn_relocs need not be copied over; After all,
4770 both syms will be dynamic or both non-dynamic so we're just
4771 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4772 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4773 dyn_relocs in read-only sections, and it does so on what is the
4774 DIR sym here. */
4775 if (eind->elf.root.type != bfd_link_hash_indirect)
4776 return;
4777
4778 /* Copy over got entries that we may have already seen to the
4779 symbol which just became indirect. */
4780 if (eind->elf.got.glist != NULL)
4781 {
4782 if (edir->elf.got.glist != NULL)
4783 {
4784 struct got_entry **entp;
4785 struct got_entry *ent;
4786
4787 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4788 {
4789 struct got_entry *dent;
4790
4791 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4792 if (dent->addend == ent->addend
4793 && dent->owner == ent->owner
4794 && dent->tls_type == ent->tls_type)
4795 {
4796 dent->got.refcount += ent->got.refcount;
4797 *entp = ent->next;
4798 break;
4799 }
4800 if (dent == NULL)
4801 entp = &ent->next;
4802 }
4803 *entp = edir->elf.got.glist;
4804 }
4805
4806 edir->elf.got.glist = eind->elf.got.glist;
4807 eind->elf.got.glist = NULL;
4808 }
4809
4810 /* And plt entries. */
4811 move_plt_plist (eind, edir);
4812
4813 if (eind->elf.dynindx != -1)
4814 {
4815 if (edir->elf.dynindx != -1)
4816 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4817 edir->elf.dynstr_index);
4818 edir->elf.dynindx = eind->elf.dynindx;
4819 edir->elf.dynstr_index = eind->elf.dynstr_index;
4820 eind->elf.dynindx = -1;
4821 eind->elf.dynstr_index = 0;
4822 }
4823 }
4824
4825 /* Find the function descriptor hash entry from the given function code
4826 hash entry FH. Link the entries via their OH fields. */
4827
4828 static struct ppc_link_hash_entry *
4829 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4830 {
4831 struct ppc_link_hash_entry *fdh = fh->oh;
4832
4833 if (fdh == NULL)
4834 {
4835 const char *fd_name = fh->elf.root.root.string + 1;
4836
4837 fdh = (struct ppc_link_hash_entry *)
4838 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4839 if (fdh == NULL)
4840 return fdh;
4841
4842 fdh->is_func_descriptor = 1;
4843 fdh->oh = fh;
4844 fh->is_func = 1;
4845 fh->oh = fdh;
4846 }
4847
4848 return ppc_follow_link (fdh);
4849 }
4850
4851 /* Make a fake function descriptor sym for the code sym FH. */
4852
4853 static struct ppc_link_hash_entry *
4854 make_fdh (struct bfd_link_info *info,
4855 struct ppc_link_hash_entry *fh)
4856 {
4857 bfd *abfd;
4858 asymbol *newsym;
4859 struct bfd_link_hash_entry *bh;
4860 struct ppc_link_hash_entry *fdh;
4861
4862 abfd = fh->elf.root.u.undef.abfd;
4863 newsym = bfd_make_empty_symbol (abfd);
4864 newsym->name = fh->elf.root.root.string + 1;
4865 newsym->section = bfd_und_section_ptr;
4866 newsym->value = 0;
4867 newsym->flags = BSF_WEAK;
4868
4869 bh = NULL;
4870 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4871 newsym->flags, newsym->section,
4872 newsym->value, NULL, FALSE, FALSE,
4873 &bh))
4874 return NULL;
4875
4876 fdh = (struct ppc_link_hash_entry *) bh;
4877 fdh->elf.non_elf = 0;
4878 fdh->fake = 1;
4879 fdh->is_func_descriptor = 1;
4880 fdh->oh = fh;
4881 fh->is_func = 1;
4882 fh->oh = fdh;
4883 return fdh;
4884 }
4885
4886 /* Fix function descriptor symbols defined in .opd sections to be
4887 function type. */
4888
4889 static bfd_boolean
4890 ppc64_elf_add_symbol_hook (bfd *ibfd,
4891 struct bfd_link_info *info,
4892 Elf_Internal_Sym *isym,
4893 const char **name,
4894 flagword *flags ATTRIBUTE_UNUSED,
4895 asection **sec,
4896 bfd_vma *value)
4897 {
4898 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4899 && (ibfd->flags & DYNAMIC) == 0
4900 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4901 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4902
4903 if (*sec != NULL
4904 && strcmp ((*sec)->name, ".opd") == 0)
4905 {
4906 asection *code_sec;
4907
4908 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4909 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4910 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4911
4912 /* If the symbol is a function defined in .opd, and the function
4913 code is in a discarded group, let it appear to be undefined. */
4914 if (!bfd_link_relocatable (info)
4915 && (*sec)->reloc_count != 0
4916 && opd_entry_value (*sec, *value, &code_sec, NULL,
4917 FALSE) != (bfd_vma) -1
4918 && discarded_section (code_sec))
4919 {
4920 *sec = bfd_und_section_ptr;
4921 isym->st_shndx = SHN_UNDEF;
4922 }
4923 }
4924 else if (*sec != NULL
4925 && strcmp ((*sec)->name, ".toc") == 0
4926 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4927 {
4928 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4929 if (htab != NULL)
4930 htab->params->object_in_toc = 1;
4931 }
4932
4933 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4934 {
4935 if (abiversion (ibfd) == 0)
4936 set_abiversion (ibfd, 2);
4937 else if (abiversion (ibfd) == 1)
4938 {
4939 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4940 " for ABI version 1\n"), name);
4941 bfd_set_error (bfd_error_bad_value);
4942 return FALSE;
4943 }
4944 }
4945
4946 return TRUE;
4947 }
4948
4949 /* Merge non-visibility st_other attributes: local entry point. */
4950
4951 static void
4952 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4953 const Elf_Internal_Sym *isym,
4954 bfd_boolean definition,
4955 bfd_boolean dynamic)
4956 {
4957 if (definition && !dynamic)
4958 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4959 | ELF_ST_VISIBILITY (h->other));
4960 }
4961
4962 /* This function makes an old ABI object reference to ".bar" cause the
4963 inclusion of a new ABI object archive that defines "bar".
4964 NAME is a symbol defined in an archive. Return a symbol in the hash
4965 table that might be satisfied by the archive symbols. */
4966
4967 static struct elf_link_hash_entry *
4968 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4969 struct bfd_link_info *info,
4970 const char *name)
4971 {
4972 struct elf_link_hash_entry *h;
4973 char *dot_name;
4974 size_t len;
4975
4976 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4977 if (h != NULL
4978 /* Don't return this sym if it is a fake function descriptor
4979 created by add_symbol_adjust. */
4980 && !(h->root.type == bfd_link_hash_undefweak
4981 && ((struct ppc_link_hash_entry *) h)->fake))
4982 return h;
4983
4984 if (name[0] == '.')
4985 return h;
4986
4987 len = strlen (name);
4988 dot_name = bfd_alloc (abfd, len + 2);
4989 if (dot_name == NULL)
4990 return (struct elf_link_hash_entry *) 0 - 1;
4991 dot_name[0] = '.';
4992 memcpy (dot_name + 1, name, len + 1);
4993 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4994 bfd_release (abfd, dot_name);
4995 return h;
4996 }
4997
4998 /* This function satisfies all old ABI object references to ".bar" if a
4999 new ABI object defines "bar". Well, at least, undefined dot symbols
5000 are made weak. This stops later archive searches from including an
5001 object if we already have a function descriptor definition. It also
5002 prevents the linker complaining about undefined symbols.
5003 We also check and correct mismatched symbol visibility here. The
5004 most restrictive visibility of the function descriptor and the
5005 function entry symbol is used. */
5006
5007 static bfd_boolean
5008 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5009 {
5010 struct ppc_link_hash_table *htab;
5011 struct ppc_link_hash_entry *fdh;
5012
5013 if (eh->elf.root.type == bfd_link_hash_indirect)
5014 return TRUE;
5015
5016 if (eh->elf.root.type == bfd_link_hash_warning)
5017 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5018
5019 if (eh->elf.root.root.string[0] != '.')
5020 abort ();
5021
5022 htab = ppc_hash_table (info);
5023 if (htab == NULL)
5024 return FALSE;
5025
5026 fdh = lookup_fdh (eh, htab);
5027 if (fdh == NULL)
5028 {
5029 if (!bfd_link_relocatable (info)
5030 && (eh->elf.root.type == bfd_link_hash_undefined
5031 || eh->elf.root.type == bfd_link_hash_undefweak)
5032 && eh->elf.ref_regular)
5033 {
5034 /* Make an undefweak function descriptor sym, which is enough to
5035 pull in an --as-needed shared lib, but won't cause link
5036 errors. Archives are handled elsewhere. */
5037 fdh = make_fdh (info, eh);
5038 if (fdh == NULL)
5039 return FALSE;
5040 fdh->elf.ref_regular = 1;
5041 }
5042 }
5043 else
5044 {
5045 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5046 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5047 if (entry_vis < descr_vis)
5048 fdh->elf.other += entry_vis - descr_vis;
5049 else if (entry_vis > descr_vis)
5050 eh->elf.other += descr_vis - entry_vis;
5051
5052 if ((fdh->elf.root.type == bfd_link_hash_defined
5053 || fdh->elf.root.type == bfd_link_hash_defweak)
5054 && eh->elf.root.type == bfd_link_hash_undefined)
5055 {
5056 eh->elf.root.type = bfd_link_hash_undefweak;
5057 eh->was_undefined = 1;
5058 htab->twiddled_syms = 1;
5059 }
5060 }
5061
5062 return TRUE;
5063 }
5064
5065 /* Set up opd section info and abiversion for IBFD, and process list
5066 of dot-symbols we made in link_hash_newfunc. */
5067
5068 static bfd_boolean
5069 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5070 {
5071 struct ppc_link_hash_table *htab;
5072 struct ppc_link_hash_entry **p, *eh;
5073 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5074
5075 if (opd != NULL && opd->size != 0)
5076 {
5077 if (abiversion (ibfd) == 0)
5078 set_abiversion (ibfd, 1);
5079 else if (abiversion (ibfd) == 2)
5080 {
5081 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5082 " version %d\n"),
5083 ibfd, abiversion (ibfd));
5084 bfd_set_error (bfd_error_bad_value);
5085 return FALSE;
5086 }
5087
5088 if ((ibfd->flags & DYNAMIC) == 0
5089 && (opd->flags & SEC_RELOC) != 0
5090 && opd->reloc_count != 0
5091 && !bfd_is_abs_section (opd->output_section))
5092 {
5093 /* Garbage collection needs some extra help with .opd sections.
5094 We don't want to necessarily keep everything referenced by
5095 relocs in .opd, as that would keep all functions. Instead,
5096 if we reference an .opd symbol (a function descriptor), we
5097 want to keep the function code symbol's section. This is
5098 easy for global symbols, but for local syms we need to keep
5099 information about the associated function section. */
5100 bfd_size_type amt;
5101 asection **opd_sym_map;
5102
5103 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5104 opd_sym_map = bfd_zalloc (ibfd, amt);
5105 if (opd_sym_map == NULL)
5106 return FALSE;
5107 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5108 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5109 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5110 }
5111 }
5112
5113 if (!is_ppc64_elf (info->output_bfd))
5114 return TRUE;
5115 htab = ppc_hash_table (info);
5116 if (htab == NULL)
5117 return FALSE;
5118
5119 /* For input files without an explicit abiversion in e_flags
5120 we should have flagged any with symbol st_other bits set
5121 as ELFv1 and above flagged those with .opd as ELFv2.
5122 Set the output abiversion if not yet set, and for any input
5123 still ambiguous, take its abiversion from the output.
5124 Differences in ABI are reported later. */
5125 if (abiversion (info->output_bfd) == 0)
5126 set_abiversion (info->output_bfd, abiversion (ibfd));
5127 else if (abiversion (ibfd) == 0)
5128 set_abiversion (ibfd, abiversion (info->output_bfd));
5129
5130 p = &htab->dot_syms;
5131 while ((eh = *p) != NULL)
5132 {
5133 *p = NULL;
5134 if (&eh->elf == htab->elf.hgot)
5135 ;
5136 else if (htab->elf.hgot == NULL
5137 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5138 htab->elf.hgot = &eh->elf;
5139 else if (!add_symbol_adjust (eh, info))
5140 return FALSE;
5141 p = &eh->u.next_dot_sym;
5142 }
5143
5144 /* Clear the list for non-ppc64 input files. */
5145 p = &htab->dot_syms;
5146 while ((eh = *p) != NULL)
5147 {
5148 *p = NULL;
5149 p = &eh->u.next_dot_sym;
5150 }
5151
5152 /* We need to fix the undefs list for any syms we have twiddled to
5153 undefweak. */
5154 if (htab->twiddled_syms)
5155 {
5156 bfd_link_repair_undef_list (&htab->elf.root);
5157 htab->twiddled_syms = 0;
5158 }
5159 return TRUE;
5160 }
5161
5162 /* Undo hash table changes when an --as-needed input file is determined
5163 not to be needed. */
5164
5165 static bfd_boolean
5166 ppc64_elf_notice_as_needed (bfd *ibfd,
5167 struct bfd_link_info *info,
5168 enum notice_asneeded_action act)
5169 {
5170 if (act == notice_not_needed)
5171 {
5172 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5173
5174 if (htab == NULL)
5175 return FALSE;
5176
5177 htab->dot_syms = NULL;
5178 }
5179 return _bfd_elf_notice_as_needed (ibfd, info, act);
5180 }
5181
5182 /* If --just-symbols against a final linked binary, then assume we need
5183 toc adjusting stubs when calling functions defined there. */
5184
5185 static void
5186 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5187 {
5188 if ((sec->flags & SEC_CODE) != 0
5189 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5190 && is_ppc64_elf (sec->owner))
5191 {
5192 if (abiversion (sec->owner) >= 2
5193 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5194 sec->has_toc_reloc = 1;
5195 }
5196 _bfd_elf_link_just_syms (sec, info);
5197 }
5198
5199 static struct plt_entry **
5200 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5201 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5202 {
5203 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5204 struct plt_entry **local_plt;
5205 unsigned char *local_got_tls_masks;
5206
5207 if (local_got_ents == NULL)
5208 {
5209 bfd_size_type size = symtab_hdr->sh_info;
5210
5211 size *= (sizeof (*local_got_ents)
5212 + sizeof (*local_plt)
5213 + sizeof (*local_got_tls_masks));
5214 local_got_ents = bfd_zalloc (abfd, size);
5215 if (local_got_ents == NULL)
5216 return NULL;
5217 elf_local_got_ents (abfd) = local_got_ents;
5218 }
5219
5220 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5221 {
5222 struct got_entry *ent;
5223
5224 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5225 if (ent->addend == r_addend
5226 && ent->owner == abfd
5227 && ent->tls_type == tls_type)
5228 break;
5229 if (ent == NULL)
5230 {
5231 bfd_size_type amt = sizeof (*ent);
5232 ent = bfd_alloc (abfd, amt);
5233 if (ent == NULL)
5234 return FALSE;
5235 ent->next = local_got_ents[r_symndx];
5236 ent->addend = r_addend;
5237 ent->owner = abfd;
5238 ent->tls_type = tls_type;
5239 ent->is_indirect = FALSE;
5240 ent->got.refcount = 0;
5241 local_got_ents[r_symndx] = ent;
5242 }
5243 ent->got.refcount += 1;
5244 }
5245
5246 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5247 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5248 local_got_tls_masks[r_symndx] |= tls_type;
5249
5250 return local_plt + r_symndx;
5251 }
5252
5253 static bfd_boolean
5254 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5255 {
5256 struct plt_entry *ent;
5257
5258 for (ent = *plist; ent != NULL; ent = ent->next)
5259 if (ent->addend == addend)
5260 break;
5261 if (ent == NULL)
5262 {
5263 bfd_size_type amt = sizeof (*ent);
5264 ent = bfd_alloc (abfd, amt);
5265 if (ent == NULL)
5266 return FALSE;
5267 ent->next = *plist;
5268 ent->addend = addend;
5269 ent->plt.refcount = 0;
5270 *plist = ent;
5271 }
5272 ent->plt.refcount += 1;
5273 return TRUE;
5274 }
5275
5276 static bfd_boolean
5277 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5278 {
5279 return (r_type == R_PPC64_REL24
5280 || r_type == R_PPC64_REL14
5281 || r_type == R_PPC64_REL14_BRTAKEN
5282 || r_type == R_PPC64_REL14_BRNTAKEN
5283 || r_type == R_PPC64_ADDR24
5284 || r_type == R_PPC64_ADDR14
5285 || r_type == R_PPC64_ADDR14_BRTAKEN
5286 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5287 }
5288
5289 /* Look through the relocs for a section during the first phase, and
5290 calculate needed space in the global offset table, procedure
5291 linkage table, and dynamic reloc sections. */
5292
5293 static bfd_boolean
5294 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5295 asection *sec, const Elf_Internal_Rela *relocs)
5296 {
5297 struct ppc_link_hash_table *htab;
5298 Elf_Internal_Shdr *symtab_hdr;
5299 struct elf_link_hash_entry **sym_hashes;
5300 const Elf_Internal_Rela *rel;
5301 const Elf_Internal_Rela *rel_end;
5302 asection *sreloc;
5303 asection **opd_sym_map;
5304 struct elf_link_hash_entry *tga, *dottga;
5305
5306 if (bfd_link_relocatable (info))
5307 return TRUE;
5308
5309 /* Don't do anything special with non-loaded, non-alloced sections.
5310 In particular, any relocs in such sections should not affect GOT
5311 and PLT reference counting (ie. we don't allow them to create GOT
5312 or PLT entries), there's no possibility or desire to optimize TLS
5313 relocs, and there's not much point in propagating relocs to shared
5314 libs that the dynamic linker won't relocate. */
5315 if ((sec->flags & SEC_ALLOC) == 0)
5316 return TRUE;
5317
5318 BFD_ASSERT (is_ppc64_elf (abfd));
5319
5320 htab = ppc_hash_table (info);
5321 if (htab == NULL)
5322 return FALSE;
5323
5324 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5325 FALSE, FALSE, TRUE);
5326 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5327 FALSE, FALSE, TRUE);
5328 symtab_hdr = &elf_symtab_hdr (abfd);
5329 sym_hashes = elf_sym_hashes (abfd);
5330 sreloc = NULL;
5331 opd_sym_map = NULL;
5332 if (ppc64_elf_section_data (sec) != NULL
5333 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5334 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5335
5336 rel_end = relocs + sec->reloc_count;
5337 for (rel = relocs; rel < rel_end; rel++)
5338 {
5339 unsigned long r_symndx;
5340 struct elf_link_hash_entry *h;
5341 enum elf_ppc64_reloc_type r_type;
5342 int tls_type;
5343 struct _ppc64_elf_section_data *ppc64_sec;
5344 struct plt_entry **ifunc, **plt_list;
5345
5346 r_symndx = ELF64_R_SYM (rel->r_info);
5347 if (r_symndx < symtab_hdr->sh_info)
5348 h = NULL;
5349 else
5350 {
5351 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5352 h = elf_follow_link (h);
5353
5354 /* PR15323, ref flags aren't set for references in the same
5355 object. */
5356 h->root.non_ir_ref = 1;
5357
5358 if (h == htab->elf.hgot)
5359 sec->has_toc_reloc = 1;
5360 }
5361
5362 tls_type = 0;
5363 ifunc = NULL;
5364 if (h != NULL)
5365 {
5366 if (h->type == STT_GNU_IFUNC)
5367 {
5368 h->needs_plt = 1;
5369 ifunc = &h->plt.plist;
5370 }
5371 }
5372 else
5373 {
5374 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5375 abfd, r_symndx);
5376 if (isym == NULL)
5377 return FALSE;
5378
5379 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5380 {
5381 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5382 rel->r_addend, PLT_IFUNC);
5383 if (ifunc == NULL)
5384 return FALSE;
5385 }
5386 }
5387
5388 r_type = ELF64_R_TYPE (rel->r_info);
5389 switch (r_type)
5390 {
5391 case R_PPC64_TLSGD:
5392 case R_PPC64_TLSLD:
5393 /* These special tls relocs tie a call to __tls_get_addr with
5394 its parameter symbol. */
5395 break;
5396
5397 case R_PPC64_GOT_TLSLD16:
5398 case R_PPC64_GOT_TLSLD16_LO:
5399 case R_PPC64_GOT_TLSLD16_HI:
5400 case R_PPC64_GOT_TLSLD16_HA:
5401 tls_type = TLS_TLS | TLS_LD;
5402 goto dogottls;
5403
5404 case R_PPC64_GOT_TLSGD16:
5405 case R_PPC64_GOT_TLSGD16_LO:
5406 case R_PPC64_GOT_TLSGD16_HI:
5407 case R_PPC64_GOT_TLSGD16_HA:
5408 tls_type = TLS_TLS | TLS_GD;
5409 goto dogottls;
5410
5411 case R_PPC64_GOT_TPREL16_DS:
5412 case R_PPC64_GOT_TPREL16_LO_DS:
5413 case R_PPC64_GOT_TPREL16_HI:
5414 case R_PPC64_GOT_TPREL16_HA:
5415 if (bfd_link_pic (info))
5416 info->flags |= DF_STATIC_TLS;
5417 tls_type = TLS_TLS | TLS_TPREL;
5418 goto dogottls;
5419
5420 case R_PPC64_GOT_DTPREL16_DS:
5421 case R_PPC64_GOT_DTPREL16_LO_DS:
5422 case R_PPC64_GOT_DTPREL16_HI:
5423 case R_PPC64_GOT_DTPREL16_HA:
5424 tls_type = TLS_TLS | TLS_DTPREL;
5425 dogottls:
5426 sec->has_tls_reloc = 1;
5427 /* Fall thru */
5428
5429 case R_PPC64_GOT16:
5430 case R_PPC64_GOT16_DS:
5431 case R_PPC64_GOT16_HA:
5432 case R_PPC64_GOT16_HI:
5433 case R_PPC64_GOT16_LO:
5434 case R_PPC64_GOT16_LO_DS:
5435 /* This symbol requires a global offset table entry. */
5436 sec->has_toc_reloc = 1;
5437 if (r_type == R_PPC64_GOT_TLSLD16
5438 || r_type == R_PPC64_GOT_TLSGD16
5439 || r_type == R_PPC64_GOT_TPREL16_DS
5440 || r_type == R_PPC64_GOT_DTPREL16_DS
5441 || r_type == R_PPC64_GOT16
5442 || r_type == R_PPC64_GOT16_DS)
5443 {
5444 htab->do_multi_toc = 1;
5445 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5446 }
5447
5448 if (ppc64_elf_tdata (abfd)->got == NULL
5449 && !create_got_section (abfd, info))
5450 return FALSE;
5451
5452 if (h != NULL)
5453 {
5454 struct ppc_link_hash_entry *eh;
5455 struct got_entry *ent;
5456
5457 eh = (struct ppc_link_hash_entry *) h;
5458 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5459 if (ent->addend == rel->r_addend
5460 && ent->owner == abfd
5461 && ent->tls_type == tls_type)
5462 break;
5463 if (ent == NULL)
5464 {
5465 bfd_size_type amt = sizeof (*ent);
5466 ent = bfd_alloc (abfd, amt);
5467 if (ent == NULL)
5468 return FALSE;
5469 ent->next = eh->elf.got.glist;
5470 ent->addend = rel->r_addend;
5471 ent->owner = abfd;
5472 ent->tls_type = tls_type;
5473 ent->is_indirect = FALSE;
5474 ent->got.refcount = 0;
5475 eh->elf.got.glist = ent;
5476 }
5477 ent->got.refcount += 1;
5478 eh->tls_mask |= tls_type;
5479 }
5480 else
5481 /* This is a global offset table entry for a local symbol. */
5482 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5483 rel->r_addend, tls_type))
5484 return FALSE;
5485
5486 /* We may also need a plt entry if the symbol turns out to be
5487 an ifunc. */
5488 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5489 {
5490 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5491 return FALSE;
5492 }
5493 break;
5494
5495 case R_PPC64_PLT16_HA:
5496 case R_PPC64_PLT16_HI:
5497 case R_PPC64_PLT16_LO:
5498 case R_PPC64_PLT32:
5499 case R_PPC64_PLT64:
5500 /* This symbol requires a procedure linkage table entry. */
5501 plt_list = ifunc;
5502 if (h != NULL)
5503 {
5504 h->needs_plt = 1;
5505 if (h->root.root.string[0] == '.'
5506 && h->root.root.string[1] != '\0')
5507 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5508 plt_list = &h->plt.plist;
5509 }
5510 if (plt_list == NULL)
5511 {
5512 /* It does not make sense to have a procedure linkage
5513 table entry for a non-ifunc local symbol. */
5514 info->callbacks->einfo
5515 (_("%P: %H: %s reloc against local symbol\n"),
5516 abfd, sec, rel->r_offset,
5517 ppc64_elf_howto_table[r_type]->name);
5518 bfd_set_error (bfd_error_bad_value);
5519 return FALSE;
5520 }
5521 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5522 return FALSE;
5523 break;
5524
5525 /* The following relocations don't need to propagate the
5526 relocation if linking a shared object since they are
5527 section relative. */
5528 case R_PPC64_SECTOFF:
5529 case R_PPC64_SECTOFF_LO:
5530 case R_PPC64_SECTOFF_HI:
5531 case R_PPC64_SECTOFF_HA:
5532 case R_PPC64_SECTOFF_DS:
5533 case R_PPC64_SECTOFF_LO_DS:
5534 case R_PPC64_DTPREL16:
5535 case R_PPC64_DTPREL16_LO:
5536 case R_PPC64_DTPREL16_HI:
5537 case R_PPC64_DTPREL16_HA:
5538 case R_PPC64_DTPREL16_DS:
5539 case R_PPC64_DTPREL16_LO_DS:
5540 case R_PPC64_DTPREL16_HIGH:
5541 case R_PPC64_DTPREL16_HIGHA:
5542 case R_PPC64_DTPREL16_HIGHER:
5543 case R_PPC64_DTPREL16_HIGHERA:
5544 case R_PPC64_DTPREL16_HIGHEST:
5545 case R_PPC64_DTPREL16_HIGHESTA:
5546 break;
5547
5548 /* Nor do these. */
5549 case R_PPC64_REL16:
5550 case R_PPC64_REL16_LO:
5551 case R_PPC64_REL16_HI:
5552 case R_PPC64_REL16_HA:
5553 case R_PPC64_REL16DX_HA:
5554 break;
5555
5556 /* Not supported as a dynamic relocation. */
5557 case R_PPC64_ADDR64_LOCAL:
5558 if (bfd_link_pic (info))
5559 {
5560 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5561 ppc_howto_init ();
5562 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5563 "in shared libraries and PIEs.\n"),
5564 abfd, sec, rel->r_offset,
5565 ppc64_elf_howto_table[r_type]->name);
5566 bfd_set_error (bfd_error_bad_value);
5567 return FALSE;
5568 }
5569 break;
5570
5571 case R_PPC64_TOC16:
5572 case R_PPC64_TOC16_DS:
5573 htab->do_multi_toc = 1;
5574 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5575 case R_PPC64_TOC16_LO:
5576 case R_PPC64_TOC16_HI:
5577 case R_PPC64_TOC16_HA:
5578 case R_PPC64_TOC16_LO_DS:
5579 sec->has_toc_reloc = 1;
5580 break;
5581
5582 /* Marker reloc. */
5583 case R_PPC64_ENTRY:
5584 break;
5585
5586 /* This relocation describes the C++ object vtable hierarchy.
5587 Reconstruct it for later use during GC. */
5588 case R_PPC64_GNU_VTINHERIT:
5589 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5590 return FALSE;
5591 break;
5592
5593 /* This relocation describes which C++ vtable entries are actually
5594 used. Record for later use during GC. */
5595 case R_PPC64_GNU_VTENTRY:
5596 BFD_ASSERT (h != NULL);
5597 if (h != NULL
5598 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5599 return FALSE;
5600 break;
5601
5602 case R_PPC64_REL14:
5603 case R_PPC64_REL14_BRTAKEN:
5604 case R_PPC64_REL14_BRNTAKEN:
5605 {
5606 asection *dest = NULL;
5607
5608 /* Heuristic: If jumping outside our section, chances are
5609 we are going to need a stub. */
5610 if (h != NULL)
5611 {
5612 /* If the sym is weak it may be overridden later, so
5613 don't assume we know where a weak sym lives. */
5614 if (h->root.type == bfd_link_hash_defined)
5615 dest = h->root.u.def.section;
5616 }
5617 else
5618 {
5619 Elf_Internal_Sym *isym;
5620
5621 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5622 abfd, r_symndx);
5623 if (isym == NULL)
5624 return FALSE;
5625
5626 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5627 }
5628
5629 if (dest != sec)
5630 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5631 }
5632 /* Fall through. */
5633
5634 case R_PPC64_REL24:
5635 plt_list = ifunc;
5636 if (h != NULL)
5637 {
5638 h->needs_plt = 1;
5639 if (h->root.root.string[0] == '.'
5640 && h->root.root.string[1] != '\0')
5641 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5642
5643 if (h == tga || h == dottga)
5644 {
5645 sec->has_tls_reloc = 1;
5646 if (rel != relocs
5647 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5648 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5649 /* We have a new-style __tls_get_addr call with
5650 a marker reloc. */
5651 ;
5652 else
5653 /* Mark this section as having an old-style call. */
5654 sec->has_tls_get_addr_call = 1;
5655 }
5656 plt_list = &h->plt.plist;
5657 }
5658
5659 /* We may need a .plt entry if the function this reloc
5660 refers to is in a shared lib. */
5661 if (plt_list
5662 && !update_plt_info (abfd, plt_list, rel->r_addend))
5663 return FALSE;
5664 break;
5665
5666 case R_PPC64_ADDR14:
5667 case R_PPC64_ADDR14_BRNTAKEN:
5668 case R_PPC64_ADDR14_BRTAKEN:
5669 case R_PPC64_ADDR24:
5670 goto dodyn;
5671
5672 case R_PPC64_TPREL64:
5673 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5674 if (bfd_link_pic (info))
5675 info->flags |= DF_STATIC_TLS;
5676 goto dotlstoc;
5677
5678 case R_PPC64_DTPMOD64:
5679 if (rel + 1 < rel_end
5680 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5681 && rel[1].r_offset == rel->r_offset + 8)
5682 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5683 else
5684 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5685 goto dotlstoc;
5686
5687 case R_PPC64_DTPREL64:
5688 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5689 if (rel != relocs
5690 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5691 && rel[-1].r_offset == rel->r_offset - 8)
5692 /* This is the second reloc of a dtpmod, dtprel pair.
5693 Don't mark with TLS_DTPREL. */
5694 goto dodyn;
5695
5696 dotlstoc:
5697 sec->has_tls_reloc = 1;
5698 if (h != NULL)
5699 {
5700 struct ppc_link_hash_entry *eh;
5701 eh = (struct ppc_link_hash_entry *) h;
5702 eh->tls_mask |= tls_type;
5703 }
5704 else
5705 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5706 rel->r_addend, tls_type))
5707 return FALSE;
5708
5709 ppc64_sec = ppc64_elf_section_data (sec);
5710 if (ppc64_sec->sec_type != sec_toc)
5711 {
5712 bfd_size_type amt;
5713
5714 /* One extra to simplify get_tls_mask. */
5715 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5716 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5717 if (ppc64_sec->u.toc.symndx == NULL)
5718 return FALSE;
5719 amt = sec->size * sizeof (bfd_vma) / 8;
5720 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5721 if (ppc64_sec->u.toc.add == NULL)
5722 return FALSE;
5723 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5724 ppc64_sec->sec_type = sec_toc;
5725 }
5726 BFD_ASSERT (rel->r_offset % 8 == 0);
5727 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5728 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5729
5730 /* Mark the second slot of a GD or LD entry.
5731 -1 to indicate GD and -2 to indicate LD. */
5732 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5733 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5734 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5735 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5736 goto dodyn;
5737
5738 case R_PPC64_TPREL16:
5739 case R_PPC64_TPREL16_LO:
5740 case R_PPC64_TPREL16_HI:
5741 case R_PPC64_TPREL16_HA:
5742 case R_PPC64_TPREL16_DS:
5743 case R_PPC64_TPREL16_LO_DS:
5744 case R_PPC64_TPREL16_HIGH:
5745 case R_PPC64_TPREL16_HIGHA:
5746 case R_PPC64_TPREL16_HIGHER:
5747 case R_PPC64_TPREL16_HIGHERA:
5748 case R_PPC64_TPREL16_HIGHEST:
5749 case R_PPC64_TPREL16_HIGHESTA:
5750 if (bfd_link_pic (info))
5751 {
5752 info->flags |= DF_STATIC_TLS;
5753 goto dodyn;
5754 }
5755 break;
5756
5757 case R_PPC64_ADDR64:
5758 if (opd_sym_map != NULL
5759 && rel + 1 < rel_end
5760 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5761 {
5762 if (h != NULL)
5763 {
5764 if (h->root.root.string[0] == '.'
5765 && h->root.root.string[1] != 0
5766 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5767 ;
5768 else
5769 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5770 }
5771 else
5772 {
5773 asection *s;
5774 Elf_Internal_Sym *isym;
5775
5776 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5777 abfd, r_symndx);
5778 if (isym == NULL)
5779 return FALSE;
5780
5781 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5782 if (s != NULL && s != sec)
5783 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5784 }
5785 }
5786 /* Fall through. */
5787
5788 case R_PPC64_ADDR16:
5789 case R_PPC64_ADDR16_DS:
5790 case R_PPC64_ADDR16_HA:
5791 case R_PPC64_ADDR16_HI:
5792 case R_PPC64_ADDR16_HIGH:
5793 case R_PPC64_ADDR16_HIGHA:
5794 case R_PPC64_ADDR16_HIGHER:
5795 case R_PPC64_ADDR16_HIGHERA:
5796 case R_PPC64_ADDR16_HIGHEST:
5797 case R_PPC64_ADDR16_HIGHESTA:
5798 case R_PPC64_ADDR16_LO:
5799 case R_PPC64_ADDR16_LO_DS:
5800 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5801 && rel->r_addend == 0)
5802 {
5803 /* We may need a .plt entry if this reloc refers to a
5804 function in a shared lib. */
5805 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5806 return FALSE;
5807 h->pointer_equality_needed = 1;
5808 }
5809 /* Fall through. */
5810
5811 case R_PPC64_REL30:
5812 case R_PPC64_REL32:
5813 case R_PPC64_REL64:
5814 case R_PPC64_ADDR32:
5815 case R_PPC64_UADDR16:
5816 case R_PPC64_UADDR32:
5817 case R_PPC64_UADDR64:
5818 case R_PPC64_TOC:
5819 if (h != NULL && !bfd_link_pic (info))
5820 /* We may need a copy reloc. */
5821 h->non_got_ref = 1;
5822
5823 /* Don't propagate .opd relocs. */
5824 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5825 break;
5826
5827 /* If we are creating a shared library, and this is a reloc
5828 against a global symbol, or a non PC relative reloc
5829 against a local symbol, then we need to copy the reloc
5830 into the shared library. However, if we are linking with
5831 -Bsymbolic, we do not need to copy a reloc against a
5832 global symbol which is defined in an object we are
5833 including in the link (i.e., DEF_REGULAR is set). At
5834 this point we have not seen all the input files, so it is
5835 possible that DEF_REGULAR is not set now but will be set
5836 later (it is never cleared). In case of a weak definition,
5837 DEF_REGULAR may be cleared later by a strong definition in
5838 a shared library. We account for that possibility below by
5839 storing information in the dyn_relocs field of the hash
5840 table entry. A similar situation occurs when creating
5841 shared libraries and symbol visibility changes render the
5842 symbol local.
5843
5844 If on the other hand, we are creating an executable, we
5845 may need to keep relocations for symbols satisfied by a
5846 dynamic library if we manage to avoid copy relocs for the
5847 symbol. */
5848 dodyn:
5849 if ((bfd_link_pic (info)
5850 && (must_be_dyn_reloc (info, r_type)
5851 || (h != NULL
5852 && (!SYMBOLIC_BIND (info, h)
5853 || h->root.type == bfd_link_hash_defweak
5854 || !h->def_regular))))
5855 || (ELIMINATE_COPY_RELOCS
5856 && !bfd_link_pic (info)
5857 && h != NULL
5858 && (h->root.type == bfd_link_hash_defweak
5859 || !h->def_regular))
5860 || (!bfd_link_pic (info)
5861 && ifunc != NULL))
5862 {
5863 /* We must copy these reloc types into the output file.
5864 Create a reloc section in dynobj and make room for
5865 this reloc. */
5866 if (sreloc == NULL)
5867 {
5868 sreloc = _bfd_elf_make_dynamic_reloc_section
5869 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5870
5871 if (sreloc == NULL)
5872 return FALSE;
5873 }
5874
5875 /* If this is a global symbol, we count the number of
5876 relocations we need for this symbol. */
5877 if (h != NULL)
5878 {
5879 struct elf_dyn_relocs *p;
5880 struct elf_dyn_relocs **head;
5881
5882 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5883 p = *head;
5884 if (p == NULL || p->sec != sec)
5885 {
5886 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5887 if (p == NULL)
5888 return FALSE;
5889 p->next = *head;
5890 *head = p;
5891 p->sec = sec;
5892 p->count = 0;
5893 p->pc_count = 0;
5894 }
5895 p->count += 1;
5896 if (!must_be_dyn_reloc (info, r_type))
5897 p->pc_count += 1;
5898 }
5899 else
5900 {
5901 /* Track dynamic relocs needed for local syms too.
5902 We really need local syms available to do this
5903 easily. Oh well. */
5904 struct ppc_dyn_relocs *p;
5905 struct ppc_dyn_relocs **head;
5906 bfd_boolean is_ifunc;
5907 asection *s;
5908 void *vpp;
5909 Elf_Internal_Sym *isym;
5910
5911 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5912 abfd, r_symndx);
5913 if (isym == NULL)
5914 return FALSE;
5915
5916 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5917 if (s == NULL)
5918 s = sec;
5919
5920 vpp = &elf_section_data (s)->local_dynrel;
5921 head = (struct ppc_dyn_relocs **) vpp;
5922 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5923 p = *head;
5924 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5925 p = p->next;
5926 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5927 {
5928 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5929 if (p == NULL)
5930 return FALSE;
5931 p->next = *head;
5932 *head = p;
5933 p->sec = sec;
5934 p->ifunc = is_ifunc;
5935 p->count = 0;
5936 }
5937 p->count += 1;
5938 }
5939 }
5940 break;
5941
5942 default:
5943 break;
5944 }
5945 }
5946
5947 return TRUE;
5948 }
5949
5950 /* Merge backend specific data from an object file to the output
5951 object file when linking. */
5952
5953 static bfd_boolean
5954 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5955 {
5956 unsigned long iflags, oflags;
5957
5958 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5959 return TRUE;
5960
5961 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5962 return TRUE;
5963
5964 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5965 return FALSE;
5966
5967 iflags = elf_elfheader (ibfd)->e_flags;
5968 oflags = elf_elfheader (obfd)->e_flags;
5969
5970 if (iflags & ~EF_PPC64_ABI)
5971 {
5972 (*_bfd_error_handler)
5973 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5974 bfd_set_error (bfd_error_bad_value);
5975 return FALSE;
5976 }
5977 else if (iflags != oflags && iflags != 0)
5978 {
5979 (*_bfd_error_handler)
5980 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5981 ibfd, iflags, oflags);
5982 bfd_set_error (bfd_error_bad_value);
5983 return FALSE;
5984 }
5985
5986 /* Merge Tag_compatibility attributes and any common GNU ones. */
5987 _bfd_elf_merge_object_attributes (ibfd, obfd);
5988
5989 return TRUE;
5990 }
5991
5992 static bfd_boolean
5993 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5994 {
5995 /* Print normal ELF private data. */
5996 _bfd_elf_print_private_bfd_data (abfd, ptr);
5997
5998 if (elf_elfheader (abfd)->e_flags != 0)
5999 {
6000 FILE *file = ptr;
6001
6002 /* xgettext:c-format */
6003 fprintf (file, _("private flags = 0x%lx:"),
6004 elf_elfheader (abfd)->e_flags);
6005
6006 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6007 fprintf (file, _(" [abiv%ld]"),
6008 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6009 fputc ('\n', file);
6010 }
6011
6012 return TRUE;
6013 }
6014
6015 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6016 of the code entry point, and its section, which must be in the same
6017 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6018
6019 static bfd_vma
6020 opd_entry_value (asection *opd_sec,
6021 bfd_vma offset,
6022 asection **code_sec,
6023 bfd_vma *code_off,
6024 bfd_boolean in_code_sec)
6025 {
6026 bfd *opd_bfd = opd_sec->owner;
6027 Elf_Internal_Rela *relocs;
6028 Elf_Internal_Rela *lo, *hi, *look;
6029 bfd_vma val;
6030
6031 /* No relocs implies we are linking a --just-symbols object, or looking
6032 at a final linked executable with addr2line or somesuch. */
6033 if (opd_sec->reloc_count == 0)
6034 {
6035 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6036
6037 if (contents == NULL)
6038 {
6039 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6040 return (bfd_vma) -1;
6041 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6042 }
6043
6044 /* PR 17512: file: 64b9dfbb. */
6045 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6046 return (bfd_vma) -1;
6047
6048 val = bfd_get_64 (opd_bfd, contents + offset);
6049 if (code_sec != NULL)
6050 {
6051 asection *sec, *likely = NULL;
6052
6053 if (in_code_sec)
6054 {
6055 sec = *code_sec;
6056 if (sec->vma <= val
6057 && val < sec->vma + sec->size)
6058 likely = sec;
6059 else
6060 val = -1;
6061 }
6062 else
6063 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6064 if (sec->vma <= val
6065 && (sec->flags & SEC_LOAD) != 0
6066 && (sec->flags & SEC_ALLOC) != 0)
6067 likely = sec;
6068 if (likely != NULL)
6069 {
6070 *code_sec = likely;
6071 if (code_off != NULL)
6072 *code_off = val - likely->vma;
6073 }
6074 }
6075 return val;
6076 }
6077
6078 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6079
6080 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6081 if (relocs == NULL)
6082 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6083 /* PR 17512: file: df8e1fd6. */
6084 if (relocs == NULL)
6085 return (bfd_vma) -1;
6086
6087 /* Go find the opd reloc at the sym address. */
6088 lo = relocs;
6089 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6090 val = (bfd_vma) -1;
6091 while (lo < hi)
6092 {
6093 look = lo + (hi - lo) / 2;
6094 if (look->r_offset < offset)
6095 lo = look + 1;
6096 else if (look->r_offset > offset)
6097 hi = look;
6098 else
6099 {
6100 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6101
6102 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6103 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6104 {
6105 unsigned long symndx = ELF64_R_SYM (look->r_info);
6106 asection *sec = NULL;
6107
6108 if (symndx >= symtab_hdr->sh_info
6109 && elf_sym_hashes (opd_bfd) != NULL)
6110 {
6111 struct elf_link_hash_entry **sym_hashes;
6112 struct elf_link_hash_entry *rh;
6113
6114 sym_hashes = elf_sym_hashes (opd_bfd);
6115 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6116 if (rh != NULL)
6117 {
6118 rh = elf_follow_link (rh);
6119 if (rh->root.type != bfd_link_hash_defined
6120 && rh->root.type != bfd_link_hash_defweak)
6121 break;
6122 if (rh->root.u.def.section->owner == opd_bfd)
6123 {
6124 val = rh->root.u.def.value;
6125 sec = rh->root.u.def.section;
6126 }
6127 }
6128 }
6129
6130 if (sec == NULL)
6131 {
6132 Elf_Internal_Sym *sym;
6133
6134 if (symndx < symtab_hdr->sh_info)
6135 {
6136 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6137 if (sym == NULL)
6138 {
6139 size_t symcnt = symtab_hdr->sh_info;
6140 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6141 symcnt, 0,
6142 NULL, NULL, NULL);
6143 if (sym == NULL)
6144 break;
6145 symtab_hdr->contents = (bfd_byte *) sym;
6146 }
6147 sym += symndx;
6148 }
6149 else
6150 {
6151 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6152 1, symndx,
6153 NULL, NULL, NULL);
6154 if (sym == NULL)
6155 break;
6156 }
6157 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6158 if (sec == NULL)
6159 break;
6160 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6161 val = sym->st_value;
6162 }
6163
6164 val += look->r_addend;
6165 if (code_off != NULL)
6166 *code_off = val;
6167 if (code_sec != NULL)
6168 {
6169 if (in_code_sec && *code_sec != sec)
6170 return -1;
6171 else
6172 *code_sec = sec;
6173 }
6174 if (sec->output_section != NULL)
6175 val += sec->output_section->vma + sec->output_offset;
6176 }
6177 break;
6178 }
6179 }
6180
6181 return val;
6182 }
6183
6184 /* If the ELF symbol SYM might be a function in SEC, return the
6185 function size and set *CODE_OFF to the function's entry point,
6186 otherwise return zero. */
6187
6188 static bfd_size_type
6189 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6190 bfd_vma *code_off)
6191 {
6192 bfd_size_type size;
6193
6194 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6195 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6196 return 0;
6197
6198 size = 0;
6199 if (!(sym->flags & BSF_SYNTHETIC))
6200 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6201
6202 if (strcmp (sym->section->name, ".opd") == 0)
6203 {
6204 struct _opd_sec_data *opd = get_opd_info (sym->section);
6205 bfd_vma symval = sym->value;
6206
6207 if (opd != NULL
6208 && opd->adjust != NULL
6209 && elf_section_data (sym->section)->relocs != NULL)
6210 {
6211 /* opd_entry_value will use cached relocs that have been
6212 adjusted, but with raw symbols. That means both local
6213 and global symbols need adjusting. */
6214 long adjust = opd->adjust[OPD_NDX (symval)];
6215 if (adjust == -1)
6216 return 0;
6217 symval += adjust;
6218 }
6219
6220 if (opd_entry_value (sym->section, symval,
6221 &sec, code_off, TRUE) == (bfd_vma) -1)
6222 return 0;
6223 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6224 symbol. This size has nothing to do with the code size of the
6225 function, which is what we're supposed to return, but the
6226 code size isn't available without looking up the dot-sym.
6227 However, doing that would be a waste of time particularly
6228 since elf_find_function will look at the dot-sym anyway.
6229 Now, elf_find_function will keep the largest size of any
6230 function sym found at the code address of interest, so return
6231 1 here to avoid it incorrectly caching a larger function size
6232 for a small function. This does mean we return the wrong
6233 size for a new-ABI function of size 24, but all that does is
6234 disable caching for such functions. */
6235 if (size == 24)
6236 size = 1;
6237 }
6238 else
6239 {
6240 if (sym->section != sec)
6241 return 0;
6242 *code_off = sym->value;
6243 }
6244 if (size == 0)
6245 size = 1;
6246 return size;
6247 }
6248
6249 /* Return true if symbol is defined in a regular object file. */
6250
6251 static bfd_boolean
6252 is_static_defined (struct elf_link_hash_entry *h)
6253 {
6254 return ((h->root.type == bfd_link_hash_defined
6255 || h->root.type == bfd_link_hash_defweak)
6256 && h->root.u.def.section != NULL
6257 && h->root.u.def.section->output_section != NULL);
6258 }
6259
6260 /* If FDH is a function descriptor symbol, return the associated code
6261 entry symbol if it is defined. Return NULL otherwise. */
6262
6263 static struct ppc_link_hash_entry *
6264 defined_code_entry (struct ppc_link_hash_entry *fdh)
6265 {
6266 if (fdh->is_func_descriptor)
6267 {
6268 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6269 if (fh->elf.root.type == bfd_link_hash_defined
6270 || fh->elf.root.type == bfd_link_hash_defweak)
6271 return fh;
6272 }
6273 return NULL;
6274 }
6275
6276 /* If FH is a function code entry symbol, return the associated
6277 function descriptor symbol if it is defined. Return NULL otherwise. */
6278
6279 static struct ppc_link_hash_entry *
6280 defined_func_desc (struct ppc_link_hash_entry *fh)
6281 {
6282 if (fh->oh != NULL
6283 && fh->oh->is_func_descriptor)
6284 {
6285 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6286 if (fdh->elf.root.type == bfd_link_hash_defined
6287 || fdh->elf.root.type == bfd_link_hash_defweak)
6288 return fdh;
6289 }
6290 return NULL;
6291 }
6292
6293 /* Mark all our entry sym sections, both opd and code section. */
6294
6295 static void
6296 ppc64_elf_gc_keep (struct bfd_link_info *info)
6297 {
6298 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6299 struct bfd_sym_chain *sym;
6300
6301 if (htab == NULL)
6302 return;
6303
6304 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6305 {
6306 struct ppc_link_hash_entry *eh, *fh;
6307 asection *sec;
6308
6309 eh = (struct ppc_link_hash_entry *)
6310 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6311 if (eh == NULL)
6312 continue;
6313 if (eh->elf.root.type != bfd_link_hash_defined
6314 && eh->elf.root.type != bfd_link_hash_defweak)
6315 continue;
6316
6317 fh = defined_code_entry (eh);
6318 if (fh != NULL)
6319 {
6320 sec = fh->elf.root.u.def.section;
6321 sec->flags |= SEC_KEEP;
6322 }
6323 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6324 && opd_entry_value (eh->elf.root.u.def.section,
6325 eh->elf.root.u.def.value,
6326 &sec, NULL, FALSE) != (bfd_vma) -1)
6327 sec->flags |= SEC_KEEP;
6328
6329 sec = eh->elf.root.u.def.section;
6330 sec->flags |= SEC_KEEP;
6331 }
6332 }
6333
6334 /* Mark sections containing dynamically referenced symbols. When
6335 building shared libraries, we must assume that any visible symbol is
6336 referenced. */
6337
6338 static bfd_boolean
6339 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6340 {
6341 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6342 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6343 struct ppc_link_hash_entry *fdh;
6344 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6345
6346 /* Dynamic linking info is on the func descriptor sym. */
6347 fdh = defined_func_desc (eh);
6348 if (fdh != NULL)
6349 eh = fdh;
6350
6351 if ((eh->elf.root.type == bfd_link_hash_defined
6352 || eh->elf.root.type == bfd_link_hash_defweak)
6353 && (eh->elf.ref_dynamic
6354 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6355 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6356 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6357 && (!bfd_link_executable (info)
6358 || info->export_dynamic
6359 || (eh->elf.dynamic
6360 && d != NULL
6361 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6362 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6363 || !bfd_hide_sym_by_version (info->version_info,
6364 eh->elf.root.root.string)))))
6365 {
6366 asection *code_sec;
6367 struct ppc_link_hash_entry *fh;
6368
6369 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6370
6371 /* Function descriptor syms cause the associated
6372 function code sym section to be marked. */
6373 fh = defined_code_entry (eh);
6374 if (fh != NULL)
6375 {
6376 code_sec = fh->elf.root.u.def.section;
6377 code_sec->flags |= SEC_KEEP;
6378 }
6379 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6380 && opd_entry_value (eh->elf.root.u.def.section,
6381 eh->elf.root.u.def.value,
6382 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6383 code_sec->flags |= SEC_KEEP;
6384 }
6385
6386 return TRUE;
6387 }
6388
6389 /* Return the section that should be marked against GC for a given
6390 relocation. */
6391
6392 static asection *
6393 ppc64_elf_gc_mark_hook (asection *sec,
6394 struct bfd_link_info *info,
6395 Elf_Internal_Rela *rel,
6396 struct elf_link_hash_entry *h,
6397 Elf_Internal_Sym *sym)
6398 {
6399 asection *rsec;
6400
6401 /* Syms return NULL if we're marking .opd, so we avoid marking all
6402 function sections, as all functions are referenced in .opd. */
6403 rsec = NULL;
6404 if (get_opd_info (sec) != NULL)
6405 return rsec;
6406
6407 if (h != NULL)
6408 {
6409 enum elf_ppc64_reloc_type r_type;
6410 struct ppc_link_hash_entry *eh, *fh, *fdh;
6411
6412 r_type = ELF64_R_TYPE (rel->r_info);
6413 switch (r_type)
6414 {
6415 case R_PPC64_GNU_VTINHERIT:
6416 case R_PPC64_GNU_VTENTRY:
6417 break;
6418
6419 default:
6420 switch (h->root.type)
6421 {
6422 case bfd_link_hash_defined:
6423 case bfd_link_hash_defweak:
6424 eh = (struct ppc_link_hash_entry *) h;
6425 fdh = defined_func_desc (eh);
6426 if (fdh != NULL)
6427 eh = fdh;
6428
6429 /* Function descriptor syms cause the associated
6430 function code sym section to be marked. */
6431 fh = defined_code_entry (eh);
6432 if (fh != NULL)
6433 {
6434 /* They also mark their opd section. */
6435 eh->elf.root.u.def.section->gc_mark = 1;
6436
6437 rsec = fh->elf.root.u.def.section;
6438 }
6439 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6440 && opd_entry_value (eh->elf.root.u.def.section,
6441 eh->elf.root.u.def.value,
6442 &rsec, NULL, FALSE) != (bfd_vma) -1)
6443 eh->elf.root.u.def.section->gc_mark = 1;
6444 else
6445 rsec = h->root.u.def.section;
6446 break;
6447
6448 case bfd_link_hash_common:
6449 rsec = h->root.u.c.p->section;
6450 break;
6451
6452 default:
6453 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6454 }
6455 }
6456 }
6457 else
6458 {
6459 struct _opd_sec_data *opd;
6460
6461 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6462 opd = get_opd_info (rsec);
6463 if (opd != NULL && opd->func_sec != NULL)
6464 {
6465 rsec->gc_mark = 1;
6466
6467 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6468 }
6469 }
6470
6471 return rsec;
6472 }
6473
6474 /* Update the .got, .plt. and dynamic reloc reference counts for the
6475 section being removed. */
6476
6477 static bfd_boolean
6478 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6479 asection *sec, const Elf_Internal_Rela *relocs)
6480 {
6481 struct ppc_link_hash_table *htab;
6482 Elf_Internal_Shdr *symtab_hdr;
6483 struct elf_link_hash_entry **sym_hashes;
6484 struct got_entry **local_got_ents;
6485 const Elf_Internal_Rela *rel, *relend;
6486
6487 if (bfd_link_relocatable (info))
6488 return TRUE;
6489
6490 if ((sec->flags & SEC_ALLOC) == 0)
6491 return TRUE;
6492
6493 elf_section_data (sec)->local_dynrel = NULL;
6494
6495 htab = ppc_hash_table (info);
6496 if (htab == NULL)
6497 return FALSE;
6498
6499 symtab_hdr = &elf_symtab_hdr (abfd);
6500 sym_hashes = elf_sym_hashes (abfd);
6501 local_got_ents = elf_local_got_ents (abfd);
6502
6503 relend = relocs + sec->reloc_count;
6504 for (rel = relocs; rel < relend; rel++)
6505 {
6506 unsigned long r_symndx;
6507 enum elf_ppc64_reloc_type r_type;
6508 struct elf_link_hash_entry *h = NULL;
6509 struct plt_entry **plt_list;
6510 unsigned char tls_type = 0;
6511
6512 r_symndx = ELF64_R_SYM (rel->r_info);
6513 r_type = ELF64_R_TYPE (rel->r_info);
6514 if (r_symndx >= symtab_hdr->sh_info)
6515 {
6516 struct ppc_link_hash_entry *eh;
6517 struct elf_dyn_relocs **pp;
6518 struct elf_dyn_relocs *p;
6519
6520 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6521 h = elf_follow_link (h);
6522 eh = (struct ppc_link_hash_entry *) h;
6523
6524 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6525 if (p->sec == sec)
6526 {
6527 /* Everything must go for SEC. */
6528 *pp = p->next;
6529 break;
6530 }
6531 }
6532
6533 switch (r_type)
6534 {
6535 case R_PPC64_GOT_TLSLD16:
6536 case R_PPC64_GOT_TLSLD16_LO:
6537 case R_PPC64_GOT_TLSLD16_HI:
6538 case R_PPC64_GOT_TLSLD16_HA:
6539 tls_type = TLS_TLS | TLS_LD;
6540 goto dogot;
6541
6542 case R_PPC64_GOT_TLSGD16:
6543 case R_PPC64_GOT_TLSGD16_LO:
6544 case R_PPC64_GOT_TLSGD16_HI:
6545 case R_PPC64_GOT_TLSGD16_HA:
6546 tls_type = TLS_TLS | TLS_GD;
6547 goto dogot;
6548
6549 case R_PPC64_GOT_TPREL16_DS:
6550 case R_PPC64_GOT_TPREL16_LO_DS:
6551 case R_PPC64_GOT_TPREL16_HI:
6552 case R_PPC64_GOT_TPREL16_HA:
6553 tls_type = TLS_TLS | TLS_TPREL;
6554 goto dogot;
6555
6556 case R_PPC64_GOT_DTPREL16_DS:
6557 case R_PPC64_GOT_DTPREL16_LO_DS:
6558 case R_PPC64_GOT_DTPREL16_HI:
6559 case R_PPC64_GOT_DTPREL16_HA:
6560 tls_type = TLS_TLS | TLS_DTPREL;
6561 goto dogot;
6562
6563 case R_PPC64_GOT16:
6564 case R_PPC64_GOT16_DS:
6565 case R_PPC64_GOT16_HA:
6566 case R_PPC64_GOT16_HI:
6567 case R_PPC64_GOT16_LO:
6568 case R_PPC64_GOT16_LO_DS:
6569 dogot:
6570 {
6571 struct got_entry *ent;
6572
6573 if (h != NULL)
6574 ent = h->got.glist;
6575 else
6576 ent = local_got_ents[r_symndx];
6577
6578 for (; ent != NULL; ent = ent->next)
6579 if (ent->addend == rel->r_addend
6580 && ent->owner == abfd
6581 && ent->tls_type == tls_type)
6582 break;
6583 if (ent == NULL)
6584 abort ();
6585 if (ent->got.refcount > 0)
6586 ent->got.refcount -= 1;
6587 }
6588 break;
6589
6590 case R_PPC64_PLT16_HA:
6591 case R_PPC64_PLT16_HI:
6592 case R_PPC64_PLT16_LO:
6593 case R_PPC64_PLT32:
6594 case R_PPC64_PLT64:
6595 case R_PPC64_REL14:
6596 case R_PPC64_REL14_BRNTAKEN:
6597 case R_PPC64_REL14_BRTAKEN:
6598 case R_PPC64_REL24:
6599 plt_list = NULL;
6600 if (h != NULL)
6601 plt_list = &h->plt.plist;
6602 else if (local_got_ents != NULL)
6603 {
6604 struct plt_entry **local_plt = (struct plt_entry **)
6605 (local_got_ents + symtab_hdr->sh_info);
6606 unsigned char *local_got_tls_masks = (unsigned char *)
6607 (local_plt + symtab_hdr->sh_info);
6608 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6609 plt_list = local_plt + r_symndx;
6610 }
6611 if (plt_list)
6612 {
6613 struct plt_entry *ent;
6614
6615 for (ent = *plt_list; ent != NULL; ent = ent->next)
6616 if (ent->addend == rel->r_addend)
6617 break;
6618 if (ent != NULL && ent->plt.refcount > 0)
6619 ent->plt.refcount -= 1;
6620 }
6621 break;
6622
6623 default:
6624 break;
6625 }
6626 }
6627 return TRUE;
6628 }
6629
6630 /* The maximum size of .sfpr. */
6631 #define SFPR_MAX (218*4)
6632
6633 struct sfpr_def_parms
6634 {
6635 const char name[12];
6636 unsigned char lo, hi;
6637 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6638 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6639 };
6640
6641 /* Auto-generate _save*, _rest* functions in .sfpr.
6642 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6643 instead. */
6644
6645 static bfd_boolean
6646 sfpr_define (struct bfd_link_info *info,
6647 const struct sfpr_def_parms *parm,
6648 asection *stub_sec)
6649 {
6650 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6651 unsigned int i;
6652 size_t len = strlen (parm->name);
6653 bfd_boolean writing = FALSE;
6654 char sym[16];
6655
6656 if (htab == NULL)
6657 return FALSE;
6658
6659 memcpy (sym, parm->name, len);
6660 sym[len + 2] = 0;
6661
6662 for (i = parm->lo; i <= parm->hi; i++)
6663 {
6664 struct ppc_link_hash_entry *h;
6665
6666 sym[len + 0] = i / 10 + '0';
6667 sym[len + 1] = i % 10 + '0';
6668 h = (struct ppc_link_hash_entry *)
6669 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6670 if (stub_sec != NULL)
6671 {
6672 if (h != NULL
6673 && h->elf.root.type == bfd_link_hash_defined
6674 && h->elf.root.u.def.section == htab->sfpr)
6675 {
6676 struct elf_link_hash_entry *s;
6677 char buf[32];
6678 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6679 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6680 if (s == NULL)
6681 return FALSE;
6682 if (s->root.type == bfd_link_hash_new
6683 || (s->root.type = bfd_link_hash_defined
6684 && s->root.u.def.section == stub_sec))
6685 {
6686 s->root.type = bfd_link_hash_defined;
6687 s->root.u.def.section = stub_sec;
6688 s->root.u.def.value = (stub_sec->size
6689 + h->elf.root.u.def.value);
6690 s->ref_regular = 1;
6691 s->def_regular = 1;
6692 s->ref_regular_nonweak = 1;
6693 s->forced_local = 1;
6694 s->non_elf = 0;
6695 s->root.linker_def = 1;
6696 }
6697 }
6698 continue;
6699 }
6700 if (h != NULL)
6701 {
6702 h->save_res = 1;
6703 if (!h->elf.def_regular)
6704 {
6705 h->elf.root.type = bfd_link_hash_defined;
6706 h->elf.root.u.def.section = htab->sfpr;
6707 h->elf.root.u.def.value = htab->sfpr->size;
6708 h->elf.type = STT_FUNC;
6709 h->elf.def_regular = 1;
6710 h->elf.non_elf = 0;
6711 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6712 writing = TRUE;
6713 if (htab->sfpr->contents == NULL)
6714 {
6715 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6716 if (htab->sfpr->contents == NULL)
6717 return FALSE;
6718 }
6719 }
6720 }
6721 if (writing)
6722 {
6723 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6724 if (i != parm->hi)
6725 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6726 else
6727 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6728 htab->sfpr->size = p - htab->sfpr->contents;
6729 }
6730 }
6731
6732 return TRUE;
6733 }
6734
6735 static bfd_byte *
6736 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6737 {
6738 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6739 return p + 4;
6740 }
6741
6742 static bfd_byte *
6743 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6744 {
6745 p = savegpr0 (abfd, p, r);
6746 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6747 p = p + 4;
6748 bfd_put_32 (abfd, BLR, p);
6749 return p + 4;
6750 }
6751
6752 static bfd_byte *
6753 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6754 {
6755 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6756 return p + 4;
6757 }
6758
6759 static bfd_byte *
6760 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6761 {
6762 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6763 p = p + 4;
6764 p = restgpr0 (abfd, p, r);
6765 bfd_put_32 (abfd, MTLR_R0, p);
6766 p = p + 4;
6767 if (r == 29)
6768 {
6769 p = restgpr0 (abfd, p, 30);
6770 p = restgpr0 (abfd, p, 31);
6771 }
6772 bfd_put_32 (abfd, BLR, p);
6773 return p + 4;
6774 }
6775
6776 static bfd_byte *
6777 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6778 {
6779 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6780 return p + 4;
6781 }
6782
6783 static bfd_byte *
6784 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6785 {
6786 p = savegpr1 (abfd, p, r);
6787 bfd_put_32 (abfd, BLR, p);
6788 return p + 4;
6789 }
6790
6791 static bfd_byte *
6792 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6793 {
6794 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6795 return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6800 {
6801 p = restgpr1 (abfd, p, r);
6802 bfd_put_32 (abfd, BLR, p);
6803 return p + 4;
6804 }
6805
6806 static bfd_byte *
6807 savefpr (bfd *abfd, bfd_byte *p, int r)
6808 {
6809 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6810 return p + 4;
6811 }
6812
6813 static bfd_byte *
6814 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6815 {
6816 p = savefpr (abfd, p, r);
6817 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6818 p = p + 4;
6819 bfd_put_32 (abfd, BLR, p);
6820 return p + 4;
6821 }
6822
6823 static bfd_byte *
6824 restfpr (bfd *abfd, bfd_byte *p, int r)
6825 {
6826 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6827 return p + 4;
6828 }
6829
6830 static bfd_byte *
6831 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6832 {
6833 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6834 p = p + 4;
6835 p = restfpr (abfd, p, r);
6836 bfd_put_32 (abfd, MTLR_R0, p);
6837 p = p + 4;
6838 if (r == 29)
6839 {
6840 p = restfpr (abfd, p, 30);
6841 p = restfpr (abfd, p, 31);
6842 }
6843 bfd_put_32 (abfd, BLR, p);
6844 return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850 p = savefpr (abfd, p, r);
6851 bfd_put_32 (abfd, BLR, p);
6852 return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6857 {
6858 p = restfpr (abfd, p, r);
6859 bfd_put_32 (abfd, BLR, p);
6860 return p + 4;
6861 }
6862
6863 static bfd_byte *
6864 savevr (bfd *abfd, bfd_byte *p, int r)
6865 {
6866 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6867 p = p + 4;
6868 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6869 return p + 4;
6870 }
6871
6872 static bfd_byte *
6873 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6874 {
6875 p = savevr (abfd, p, r);
6876 bfd_put_32 (abfd, BLR, p);
6877 return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 restvr (bfd *abfd, bfd_byte *p, int r)
6882 {
6883 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6884 p = p + 4;
6885 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6886 return p + 4;
6887 }
6888
6889 static bfd_byte *
6890 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6891 {
6892 p = restvr (abfd, p, r);
6893 bfd_put_32 (abfd, BLR, p);
6894 return p + 4;
6895 }
6896
6897 /* Called via elf_link_hash_traverse to transfer dynamic linking
6898 information on function code symbol entries to their corresponding
6899 function descriptor symbol entries. */
6900
6901 static bfd_boolean
6902 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6903 {
6904 struct bfd_link_info *info;
6905 struct ppc_link_hash_table *htab;
6906 struct plt_entry *ent;
6907 struct ppc_link_hash_entry *fh;
6908 struct ppc_link_hash_entry *fdh;
6909 bfd_boolean force_local;
6910
6911 fh = (struct ppc_link_hash_entry *) h;
6912 if (fh->elf.root.type == bfd_link_hash_indirect)
6913 return TRUE;
6914
6915 info = inf;
6916 htab = ppc_hash_table (info);
6917 if (htab == NULL)
6918 return FALSE;
6919
6920 /* Resolve undefined references to dot-symbols as the value
6921 in the function descriptor, if we have one in a regular object.
6922 This is to satisfy cases like ".quad .foo". Calls to functions
6923 in dynamic objects are handled elsewhere. */
6924 if (fh->elf.root.type == bfd_link_hash_undefweak
6925 && fh->was_undefined
6926 && (fdh = defined_func_desc (fh)) != NULL
6927 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6928 && opd_entry_value (fdh->elf.root.u.def.section,
6929 fdh->elf.root.u.def.value,
6930 &fh->elf.root.u.def.section,
6931 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6932 {
6933 fh->elf.root.type = fdh->elf.root.type;
6934 fh->elf.forced_local = 1;
6935 fh->elf.def_regular = fdh->elf.def_regular;
6936 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6937 }
6938
6939 /* If this is a function code symbol, transfer dynamic linking
6940 information to the function descriptor symbol. */
6941 if (!fh->is_func)
6942 return TRUE;
6943
6944 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6945 if (ent->plt.refcount > 0)
6946 break;
6947 if (ent == NULL
6948 || fh->elf.root.root.string[0] != '.'
6949 || fh->elf.root.root.string[1] == '\0')
6950 return TRUE;
6951
6952 /* Find the corresponding function descriptor symbol. Create it
6953 as undefined if necessary. */
6954
6955 fdh = lookup_fdh (fh, htab);
6956 if (fdh == NULL
6957 && !bfd_link_executable (info)
6958 && (fh->elf.root.type == bfd_link_hash_undefined
6959 || fh->elf.root.type == bfd_link_hash_undefweak))
6960 {
6961 fdh = make_fdh (info, fh);
6962 if (fdh == NULL)
6963 return FALSE;
6964 }
6965
6966 /* Fake function descriptors are made undefweak. If the function
6967 code symbol is strong undefined, make the fake sym the same.
6968 If the function code symbol is defined, then force the fake
6969 descriptor local; We can't support overriding of symbols in a
6970 shared library on a fake descriptor. */
6971
6972 if (fdh != NULL
6973 && fdh->fake
6974 && fdh->elf.root.type == bfd_link_hash_undefweak)
6975 {
6976 if (fh->elf.root.type == bfd_link_hash_undefined)
6977 {
6978 fdh->elf.root.type = bfd_link_hash_undefined;
6979 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6980 }
6981 else if (fh->elf.root.type == bfd_link_hash_defined
6982 || fh->elf.root.type == bfd_link_hash_defweak)
6983 {
6984 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6985 }
6986 }
6987
6988 if (fdh != NULL
6989 && !fdh->elf.forced_local
6990 && (!bfd_link_executable (info)
6991 || fdh->elf.def_dynamic
6992 || fdh->elf.ref_dynamic
6993 || (fdh->elf.root.type == bfd_link_hash_undefweak
6994 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6995 {
6996 if (fdh->elf.dynindx == -1)
6997 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6998 return FALSE;
6999 fdh->elf.ref_regular |= fh->elf.ref_regular;
7000 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7001 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7002 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7003 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7004 {
7005 move_plt_plist (fh, fdh);
7006 fdh->elf.needs_plt = 1;
7007 }
7008 fdh->is_func_descriptor = 1;
7009 fdh->oh = fh;
7010 fh->oh = fdh;
7011 }
7012
7013 /* Now that the info is on the function descriptor, clear the
7014 function code sym info. Any function code syms for which we
7015 don't have a definition in a regular file, we force local.
7016 This prevents a shared library from exporting syms that have
7017 been imported from another library. Function code syms that
7018 are really in the library we must leave global to prevent the
7019 linker dragging in a definition from a static library. */
7020 force_local = (!fh->elf.def_regular
7021 || fdh == NULL
7022 || !fdh->elf.def_regular
7023 || fdh->elf.forced_local);
7024 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7025
7026 return TRUE;
7027 }
7028
7029 static const struct sfpr_def_parms save_res_funcs[] =
7030 {
7031 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7032 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7033 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7034 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7035 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7036 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7037 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7038 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7039 { "._savef", 14, 31, savefpr, savefpr1_tail },
7040 { "._restf", 14, 31, restfpr, restfpr1_tail },
7041 { "_savevr_", 20, 31, savevr, savevr_tail },
7042 { "_restvr_", 20, 31, restvr, restvr_tail }
7043 };
7044
7045 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7046 this hook to a) provide some gcc support functions, and b) transfer
7047 dynamic linking information gathered so far on function code symbol
7048 entries, to their corresponding function descriptor symbol entries. */
7049
7050 static bfd_boolean
7051 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7052 struct bfd_link_info *info)
7053 {
7054 struct ppc_link_hash_table *htab;
7055
7056 htab = ppc_hash_table (info);
7057 if (htab == NULL)
7058 return FALSE;
7059
7060 /* Provide any missing _save* and _rest* functions. */
7061 if (htab->sfpr != NULL)
7062 {
7063 unsigned int i;
7064
7065 htab->sfpr->size = 0;
7066 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7067 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7068 return FALSE;
7069 if (htab->sfpr->size == 0)
7070 htab->sfpr->flags |= SEC_EXCLUDE;
7071 }
7072
7073 if (bfd_link_relocatable (info))
7074 return TRUE;
7075
7076 if (htab->elf.hgot != NULL)
7077 {
7078 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7079 /* Make .TOC. defined so as to prevent it being made dynamic.
7080 The wrong value here is fixed later in ppc64_elf_set_toc. */
7081 if (!htab->elf.hgot->def_regular
7082 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7083 {
7084 htab->elf.hgot->root.type = bfd_link_hash_defined;
7085 htab->elf.hgot->root.u.def.value = 0;
7086 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7087 htab->elf.hgot->def_regular = 1;
7088 htab->elf.hgot->root.linker_def = 1;
7089 }
7090 htab->elf.hgot->type = STT_OBJECT;
7091 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7092 | STV_HIDDEN);
7093 }
7094
7095 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7096
7097 return TRUE;
7098 }
7099
7100 /* Return true if we have dynamic relocs that apply to read-only sections. */
7101
7102 static bfd_boolean
7103 readonly_dynrelocs (struct elf_link_hash_entry *h)
7104 {
7105 struct ppc_link_hash_entry *eh;
7106 struct elf_dyn_relocs *p;
7107
7108 eh = (struct ppc_link_hash_entry *) h;
7109 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7110 {
7111 asection *s = p->sec->output_section;
7112
7113 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7114 return TRUE;
7115 }
7116 return FALSE;
7117 }
7118
7119 /* Adjust a symbol defined by a dynamic object and referenced by a
7120 regular object. The current definition is in some section of the
7121 dynamic object, but we're not including those sections. We have to
7122 change the definition to something the rest of the link can
7123 understand. */
7124
7125 static bfd_boolean
7126 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7127 struct elf_link_hash_entry *h)
7128 {
7129 struct ppc_link_hash_table *htab;
7130 asection *s;
7131
7132 htab = ppc_hash_table (info);
7133 if (htab == NULL)
7134 return FALSE;
7135
7136 /* Deal with function syms. */
7137 if (h->type == STT_FUNC
7138 || h->type == STT_GNU_IFUNC
7139 || h->needs_plt)
7140 {
7141 /* Clear procedure linkage table information for any symbol that
7142 won't need a .plt entry. */
7143 struct plt_entry *ent;
7144 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7145 if (ent->plt.refcount > 0)
7146 break;
7147 if (ent == NULL
7148 || (h->type != STT_GNU_IFUNC
7149 && (SYMBOL_CALLS_LOCAL (info, h)
7150 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7151 && h->root.type == bfd_link_hash_undefweak)))
7152 || ((struct ppc_link_hash_entry *) h)->save_res)
7153 {
7154 h->plt.plist = NULL;
7155 h->needs_plt = 0;
7156 h->pointer_equality_needed = 0;
7157 }
7158 else if (abiversion (info->output_bfd) == 2)
7159 {
7160 /* Taking a function's address in a read/write section
7161 doesn't require us to define the function symbol in the
7162 executable on a global entry stub. A dynamic reloc can
7163 be used instead. */
7164 if (h->pointer_equality_needed
7165 && h->type != STT_GNU_IFUNC
7166 && !readonly_dynrelocs (h))
7167 {
7168 h->pointer_equality_needed = 0;
7169 h->non_got_ref = 0;
7170 }
7171
7172 /* After adjust_dynamic_symbol, non_got_ref set in the
7173 non-shared case means that we have allocated space in
7174 .dynbss for the symbol and thus dyn_relocs for this
7175 symbol should be discarded.
7176 If we get here we know we are making a PLT entry for this
7177 symbol, and in an executable we'd normally resolve
7178 relocations against this symbol to the PLT entry. Allow
7179 dynamic relocs if the reference is weak, and the dynamic
7180 relocs will not cause text relocation. */
7181 else if (!h->ref_regular_nonweak
7182 && h->non_got_ref
7183 && h->type != STT_GNU_IFUNC
7184 && !readonly_dynrelocs (h))
7185 h->non_got_ref = 0;
7186
7187 /* If making a plt entry, then we don't need copy relocs. */
7188 return TRUE;
7189 }
7190 }
7191 else
7192 h->plt.plist = NULL;
7193
7194 /* If this is a weak symbol, and there is a real definition, the
7195 processor independent code will have arranged for us to see the
7196 real definition first, and we can just use the same value. */
7197 if (h->u.weakdef != NULL)
7198 {
7199 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7200 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7201 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7202 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7203 if (ELIMINATE_COPY_RELOCS)
7204 h->non_got_ref = h->u.weakdef->non_got_ref;
7205 return TRUE;
7206 }
7207
7208 /* If we are creating a shared library, we must presume that the
7209 only references to the symbol are via the global offset table.
7210 For such cases we need not do anything here; the relocations will
7211 be handled correctly by relocate_section. */
7212 if (bfd_link_pic (info))
7213 return TRUE;
7214
7215 /* If there are no references to this symbol that do not use the
7216 GOT, we don't need to generate a copy reloc. */
7217 if (!h->non_got_ref)
7218 return TRUE;
7219
7220 /* Don't generate a copy reloc for symbols defined in the executable. */
7221 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7222 return TRUE;
7223
7224 /* If -z nocopyreloc was given, don't generate them either. */
7225 if (info->nocopyreloc)
7226 {
7227 h->non_got_ref = 0;
7228 return TRUE;
7229 }
7230
7231 /* If we didn't find any dynamic relocs in read-only sections, then
7232 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7233 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7234 {
7235 h->non_got_ref = 0;
7236 return TRUE;
7237 }
7238
7239 /* Protected variables do not work with .dynbss. The copy in
7240 .dynbss won't be used by the shared library with the protected
7241 definition for the variable. Text relocations are preferable
7242 to an incorrect program. */
7243 if (h->protected_def)
7244 {
7245 h->non_got_ref = 0;
7246 return TRUE;
7247 }
7248
7249 if (h->plt.plist != NULL)
7250 {
7251 /* We should never get here, but unfortunately there are versions
7252 of gcc out there that improperly (for this ABI) put initialized
7253 function pointers, vtable refs and suchlike in read-only
7254 sections. Allow them to proceed, but warn that this might
7255 break at runtime. */
7256 info->callbacks->einfo
7257 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7258 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7259 h->root.root.string);
7260 }
7261
7262 /* This is a reference to a symbol defined by a dynamic object which
7263 is not a function. */
7264
7265 /* We must allocate the symbol in our .dynbss section, which will
7266 become part of the .bss section of the executable. There will be
7267 an entry for this symbol in the .dynsym section. The dynamic
7268 object will contain position independent code, so all references
7269 from the dynamic object to this symbol will go through the global
7270 offset table. The dynamic linker will use the .dynsym entry to
7271 determine the address it must put in the global offset table, so
7272 both the dynamic object and the regular object will refer to the
7273 same memory location for the variable. */
7274
7275 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7276 to copy the initial value out of the dynamic object and into the
7277 runtime process image. We need to remember the offset into the
7278 .rela.bss section we are going to use. */
7279 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7280 {
7281 htab->relbss->size += sizeof (Elf64_External_Rela);
7282 h->needs_copy = 1;
7283 }
7284
7285 s = htab->dynbss;
7286
7287 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7288 }
7289
7290 /* If given a function descriptor symbol, hide both the function code
7291 sym and the descriptor. */
7292 static void
7293 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7294 struct elf_link_hash_entry *h,
7295 bfd_boolean force_local)
7296 {
7297 struct ppc_link_hash_entry *eh;
7298 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7299
7300 eh = (struct ppc_link_hash_entry *) h;
7301 if (eh->is_func_descriptor)
7302 {
7303 struct ppc_link_hash_entry *fh = eh->oh;
7304
7305 if (fh == NULL)
7306 {
7307 const char *p, *q;
7308 struct ppc_link_hash_table *htab;
7309 char save;
7310
7311 /* We aren't supposed to use alloca in BFD because on
7312 systems which do not have alloca the version in libiberty
7313 calls xmalloc, which might cause the program to crash
7314 when it runs out of memory. This function doesn't have a
7315 return status, so there's no way to gracefully return an
7316 error. So cheat. We know that string[-1] can be safely
7317 accessed; It's either a string in an ELF string table,
7318 or allocated in an objalloc structure. */
7319
7320 p = eh->elf.root.root.string - 1;
7321 save = *p;
7322 *(char *) p = '.';
7323 htab = ppc_hash_table (info);
7324 if (htab == NULL)
7325 return;
7326
7327 fh = (struct ppc_link_hash_entry *)
7328 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7329 *(char *) p = save;
7330
7331 /* Unfortunately, if it so happens that the string we were
7332 looking for was allocated immediately before this string,
7333 then we overwrote the string terminator. That's the only
7334 reason the lookup should fail. */
7335 if (fh == NULL)
7336 {
7337 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7338 while (q >= eh->elf.root.root.string && *q == *p)
7339 --q, --p;
7340 if (q < eh->elf.root.root.string && *p == '.')
7341 fh = (struct ppc_link_hash_entry *)
7342 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7343 }
7344 if (fh != NULL)
7345 {
7346 eh->oh = fh;
7347 fh->oh = eh;
7348 }
7349 }
7350 if (fh != NULL)
7351 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7352 }
7353 }
7354
7355 static bfd_boolean
7356 get_sym_h (struct elf_link_hash_entry **hp,
7357 Elf_Internal_Sym **symp,
7358 asection **symsecp,
7359 unsigned char **tls_maskp,
7360 Elf_Internal_Sym **locsymsp,
7361 unsigned long r_symndx,
7362 bfd *ibfd)
7363 {
7364 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7365
7366 if (r_symndx >= symtab_hdr->sh_info)
7367 {
7368 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7369 struct elf_link_hash_entry *h;
7370
7371 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7372 h = elf_follow_link (h);
7373
7374 if (hp != NULL)
7375 *hp = h;
7376
7377 if (symp != NULL)
7378 *symp = NULL;
7379
7380 if (symsecp != NULL)
7381 {
7382 asection *symsec = NULL;
7383 if (h->root.type == bfd_link_hash_defined
7384 || h->root.type == bfd_link_hash_defweak)
7385 symsec = h->root.u.def.section;
7386 *symsecp = symsec;
7387 }
7388
7389 if (tls_maskp != NULL)
7390 {
7391 struct ppc_link_hash_entry *eh;
7392
7393 eh = (struct ppc_link_hash_entry *) h;
7394 *tls_maskp = &eh->tls_mask;
7395 }
7396 }
7397 else
7398 {
7399 Elf_Internal_Sym *sym;
7400 Elf_Internal_Sym *locsyms = *locsymsp;
7401
7402 if (locsyms == NULL)
7403 {
7404 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7405 if (locsyms == NULL)
7406 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7407 symtab_hdr->sh_info,
7408 0, NULL, NULL, NULL);
7409 if (locsyms == NULL)
7410 return FALSE;
7411 *locsymsp = locsyms;
7412 }
7413 sym = locsyms + r_symndx;
7414
7415 if (hp != NULL)
7416 *hp = NULL;
7417
7418 if (symp != NULL)
7419 *symp = sym;
7420
7421 if (symsecp != NULL)
7422 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7423
7424 if (tls_maskp != NULL)
7425 {
7426 struct got_entry **lgot_ents;
7427 unsigned char *tls_mask;
7428
7429 tls_mask = NULL;
7430 lgot_ents = elf_local_got_ents (ibfd);
7431 if (lgot_ents != NULL)
7432 {
7433 struct plt_entry **local_plt = (struct plt_entry **)
7434 (lgot_ents + symtab_hdr->sh_info);
7435 unsigned char *lgot_masks = (unsigned char *)
7436 (local_plt + symtab_hdr->sh_info);
7437 tls_mask = &lgot_masks[r_symndx];
7438 }
7439 *tls_maskp = tls_mask;
7440 }
7441 }
7442 return TRUE;
7443 }
7444
7445 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7446 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7447 type suitable for optimization, and 1 otherwise. */
7448
7449 static int
7450 get_tls_mask (unsigned char **tls_maskp,
7451 unsigned long *toc_symndx,
7452 bfd_vma *toc_addend,
7453 Elf_Internal_Sym **locsymsp,
7454 const Elf_Internal_Rela *rel,
7455 bfd *ibfd)
7456 {
7457 unsigned long r_symndx;
7458 int next_r;
7459 struct elf_link_hash_entry *h;
7460 Elf_Internal_Sym *sym;
7461 asection *sec;
7462 bfd_vma off;
7463
7464 r_symndx = ELF64_R_SYM (rel->r_info);
7465 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7466 return 0;
7467
7468 if ((*tls_maskp != NULL && **tls_maskp != 0)
7469 || sec == NULL
7470 || ppc64_elf_section_data (sec) == NULL
7471 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7472 return 1;
7473
7474 /* Look inside a TOC section too. */
7475 if (h != NULL)
7476 {
7477 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7478 off = h->root.u.def.value;
7479 }
7480 else
7481 off = sym->st_value;
7482 off += rel->r_addend;
7483 BFD_ASSERT (off % 8 == 0);
7484 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7485 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7486 if (toc_symndx != NULL)
7487 *toc_symndx = r_symndx;
7488 if (toc_addend != NULL)
7489 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7490 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7491 return 0;
7492 if ((h == NULL || is_static_defined (h))
7493 && (next_r == -1 || next_r == -2))
7494 return 1 - next_r;
7495 return 1;
7496 }
7497
7498 /* Find (or create) an entry in the tocsave hash table. */
7499
7500 static struct tocsave_entry *
7501 tocsave_find (struct ppc_link_hash_table *htab,
7502 enum insert_option insert,
7503 Elf_Internal_Sym **local_syms,
7504 const Elf_Internal_Rela *irela,
7505 bfd *ibfd)
7506 {
7507 unsigned long r_indx;
7508 struct elf_link_hash_entry *h;
7509 Elf_Internal_Sym *sym;
7510 struct tocsave_entry ent, *p;
7511 hashval_t hash;
7512 struct tocsave_entry **slot;
7513
7514 r_indx = ELF64_R_SYM (irela->r_info);
7515 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7516 return NULL;
7517 if (ent.sec == NULL || ent.sec->output_section == NULL)
7518 {
7519 (*_bfd_error_handler)
7520 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7521 return NULL;
7522 }
7523
7524 if (h != NULL)
7525 ent.offset = h->root.u.def.value;
7526 else
7527 ent.offset = sym->st_value;
7528 ent.offset += irela->r_addend;
7529
7530 hash = tocsave_htab_hash (&ent);
7531 slot = ((struct tocsave_entry **)
7532 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7533 if (slot == NULL)
7534 return NULL;
7535
7536 if (*slot == NULL)
7537 {
7538 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7539 if (p == NULL)
7540 return NULL;
7541 *p = ent;
7542 *slot = p;
7543 }
7544 return *slot;
7545 }
7546
7547 /* Adjust all global syms defined in opd sections. In gcc generated
7548 code for the old ABI, these will already have been done. */
7549
7550 static bfd_boolean
7551 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7552 {
7553 struct ppc_link_hash_entry *eh;
7554 asection *sym_sec;
7555 struct _opd_sec_data *opd;
7556
7557 if (h->root.type == bfd_link_hash_indirect)
7558 return TRUE;
7559
7560 if (h->root.type != bfd_link_hash_defined
7561 && h->root.type != bfd_link_hash_defweak)
7562 return TRUE;
7563
7564 eh = (struct ppc_link_hash_entry *) h;
7565 if (eh->adjust_done)
7566 return TRUE;
7567
7568 sym_sec = eh->elf.root.u.def.section;
7569 opd = get_opd_info (sym_sec);
7570 if (opd != NULL && opd->adjust != NULL)
7571 {
7572 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7573 if (adjust == -1)
7574 {
7575 /* This entry has been deleted. */
7576 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7577 if (dsec == NULL)
7578 {
7579 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7580 if (discarded_section (dsec))
7581 {
7582 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7583 break;
7584 }
7585 }
7586 eh->elf.root.u.def.value = 0;
7587 eh->elf.root.u.def.section = dsec;
7588 }
7589 else
7590 eh->elf.root.u.def.value += adjust;
7591 eh->adjust_done = 1;
7592 }
7593 return TRUE;
7594 }
7595
7596 /* Handles decrementing dynamic reloc counts for the reloc specified by
7597 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7598 have already been determined. */
7599
7600 static bfd_boolean
7601 dec_dynrel_count (bfd_vma r_info,
7602 asection *sec,
7603 struct bfd_link_info *info,
7604 Elf_Internal_Sym **local_syms,
7605 struct elf_link_hash_entry *h,
7606 Elf_Internal_Sym *sym)
7607 {
7608 enum elf_ppc64_reloc_type r_type;
7609 asection *sym_sec = NULL;
7610
7611 /* Can this reloc be dynamic? This switch, and later tests here
7612 should be kept in sync with the code in check_relocs. */
7613 r_type = ELF64_R_TYPE (r_info);
7614 switch (r_type)
7615 {
7616 default:
7617 return TRUE;
7618
7619 case R_PPC64_TPREL16:
7620 case R_PPC64_TPREL16_LO:
7621 case R_PPC64_TPREL16_HI:
7622 case R_PPC64_TPREL16_HA:
7623 case R_PPC64_TPREL16_DS:
7624 case R_PPC64_TPREL16_LO_DS:
7625 case R_PPC64_TPREL16_HIGH:
7626 case R_PPC64_TPREL16_HIGHA:
7627 case R_PPC64_TPREL16_HIGHER:
7628 case R_PPC64_TPREL16_HIGHERA:
7629 case R_PPC64_TPREL16_HIGHEST:
7630 case R_PPC64_TPREL16_HIGHESTA:
7631 if (!bfd_link_pic (info))
7632 return TRUE;
7633
7634 case R_PPC64_TPREL64:
7635 case R_PPC64_DTPMOD64:
7636 case R_PPC64_DTPREL64:
7637 case R_PPC64_ADDR64:
7638 case R_PPC64_REL30:
7639 case R_PPC64_REL32:
7640 case R_PPC64_REL64:
7641 case R_PPC64_ADDR14:
7642 case R_PPC64_ADDR14_BRNTAKEN:
7643 case R_PPC64_ADDR14_BRTAKEN:
7644 case R_PPC64_ADDR16:
7645 case R_PPC64_ADDR16_DS:
7646 case R_PPC64_ADDR16_HA:
7647 case R_PPC64_ADDR16_HI:
7648 case R_PPC64_ADDR16_HIGH:
7649 case R_PPC64_ADDR16_HIGHA:
7650 case R_PPC64_ADDR16_HIGHER:
7651 case R_PPC64_ADDR16_HIGHERA:
7652 case R_PPC64_ADDR16_HIGHEST:
7653 case R_PPC64_ADDR16_HIGHESTA:
7654 case R_PPC64_ADDR16_LO:
7655 case R_PPC64_ADDR16_LO_DS:
7656 case R_PPC64_ADDR24:
7657 case R_PPC64_ADDR32:
7658 case R_PPC64_UADDR16:
7659 case R_PPC64_UADDR32:
7660 case R_PPC64_UADDR64:
7661 case R_PPC64_TOC:
7662 break;
7663 }
7664
7665 if (local_syms != NULL)
7666 {
7667 unsigned long r_symndx;
7668 bfd *ibfd = sec->owner;
7669
7670 r_symndx = ELF64_R_SYM (r_info);
7671 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7672 return FALSE;
7673 }
7674
7675 if ((bfd_link_pic (info)
7676 && (must_be_dyn_reloc (info, r_type)
7677 || (h != NULL
7678 && (!SYMBOLIC_BIND (info, h)
7679 || h->root.type == bfd_link_hash_defweak
7680 || !h->def_regular))))
7681 || (ELIMINATE_COPY_RELOCS
7682 && !bfd_link_pic (info)
7683 && h != NULL
7684 && (h->root.type == bfd_link_hash_defweak
7685 || !h->def_regular)))
7686 ;
7687 else
7688 return TRUE;
7689
7690 if (h != NULL)
7691 {
7692 struct elf_dyn_relocs *p;
7693 struct elf_dyn_relocs **pp;
7694 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7695
7696 /* elf_gc_sweep may have already removed all dyn relocs associated
7697 with local syms for a given section. Also, symbol flags are
7698 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7699 report a dynreloc miscount. */
7700 if (*pp == NULL && info->gc_sections)
7701 return TRUE;
7702
7703 while ((p = *pp) != NULL)
7704 {
7705 if (p->sec == sec)
7706 {
7707 if (!must_be_dyn_reloc (info, r_type))
7708 p->pc_count -= 1;
7709 p->count -= 1;
7710 if (p->count == 0)
7711 *pp = p->next;
7712 return TRUE;
7713 }
7714 pp = &p->next;
7715 }
7716 }
7717 else
7718 {
7719 struct ppc_dyn_relocs *p;
7720 struct ppc_dyn_relocs **pp;
7721 void *vpp;
7722 bfd_boolean is_ifunc;
7723
7724 if (local_syms == NULL)
7725 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7726 if (sym_sec == NULL)
7727 sym_sec = sec;
7728
7729 vpp = &elf_section_data (sym_sec)->local_dynrel;
7730 pp = (struct ppc_dyn_relocs **) vpp;
7731
7732 if (*pp == NULL && info->gc_sections)
7733 return TRUE;
7734
7735 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7736 while ((p = *pp) != NULL)
7737 {
7738 if (p->sec == sec && p->ifunc == is_ifunc)
7739 {
7740 p->count -= 1;
7741 if (p->count == 0)
7742 *pp = p->next;
7743 return TRUE;
7744 }
7745 pp = &p->next;
7746 }
7747 }
7748
7749 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7750 sec->owner, sec);
7751 bfd_set_error (bfd_error_bad_value);
7752 return FALSE;
7753 }
7754
7755 /* Remove unused Official Procedure Descriptor entries. Currently we
7756 only remove those associated with functions in discarded link-once
7757 sections, or weakly defined functions that have been overridden. It
7758 would be possible to remove many more entries for statically linked
7759 applications. */
7760
7761 bfd_boolean
7762 ppc64_elf_edit_opd (struct bfd_link_info *info)
7763 {
7764 bfd *ibfd;
7765 bfd_boolean some_edited = FALSE;
7766 asection *need_pad = NULL;
7767 struct ppc_link_hash_table *htab;
7768
7769 htab = ppc_hash_table (info);
7770 if (htab == NULL)
7771 return FALSE;
7772
7773 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7774 {
7775 asection *sec;
7776 Elf_Internal_Rela *relstart, *rel, *relend;
7777 Elf_Internal_Shdr *symtab_hdr;
7778 Elf_Internal_Sym *local_syms;
7779 struct _opd_sec_data *opd;
7780 bfd_boolean need_edit, add_aux_fields, broken;
7781 bfd_size_type cnt_16b = 0;
7782
7783 if (!is_ppc64_elf (ibfd))
7784 continue;
7785
7786 sec = bfd_get_section_by_name (ibfd, ".opd");
7787 if (sec == NULL || sec->size == 0)
7788 continue;
7789
7790 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7791 continue;
7792
7793 if (sec->output_section == bfd_abs_section_ptr)
7794 continue;
7795
7796 /* Look through the section relocs. */
7797 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7798 continue;
7799
7800 local_syms = NULL;
7801 symtab_hdr = &elf_symtab_hdr (ibfd);
7802
7803 /* Read the relocations. */
7804 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7805 info->keep_memory);
7806 if (relstart == NULL)
7807 return FALSE;
7808
7809 /* First run through the relocs to check they are sane, and to
7810 determine whether we need to edit this opd section. */
7811 need_edit = FALSE;
7812 broken = FALSE;
7813 need_pad = sec;
7814 relend = relstart + sec->reloc_count;
7815 for (rel = relstart; rel < relend; )
7816 {
7817 enum elf_ppc64_reloc_type r_type;
7818 unsigned long r_symndx;
7819 asection *sym_sec;
7820 struct elf_link_hash_entry *h;
7821 Elf_Internal_Sym *sym;
7822 bfd_vma offset;
7823
7824 /* .opd contains an array of 16 or 24 byte entries. We're
7825 only interested in the reloc pointing to a function entry
7826 point. */
7827 offset = rel->r_offset;
7828 if (rel + 1 == relend
7829 || rel[1].r_offset != offset + 8)
7830 {
7831 /* If someone messes with .opd alignment then after a
7832 "ld -r" we might have padding in the middle of .opd.
7833 Also, there's nothing to prevent someone putting
7834 something silly in .opd with the assembler. No .opd
7835 optimization for them! */
7836 broken_opd:
7837 (*_bfd_error_handler)
7838 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7839 broken = TRUE;
7840 break;
7841 }
7842
7843 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7844 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7845 {
7846 (*_bfd_error_handler)
7847 (_("%B: unexpected reloc type %u in .opd section"),
7848 ibfd, r_type);
7849 broken = TRUE;
7850 break;
7851 }
7852
7853 r_symndx = ELF64_R_SYM (rel->r_info);
7854 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7855 r_symndx, ibfd))
7856 goto error_ret;
7857
7858 if (sym_sec == NULL || sym_sec->owner == NULL)
7859 {
7860 const char *sym_name;
7861 if (h != NULL)
7862 sym_name = h->root.root.string;
7863 else
7864 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7865 sym_sec);
7866
7867 (*_bfd_error_handler)
7868 (_("%B: undefined sym `%s' in .opd section"),
7869 ibfd, sym_name);
7870 broken = TRUE;
7871 break;
7872 }
7873
7874 /* opd entries are always for functions defined in the
7875 current input bfd. If the symbol isn't defined in the
7876 input bfd, then we won't be using the function in this
7877 bfd; It must be defined in a linkonce section in another
7878 bfd, or is weak. It's also possible that we are
7879 discarding the function due to a linker script /DISCARD/,
7880 which we test for via the output_section. */
7881 if (sym_sec->owner != ibfd
7882 || sym_sec->output_section == bfd_abs_section_ptr)
7883 need_edit = TRUE;
7884
7885 rel += 2;
7886 if (rel + 1 == relend
7887 || (rel + 2 < relend
7888 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7889 ++rel;
7890
7891 if (rel == relend)
7892 {
7893 if (sec->size == offset + 24)
7894 {
7895 need_pad = NULL;
7896 break;
7897 }
7898 if (sec->size == offset + 16)
7899 {
7900 cnt_16b++;
7901 break;
7902 }
7903 goto broken_opd;
7904 }
7905 else if (rel + 1 < relend
7906 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7907 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7908 {
7909 if (rel[0].r_offset == offset + 16)
7910 cnt_16b++;
7911 else if (rel[0].r_offset != offset + 24)
7912 goto broken_opd;
7913 }
7914 else
7915 goto broken_opd;
7916 }
7917
7918 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7919
7920 if (!broken && (need_edit || add_aux_fields))
7921 {
7922 Elf_Internal_Rela *write_rel;
7923 Elf_Internal_Shdr *rel_hdr;
7924 bfd_byte *rptr, *wptr;
7925 bfd_byte *new_contents;
7926 bfd_size_type amt;
7927
7928 new_contents = NULL;
7929 amt = OPD_NDX (sec->size) * sizeof (long);
7930 opd = &ppc64_elf_section_data (sec)->u.opd;
7931 opd->adjust = bfd_zalloc (sec->owner, amt);
7932 if (opd->adjust == NULL)
7933 return FALSE;
7934 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7935
7936 /* This seems a waste of time as input .opd sections are all
7937 zeros as generated by gcc, but I suppose there's no reason
7938 this will always be so. We might start putting something in
7939 the third word of .opd entries. */
7940 if ((sec->flags & SEC_IN_MEMORY) == 0)
7941 {
7942 bfd_byte *loc;
7943 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7944 {
7945 if (loc != NULL)
7946 free (loc);
7947 error_ret:
7948 if (local_syms != NULL
7949 && symtab_hdr->contents != (unsigned char *) local_syms)
7950 free (local_syms);
7951 if (elf_section_data (sec)->relocs != relstart)
7952 free (relstart);
7953 return FALSE;
7954 }
7955 sec->contents = loc;
7956 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7957 }
7958
7959 elf_section_data (sec)->relocs = relstart;
7960
7961 new_contents = sec->contents;
7962 if (add_aux_fields)
7963 {
7964 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7965 if (new_contents == NULL)
7966 return FALSE;
7967 need_pad = NULL;
7968 }
7969 wptr = new_contents;
7970 rptr = sec->contents;
7971 write_rel = relstart;
7972 for (rel = relstart; rel < relend; )
7973 {
7974 unsigned long r_symndx;
7975 asection *sym_sec;
7976 struct elf_link_hash_entry *h;
7977 struct ppc_link_hash_entry *fdh = NULL;
7978 Elf_Internal_Sym *sym;
7979 long opd_ent_size;
7980 Elf_Internal_Rela *next_rel;
7981 bfd_boolean skip;
7982
7983 r_symndx = ELF64_R_SYM (rel->r_info);
7984 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7985 r_symndx, ibfd))
7986 goto error_ret;
7987
7988 next_rel = rel + 2;
7989 if (next_rel + 1 == relend
7990 || (next_rel + 2 < relend
7991 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7992 ++next_rel;
7993
7994 /* See if the .opd entry is full 24 byte or
7995 16 byte (with fd_aux entry overlapped with next
7996 fd_func). */
7997 opd_ent_size = 24;
7998 if (next_rel == relend)
7999 {
8000 if (sec->size == rel->r_offset + 16)
8001 opd_ent_size = 16;
8002 }
8003 else if (next_rel->r_offset == rel->r_offset + 16)
8004 opd_ent_size = 16;
8005
8006 if (h != NULL
8007 && h->root.root.string[0] == '.')
8008 {
8009 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8010 if (fdh != NULL
8011 && fdh->elf.root.type != bfd_link_hash_defined
8012 && fdh->elf.root.type != bfd_link_hash_defweak)
8013 fdh = NULL;
8014 }
8015
8016 skip = (sym_sec->owner != ibfd
8017 || sym_sec->output_section == bfd_abs_section_ptr);
8018 if (skip)
8019 {
8020 if (fdh != NULL && sym_sec->owner == ibfd)
8021 {
8022 /* Arrange for the function descriptor sym
8023 to be dropped. */
8024 fdh->elf.root.u.def.value = 0;
8025 fdh->elf.root.u.def.section = sym_sec;
8026 }
8027 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8028
8029 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8030 rel = next_rel;
8031 else
8032 while (1)
8033 {
8034 if (!dec_dynrel_count (rel->r_info, sec, info,
8035 NULL, h, sym))
8036 goto error_ret;
8037
8038 if (++rel == next_rel)
8039 break;
8040
8041 r_symndx = ELF64_R_SYM (rel->r_info);
8042 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8043 r_symndx, ibfd))
8044 goto error_ret;
8045 }
8046 }
8047 else
8048 {
8049 /* We'll be keeping this opd entry. */
8050 long adjust;
8051
8052 if (fdh != NULL)
8053 {
8054 /* Redefine the function descriptor symbol to
8055 this location in the opd section. It is
8056 necessary to update the value here rather
8057 than using an array of adjustments as we do
8058 for local symbols, because various places
8059 in the generic ELF code use the value
8060 stored in u.def.value. */
8061 fdh->elf.root.u.def.value = wptr - new_contents;
8062 fdh->adjust_done = 1;
8063 }
8064
8065 /* Local syms are a bit tricky. We could
8066 tweak them as they can be cached, but
8067 we'd need to look through the local syms
8068 for the function descriptor sym which we
8069 don't have at the moment. So keep an
8070 array of adjustments. */
8071 adjust = (wptr - new_contents) - (rptr - sec->contents);
8072 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8073
8074 if (wptr != rptr)
8075 memcpy (wptr, rptr, opd_ent_size);
8076 wptr += opd_ent_size;
8077 if (add_aux_fields && opd_ent_size == 16)
8078 {
8079 memset (wptr, '\0', 8);
8080 wptr += 8;
8081 }
8082
8083 /* We need to adjust any reloc offsets to point to the
8084 new opd entries. */
8085 for ( ; rel != next_rel; ++rel)
8086 {
8087 rel->r_offset += adjust;
8088 if (write_rel != rel)
8089 memcpy (write_rel, rel, sizeof (*rel));
8090 ++write_rel;
8091 }
8092 }
8093
8094 rptr += opd_ent_size;
8095 }
8096
8097 sec->size = wptr - new_contents;
8098 sec->reloc_count = write_rel - relstart;
8099 if (add_aux_fields)
8100 {
8101 free (sec->contents);
8102 sec->contents = new_contents;
8103 }
8104
8105 /* Fudge the header size too, as this is used later in
8106 elf_bfd_final_link if we are emitting relocs. */
8107 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8108 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8109 some_edited = TRUE;
8110 }
8111 else if (elf_section_data (sec)->relocs != relstart)
8112 free (relstart);
8113
8114 if (local_syms != NULL
8115 && symtab_hdr->contents != (unsigned char *) local_syms)
8116 {
8117 if (!info->keep_memory)
8118 free (local_syms);
8119 else
8120 symtab_hdr->contents = (unsigned char *) local_syms;
8121 }
8122 }
8123
8124 if (some_edited)
8125 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8126
8127 /* If we are doing a final link and the last .opd entry is just 16 byte
8128 long, add a 8 byte padding after it. */
8129 if (need_pad != NULL && !bfd_link_relocatable (info))
8130 {
8131 bfd_byte *p;
8132
8133 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8134 {
8135 BFD_ASSERT (need_pad->size > 0);
8136
8137 p = bfd_malloc (need_pad->size + 8);
8138 if (p == NULL)
8139 return FALSE;
8140
8141 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8142 p, 0, need_pad->size))
8143 return FALSE;
8144
8145 need_pad->contents = p;
8146 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8147 }
8148 else
8149 {
8150 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8151 if (p == NULL)
8152 return FALSE;
8153
8154 need_pad->contents = p;
8155 }
8156
8157 memset (need_pad->contents + need_pad->size, 0, 8);
8158 need_pad->size += 8;
8159 }
8160
8161 return TRUE;
8162 }
8163
8164 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8165
8166 asection *
8167 ppc64_elf_tls_setup (struct bfd_link_info *info)
8168 {
8169 struct ppc_link_hash_table *htab;
8170
8171 htab = ppc_hash_table (info);
8172 if (htab == NULL)
8173 return NULL;
8174
8175 if (abiversion (info->output_bfd) == 1)
8176 htab->opd_abi = 1;
8177
8178 if (htab->params->no_multi_toc)
8179 htab->do_multi_toc = 0;
8180 else if (!htab->do_multi_toc)
8181 htab->params->no_multi_toc = 1;
8182
8183 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8184 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8185 FALSE, FALSE, TRUE));
8186 /* Move dynamic linking info to the function descriptor sym. */
8187 if (htab->tls_get_addr != NULL)
8188 func_desc_adjust (&htab->tls_get_addr->elf, info);
8189 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8190 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8191 FALSE, FALSE, TRUE));
8192 if (htab->params->tls_get_addr_opt)
8193 {
8194 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8195
8196 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8197 FALSE, FALSE, TRUE);
8198 if (opt != NULL)
8199 func_desc_adjust (opt, info);
8200 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8201 FALSE, FALSE, TRUE);
8202 if (opt_fd != NULL
8203 && (opt_fd->root.type == bfd_link_hash_defined
8204 || opt_fd->root.type == bfd_link_hash_defweak))
8205 {
8206 /* If glibc supports an optimized __tls_get_addr call stub,
8207 signalled by the presence of __tls_get_addr_opt, and we'll
8208 be calling __tls_get_addr via a plt call stub, then
8209 make __tls_get_addr point to __tls_get_addr_opt. */
8210 tga_fd = &htab->tls_get_addr_fd->elf;
8211 if (htab->elf.dynamic_sections_created
8212 && tga_fd != NULL
8213 && (tga_fd->type == STT_FUNC
8214 || tga_fd->needs_plt)
8215 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8216 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8217 && tga_fd->root.type == bfd_link_hash_undefweak)))
8218 {
8219 struct plt_entry *ent;
8220
8221 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8222 if (ent->plt.refcount > 0)
8223 break;
8224 if (ent != NULL)
8225 {
8226 tga_fd->root.type = bfd_link_hash_indirect;
8227 tga_fd->root.u.i.link = &opt_fd->root;
8228 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8229 opt_fd->forced_local = 0;
8230 if (opt_fd->dynindx != -1)
8231 {
8232 /* Use __tls_get_addr_opt in dynamic relocations. */
8233 opt_fd->dynindx = -1;
8234 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8235 opt_fd->dynstr_index);
8236 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8237 return NULL;
8238 }
8239 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8240 tga = &htab->tls_get_addr->elf;
8241 if (opt != NULL && tga != NULL)
8242 {
8243 tga->root.type = bfd_link_hash_indirect;
8244 tga->root.u.i.link = &opt->root;
8245 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8246 opt->forced_local = 0;
8247 _bfd_elf_link_hash_hide_symbol (info, opt,
8248 tga->forced_local);
8249 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8250 }
8251 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8252 htab->tls_get_addr_fd->is_func_descriptor = 1;
8253 if (htab->tls_get_addr != NULL)
8254 {
8255 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8256 htab->tls_get_addr->is_func = 1;
8257 }
8258 }
8259 }
8260 }
8261 else if (htab->params->tls_get_addr_opt < 0)
8262 htab->params->tls_get_addr_opt = 0;
8263 }
8264 return _bfd_elf_tls_setup (info->output_bfd, info);
8265 }
8266
8267 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8268 HASH1 or HASH2. */
8269
8270 static bfd_boolean
8271 branch_reloc_hash_match (const bfd *ibfd,
8272 const Elf_Internal_Rela *rel,
8273 const struct ppc_link_hash_entry *hash1,
8274 const struct ppc_link_hash_entry *hash2)
8275 {
8276 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8277 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8278 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8279
8280 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8281 {
8282 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8283 struct elf_link_hash_entry *h;
8284
8285 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8286 h = elf_follow_link (h);
8287 if (h == &hash1->elf || h == &hash2->elf)
8288 return TRUE;
8289 }
8290 return FALSE;
8291 }
8292
8293 /* Run through all the TLS relocs looking for optimization
8294 opportunities. The linker has been hacked (see ppc64elf.em) to do
8295 a preliminary section layout so that we know the TLS segment
8296 offsets. We can't optimize earlier because some optimizations need
8297 to know the tp offset, and we need to optimize before allocating
8298 dynamic relocations. */
8299
8300 bfd_boolean
8301 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8302 {
8303 bfd *ibfd;
8304 asection *sec;
8305 struct ppc_link_hash_table *htab;
8306 unsigned char *toc_ref;
8307 int pass;
8308
8309 if (!bfd_link_executable (info))
8310 return TRUE;
8311
8312 htab = ppc_hash_table (info);
8313 if (htab == NULL)
8314 return FALSE;
8315
8316 /* Make two passes over the relocs. On the first pass, mark toc
8317 entries involved with tls relocs, and check that tls relocs
8318 involved in setting up a tls_get_addr call are indeed followed by
8319 such a call. If they are not, we can't do any tls optimization.
8320 On the second pass twiddle tls_mask flags to notify
8321 relocate_section that optimization can be done, and adjust got
8322 and plt refcounts. */
8323 toc_ref = NULL;
8324 for (pass = 0; pass < 2; ++pass)
8325 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8326 {
8327 Elf_Internal_Sym *locsyms = NULL;
8328 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8329
8330 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8331 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8332 {
8333 Elf_Internal_Rela *relstart, *rel, *relend;
8334 bfd_boolean found_tls_get_addr_arg = 0;
8335
8336 /* Read the relocations. */
8337 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8338 info->keep_memory);
8339 if (relstart == NULL)
8340 {
8341 free (toc_ref);
8342 return FALSE;
8343 }
8344
8345 relend = relstart + sec->reloc_count;
8346 for (rel = relstart; rel < relend; rel++)
8347 {
8348 enum elf_ppc64_reloc_type r_type;
8349 unsigned long r_symndx;
8350 struct elf_link_hash_entry *h;
8351 Elf_Internal_Sym *sym;
8352 asection *sym_sec;
8353 unsigned char *tls_mask;
8354 unsigned char tls_set, tls_clear, tls_type = 0;
8355 bfd_vma value;
8356 bfd_boolean ok_tprel, is_local;
8357 long toc_ref_index = 0;
8358 int expecting_tls_get_addr = 0;
8359 bfd_boolean ret = FALSE;
8360
8361 r_symndx = ELF64_R_SYM (rel->r_info);
8362 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8363 r_symndx, ibfd))
8364 {
8365 err_free_rel:
8366 if (elf_section_data (sec)->relocs != relstart)
8367 free (relstart);
8368 if (toc_ref != NULL)
8369 free (toc_ref);
8370 if (locsyms != NULL
8371 && (elf_symtab_hdr (ibfd).contents
8372 != (unsigned char *) locsyms))
8373 free (locsyms);
8374 return ret;
8375 }
8376
8377 if (h != NULL)
8378 {
8379 if (h->root.type == bfd_link_hash_defined
8380 || h->root.type == bfd_link_hash_defweak)
8381 value = h->root.u.def.value;
8382 else if (h->root.type == bfd_link_hash_undefweak)
8383 value = 0;
8384 else
8385 {
8386 found_tls_get_addr_arg = 0;
8387 continue;
8388 }
8389 }
8390 else
8391 /* Symbols referenced by TLS relocs must be of type
8392 STT_TLS. So no need for .opd local sym adjust. */
8393 value = sym->st_value;
8394
8395 ok_tprel = FALSE;
8396 is_local = FALSE;
8397 if (h == NULL
8398 || !h->def_dynamic)
8399 {
8400 is_local = TRUE;
8401 if (h != NULL
8402 && h->root.type == bfd_link_hash_undefweak)
8403 ok_tprel = TRUE;
8404 else if (sym_sec != NULL
8405 && sym_sec->output_section != NULL)
8406 {
8407 value += sym_sec->output_offset;
8408 value += sym_sec->output_section->vma;
8409 value -= htab->elf.tls_sec->vma;
8410 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8411 < (bfd_vma) 1 << 32);
8412 }
8413 }
8414
8415 r_type = ELF64_R_TYPE (rel->r_info);
8416 /* If this section has old-style __tls_get_addr calls
8417 without marker relocs, then check that each
8418 __tls_get_addr call reloc is preceded by a reloc
8419 that conceivably belongs to the __tls_get_addr arg
8420 setup insn. If we don't find matching arg setup
8421 relocs, don't do any tls optimization. */
8422 if (pass == 0
8423 && sec->has_tls_get_addr_call
8424 && h != NULL
8425 && (h == &htab->tls_get_addr->elf
8426 || h == &htab->tls_get_addr_fd->elf)
8427 && !found_tls_get_addr_arg
8428 && is_branch_reloc (r_type))
8429 {
8430 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8431 "TLS optimization disabled\n"),
8432 ibfd, sec, rel->r_offset);
8433 ret = TRUE;
8434 goto err_free_rel;
8435 }
8436
8437 found_tls_get_addr_arg = 0;
8438 switch (r_type)
8439 {
8440 case R_PPC64_GOT_TLSLD16:
8441 case R_PPC64_GOT_TLSLD16_LO:
8442 expecting_tls_get_addr = 1;
8443 found_tls_get_addr_arg = 1;
8444 /* Fall thru */
8445
8446 case R_PPC64_GOT_TLSLD16_HI:
8447 case R_PPC64_GOT_TLSLD16_HA:
8448 /* These relocs should never be against a symbol
8449 defined in a shared lib. Leave them alone if
8450 that turns out to be the case. */
8451 if (!is_local)
8452 continue;
8453
8454 /* LD -> LE */
8455 tls_set = 0;
8456 tls_clear = TLS_LD;
8457 tls_type = TLS_TLS | TLS_LD;
8458 break;
8459
8460 case R_PPC64_GOT_TLSGD16:
8461 case R_PPC64_GOT_TLSGD16_LO:
8462 expecting_tls_get_addr = 1;
8463 found_tls_get_addr_arg = 1;
8464 /* Fall thru */
8465
8466 case R_PPC64_GOT_TLSGD16_HI:
8467 case R_PPC64_GOT_TLSGD16_HA:
8468 if (ok_tprel)
8469 /* GD -> LE */
8470 tls_set = 0;
8471 else
8472 /* GD -> IE */
8473 tls_set = TLS_TLS | TLS_TPRELGD;
8474 tls_clear = TLS_GD;
8475 tls_type = TLS_TLS | TLS_GD;
8476 break;
8477
8478 case R_PPC64_GOT_TPREL16_DS:
8479 case R_PPC64_GOT_TPREL16_LO_DS:
8480 case R_PPC64_GOT_TPREL16_HI:
8481 case R_PPC64_GOT_TPREL16_HA:
8482 if (ok_tprel)
8483 {
8484 /* IE -> LE */
8485 tls_set = 0;
8486 tls_clear = TLS_TPREL;
8487 tls_type = TLS_TLS | TLS_TPREL;
8488 break;
8489 }
8490 continue;
8491
8492 case R_PPC64_TLSGD:
8493 case R_PPC64_TLSLD:
8494 found_tls_get_addr_arg = 1;
8495 /* Fall thru */
8496
8497 case R_PPC64_TLS:
8498 case R_PPC64_TOC16:
8499 case R_PPC64_TOC16_LO:
8500 if (sym_sec == NULL || sym_sec != toc)
8501 continue;
8502
8503 /* Mark this toc entry as referenced by a TLS
8504 code sequence. We can do that now in the
8505 case of R_PPC64_TLS, and after checking for
8506 tls_get_addr for the TOC16 relocs. */
8507 if (toc_ref == NULL)
8508 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8509 if (toc_ref == NULL)
8510 goto err_free_rel;
8511
8512 if (h != NULL)
8513 value = h->root.u.def.value;
8514 else
8515 value = sym->st_value;
8516 value += rel->r_addend;
8517 if (value % 8 != 0)
8518 continue;
8519 BFD_ASSERT (value < toc->size
8520 && toc->output_offset % 8 == 0);
8521 toc_ref_index = (value + toc->output_offset) / 8;
8522 if (r_type == R_PPC64_TLS
8523 || r_type == R_PPC64_TLSGD
8524 || r_type == R_PPC64_TLSLD)
8525 {
8526 toc_ref[toc_ref_index] = 1;
8527 continue;
8528 }
8529
8530 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8531 continue;
8532
8533 tls_set = 0;
8534 tls_clear = 0;
8535 expecting_tls_get_addr = 2;
8536 break;
8537
8538 case R_PPC64_TPREL64:
8539 if (pass == 0
8540 || sec != toc
8541 || toc_ref == NULL
8542 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8543 continue;
8544 if (ok_tprel)
8545 {
8546 /* IE -> LE */
8547 tls_set = TLS_EXPLICIT;
8548 tls_clear = TLS_TPREL;
8549 break;
8550 }
8551 continue;
8552
8553 case R_PPC64_DTPMOD64:
8554 if (pass == 0
8555 || sec != toc
8556 || toc_ref == NULL
8557 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8558 continue;
8559 if (rel + 1 < relend
8560 && (rel[1].r_info
8561 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8562 && rel[1].r_offset == rel->r_offset + 8)
8563 {
8564 if (ok_tprel)
8565 /* GD -> LE */
8566 tls_set = TLS_EXPLICIT | TLS_GD;
8567 else
8568 /* GD -> IE */
8569 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8570 tls_clear = TLS_GD;
8571 }
8572 else
8573 {
8574 if (!is_local)
8575 continue;
8576
8577 /* LD -> LE */
8578 tls_set = TLS_EXPLICIT;
8579 tls_clear = TLS_LD;
8580 }
8581 break;
8582
8583 default:
8584 continue;
8585 }
8586
8587 if (pass == 0)
8588 {
8589 if (!expecting_tls_get_addr
8590 || !sec->has_tls_get_addr_call)
8591 continue;
8592
8593 if (rel + 1 < relend
8594 && branch_reloc_hash_match (ibfd, rel + 1,
8595 htab->tls_get_addr,
8596 htab->tls_get_addr_fd))
8597 {
8598 if (expecting_tls_get_addr == 2)
8599 {
8600 /* Check for toc tls entries. */
8601 unsigned char *toc_tls;
8602 int retval;
8603
8604 retval = get_tls_mask (&toc_tls, NULL, NULL,
8605 &locsyms,
8606 rel, ibfd);
8607 if (retval == 0)
8608 goto err_free_rel;
8609 if (toc_tls != NULL)
8610 {
8611 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8612 found_tls_get_addr_arg = 1;
8613 if (retval > 1)
8614 toc_ref[toc_ref_index] = 1;
8615 }
8616 }
8617 continue;
8618 }
8619
8620 if (expecting_tls_get_addr != 1)
8621 continue;
8622
8623 /* Uh oh, we didn't find the expected call. We
8624 could just mark this symbol to exclude it
8625 from tls optimization but it's safer to skip
8626 the entire optimization. */
8627 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8628 "TLS optimization disabled\n"),
8629 ibfd, sec, rel->r_offset);
8630 ret = TRUE;
8631 goto err_free_rel;
8632 }
8633
8634 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8635 {
8636 struct plt_entry *ent;
8637 for (ent = htab->tls_get_addr->elf.plt.plist;
8638 ent != NULL;
8639 ent = ent->next)
8640 if (ent->addend == 0)
8641 {
8642 if (ent->plt.refcount > 0)
8643 {
8644 ent->plt.refcount -= 1;
8645 expecting_tls_get_addr = 0;
8646 }
8647 break;
8648 }
8649 }
8650
8651 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8652 {
8653 struct plt_entry *ent;
8654 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8655 ent != NULL;
8656 ent = ent->next)
8657 if (ent->addend == 0)
8658 {
8659 if (ent->plt.refcount > 0)
8660 ent->plt.refcount -= 1;
8661 break;
8662 }
8663 }
8664
8665 if (tls_clear == 0)
8666 continue;
8667
8668 if ((tls_set & TLS_EXPLICIT) == 0)
8669 {
8670 struct got_entry *ent;
8671
8672 /* Adjust got entry for this reloc. */
8673 if (h != NULL)
8674 ent = h->got.glist;
8675 else
8676 ent = elf_local_got_ents (ibfd)[r_symndx];
8677
8678 for (; ent != NULL; ent = ent->next)
8679 if (ent->addend == rel->r_addend
8680 && ent->owner == ibfd
8681 && ent->tls_type == tls_type)
8682 break;
8683 if (ent == NULL)
8684 abort ();
8685
8686 if (tls_set == 0)
8687 {
8688 /* We managed to get rid of a got entry. */
8689 if (ent->got.refcount > 0)
8690 ent->got.refcount -= 1;
8691 }
8692 }
8693 else
8694 {
8695 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8696 we'll lose one or two dyn relocs. */
8697 if (!dec_dynrel_count (rel->r_info, sec, info,
8698 NULL, h, sym))
8699 return FALSE;
8700
8701 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8702 {
8703 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8704 NULL, h, sym))
8705 return FALSE;
8706 }
8707 }
8708
8709 *tls_mask |= tls_set;
8710 *tls_mask &= ~tls_clear;
8711 }
8712
8713 if (elf_section_data (sec)->relocs != relstart)
8714 free (relstart);
8715 }
8716
8717 if (locsyms != NULL
8718 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8719 {
8720 if (!info->keep_memory)
8721 free (locsyms);
8722 else
8723 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8724 }
8725 }
8726
8727 if (toc_ref != NULL)
8728 free (toc_ref);
8729 return TRUE;
8730 }
8731
8732 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8733 the values of any global symbols in a toc section that has been
8734 edited. Globals in toc sections should be a rarity, so this function
8735 sets a flag if any are found in toc sections other than the one just
8736 edited, so that futher hash table traversals can be avoided. */
8737
8738 struct adjust_toc_info
8739 {
8740 asection *toc;
8741 unsigned long *skip;
8742 bfd_boolean global_toc_syms;
8743 };
8744
8745 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8746
8747 static bfd_boolean
8748 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8749 {
8750 struct ppc_link_hash_entry *eh;
8751 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8752 unsigned long i;
8753
8754 if (h->root.type != bfd_link_hash_defined
8755 && h->root.type != bfd_link_hash_defweak)
8756 return TRUE;
8757
8758 eh = (struct ppc_link_hash_entry *) h;
8759 if (eh->adjust_done)
8760 return TRUE;
8761
8762 if (eh->elf.root.u.def.section == toc_inf->toc)
8763 {
8764 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8765 i = toc_inf->toc->rawsize >> 3;
8766 else
8767 i = eh->elf.root.u.def.value >> 3;
8768
8769 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8770 {
8771 (*_bfd_error_handler)
8772 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8773 do
8774 ++i;
8775 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8776 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8777 }
8778
8779 eh->elf.root.u.def.value -= toc_inf->skip[i];
8780 eh->adjust_done = 1;
8781 }
8782 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8783 toc_inf->global_toc_syms = TRUE;
8784
8785 return TRUE;
8786 }
8787
8788 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8789
8790 static bfd_boolean
8791 ok_lo_toc_insn (unsigned int insn)
8792 {
8793 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8794 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8795 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8796 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8797 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8798 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8799 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8800 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8801 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8802 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8803 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8804 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8805 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8806 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8807 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8808 && (insn & 3) != 1)
8809 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8810 && ((insn & 3) == 0 || (insn & 3) == 3))
8811 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8812 }
8813
8814 /* Examine all relocs referencing .toc sections in order to remove
8815 unused .toc entries. */
8816
8817 bfd_boolean
8818 ppc64_elf_edit_toc (struct bfd_link_info *info)
8819 {
8820 bfd *ibfd;
8821 struct adjust_toc_info toc_inf;
8822 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8823
8824 htab->do_toc_opt = 1;
8825 toc_inf.global_toc_syms = TRUE;
8826 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8827 {
8828 asection *toc, *sec;
8829 Elf_Internal_Shdr *symtab_hdr;
8830 Elf_Internal_Sym *local_syms;
8831 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8832 unsigned long *skip, *drop;
8833 unsigned char *used;
8834 unsigned char *keep, last, some_unused;
8835
8836 if (!is_ppc64_elf (ibfd))
8837 continue;
8838
8839 toc = bfd_get_section_by_name (ibfd, ".toc");
8840 if (toc == NULL
8841 || toc->size == 0
8842 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8843 || discarded_section (toc))
8844 continue;
8845
8846 toc_relocs = NULL;
8847 local_syms = NULL;
8848 symtab_hdr = &elf_symtab_hdr (ibfd);
8849
8850 /* Look at sections dropped from the final link. */
8851 skip = NULL;
8852 relstart = NULL;
8853 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8854 {
8855 if (sec->reloc_count == 0
8856 || !discarded_section (sec)
8857 || get_opd_info (sec)
8858 || (sec->flags & SEC_ALLOC) == 0
8859 || (sec->flags & SEC_DEBUGGING) != 0)
8860 continue;
8861
8862 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8863 if (relstart == NULL)
8864 goto error_ret;
8865
8866 /* Run through the relocs to see which toc entries might be
8867 unused. */
8868 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8869 {
8870 enum elf_ppc64_reloc_type r_type;
8871 unsigned long r_symndx;
8872 asection *sym_sec;
8873 struct elf_link_hash_entry *h;
8874 Elf_Internal_Sym *sym;
8875 bfd_vma val;
8876
8877 r_type = ELF64_R_TYPE (rel->r_info);
8878 switch (r_type)
8879 {
8880 default:
8881 continue;
8882
8883 case R_PPC64_TOC16:
8884 case R_PPC64_TOC16_LO:
8885 case R_PPC64_TOC16_HI:
8886 case R_PPC64_TOC16_HA:
8887 case R_PPC64_TOC16_DS:
8888 case R_PPC64_TOC16_LO_DS:
8889 break;
8890 }
8891
8892 r_symndx = ELF64_R_SYM (rel->r_info);
8893 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8894 r_symndx, ibfd))
8895 goto error_ret;
8896
8897 if (sym_sec != toc)
8898 continue;
8899
8900 if (h != NULL)
8901 val = h->root.u.def.value;
8902 else
8903 val = sym->st_value;
8904 val += rel->r_addend;
8905
8906 if (val >= toc->size)
8907 continue;
8908
8909 /* Anything in the toc ought to be aligned to 8 bytes.
8910 If not, don't mark as unused. */
8911 if (val & 7)
8912 continue;
8913
8914 if (skip == NULL)
8915 {
8916 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8917 if (skip == NULL)
8918 goto error_ret;
8919 }
8920
8921 skip[val >> 3] = ref_from_discarded;
8922 }
8923
8924 if (elf_section_data (sec)->relocs != relstart)
8925 free (relstart);
8926 }
8927
8928 /* For largetoc loads of address constants, we can convert
8929 . addis rx,2,addr@got@ha
8930 . ld ry,addr@got@l(rx)
8931 to
8932 . addis rx,2,addr@toc@ha
8933 . addi ry,rx,addr@toc@l
8934 when addr is within 2G of the toc pointer. This then means
8935 that the word storing "addr" in the toc is no longer needed. */
8936
8937 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8938 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8939 && toc->reloc_count != 0)
8940 {
8941 /* Read toc relocs. */
8942 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8943 info->keep_memory);
8944 if (toc_relocs == NULL)
8945 goto error_ret;
8946
8947 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8948 {
8949 enum elf_ppc64_reloc_type r_type;
8950 unsigned long r_symndx;
8951 asection *sym_sec;
8952 struct elf_link_hash_entry *h;
8953 Elf_Internal_Sym *sym;
8954 bfd_vma val, addr;
8955
8956 r_type = ELF64_R_TYPE (rel->r_info);
8957 if (r_type != R_PPC64_ADDR64)
8958 continue;
8959
8960 r_symndx = ELF64_R_SYM (rel->r_info);
8961 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8962 r_symndx, ibfd))
8963 goto error_ret;
8964
8965 if (sym_sec == NULL
8966 || sym_sec->output_section == NULL
8967 || discarded_section (sym_sec))
8968 continue;
8969
8970 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8971 continue;
8972
8973 if (h != NULL)
8974 {
8975 if (h->type == STT_GNU_IFUNC)
8976 continue;
8977 val = h->root.u.def.value;
8978 }
8979 else
8980 {
8981 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8982 continue;
8983 val = sym->st_value;
8984 }
8985 val += rel->r_addend;
8986 val += sym_sec->output_section->vma + sym_sec->output_offset;
8987
8988 /* We don't yet know the exact toc pointer value, but we
8989 know it will be somewhere in the toc section. Don't
8990 optimize if the difference from any possible toc
8991 pointer is outside [ff..f80008000, 7fff7fff]. */
8992 addr = toc->output_section->vma + TOC_BASE_OFF;
8993 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8994 continue;
8995
8996 addr = toc->output_section->vma + toc->output_section->rawsize;
8997 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8998 continue;
8999
9000 if (skip == NULL)
9001 {
9002 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9003 if (skip == NULL)
9004 goto error_ret;
9005 }
9006
9007 skip[rel->r_offset >> 3]
9008 |= can_optimize | ((rel - toc_relocs) << 2);
9009 }
9010 }
9011
9012 if (skip == NULL)
9013 continue;
9014
9015 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9016 if (used == NULL)
9017 {
9018 error_ret:
9019 if (local_syms != NULL
9020 && symtab_hdr->contents != (unsigned char *) local_syms)
9021 free (local_syms);
9022 if (sec != NULL
9023 && relstart != NULL
9024 && elf_section_data (sec)->relocs != relstart)
9025 free (relstart);
9026 if (toc_relocs != NULL
9027 && elf_section_data (toc)->relocs != toc_relocs)
9028 free (toc_relocs);
9029 if (skip != NULL)
9030 free (skip);
9031 return FALSE;
9032 }
9033
9034 /* Now check all kept sections that might reference the toc.
9035 Check the toc itself last. */
9036 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9037 : ibfd->sections);
9038 sec != NULL;
9039 sec = (sec == toc ? NULL
9040 : sec->next == NULL ? toc
9041 : sec->next == toc && toc->next ? toc->next
9042 : sec->next))
9043 {
9044 int repeat;
9045
9046 if (sec->reloc_count == 0
9047 || discarded_section (sec)
9048 || get_opd_info (sec)
9049 || (sec->flags & SEC_ALLOC) == 0
9050 || (sec->flags & SEC_DEBUGGING) != 0)
9051 continue;
9052
9053 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9054 info->keep_memory);
9055 if (relstart == NULL)
9056 {
9057 free (used);
9058 goto error_ret;
9059 }
9060
9061 /* Mark toc entries referenced as used. */
9062 do
9063 {
9064 repeat = 0;
9065 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9066 {
9067 enum elf_ppc64_reloc_type r_type;
9068 unsigned long r_symndx;
9069 asection *sym_sec;
9070 struct elf_link_hash_entry *h;
9071 Elf_Internal_Sym *sym;
9072 bfd_vma val;
9073 enum {no_check, check_lo, check_ha} insn_check;
9074
9075 r_type = ELF64_R_TYPE (rel->r_info);
9076 switch (r_type)
9077 {
9078 default:
9079 insn_check = no_check;
9080 break;
9081
9082 case R_PPC64_GOT_TLSLD16_HA:
9083 case R_PPC64_GOT_TLSGD16_HA:
9084 case R_PPC64_GOT_TPREL16_HA:
9085 case R_PPC64_GOT_DTPREL16_HA:
9086 case R_PPC64_GOT16_HA:
9087 case R_PPC64_TOC16_HA:
9088 insn_check = check_ha;
9089 break;
9090
9091 case R_PPC64_GOT_TLSLD16_LO:
9092 case R_PPC64_GOT_TLSGD16_LO:
9093 case R_PPC64_GOT_TPREL16_LO_DS:
9094 case R_PPC64_GOT_DTPREL16_LO_DS:
9095 case R_PPC64_GOT16_LO:
9096 case R_PPC64_GOT16_LO_DS:
9097 case R_PPC64_TOC16_LO:
9098 case R_PPC64_TOC16_LO_DS:
9099 insn_check = check_lo;
9100 break;
9101 }
9102
9103 if (insn_check != no_check)
9104 {
9105 bfd_vma off = rel->r_offset & ~3;
9106 unsigned char buf[4];
9107 unsigned int insn;
9108
9109 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9110 {
9111 free (used);
9112 goto error_ret;
9113 }
9114 insn = bfd_get_32 (ibfd, buf);
9115 if (insn_check == check_lo
9116 ? !ok_lo_toc_insn (insn)
9117 : ((insn & ((0x3f << 26) | 0x1f << 16))
9118 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9119 {
9120 char str[12];
9121
9122 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9123 sprintf (str, "%#08x", insn);
9124 info->callbacks->einfo
9125 (_("%P: %H: toc optimization is not supported for"
9126 " %s instruction.\n"),
9127 ibfd, sec, rel->r_offset & ~3, str);
9128 }
9129 }
9130
9131 switch (r_type)
9132 {
9133 case R_PPC64_TOC16:
9134 case R_PPC64_TOC16_LO:
9135 case R_PPC64_TOC16_HI:
9136 case R_PPC64_TOC16_HA:
9137 case R_PPC64_TOC16_DS:
9138 case R_PPC64_TOC16_LO_DS:
9139 /* In case we're taking addresses of toc entries. */
9140 case R_PPC64_ADDR64:
9141 break;
9142
9143 default:
9144 continue;
9145 }
9146
9147 r_symndx = ELF64_R_SYM (rel->r_info);
9148 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9149 r_symndx, ibfd))
9150 {
9151 free (used);
9152 goto error_ret;
9153 }
9154
9155 if (sym_sec != toc)
9156 continue;
9157
9158 if (h != NULL)
9159 val = h->root.u.def.value;
9160 else
9161 val = sym->st_value;
9162 val += rel->r_addend;
9163
9164 if (val >= toc->size)
9165 continue;
9166
9167 if ((skip[val >> 3] & can_optimize) != 0)
9168 {
9169 bfd_vma off;
9170 unsigned char opc;
9171
9172 switch (r_type)
9173 {
9174 case R_PPC64_TOC16_HA:
9175 break;
9176
9177 case R_PPC64_TOC16_LO_DS:
9178 off = rel->r_offset;
9179 off += (bfd_big_endian (ibfd) ? -2 : 3);
9180 if (!bfd_get_section_contents (ibfd, sec, &opc,
9181 off, 1))
9182 {
9183 free (used);
9184 goto error_ret;
9185 }
9186 if ((opc & (0x3f << 2)) == (58u << 2))
9187 break;
9188 /* Fall thru */
9189
9190 default:
9191 /* Wrong sort of reloc, or not a ld. We may
9192 as well clear ref_from_discarded too. */
9193 skip[val >> 3] = 0;
9194 }
9195 }
9196
9197 if (sec != toc)
9198 used[val >> 3] = 1;
9199 /* For the toc section, we only mark as used if this
9200 entry itself isn't unused. */
9201 else if ((used[rel->r_offset >> 3]
9202 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9203 && !used[val >> 3])
9204 {
9205 /* Do all the relocs again, to catch reference
9206 chains. */
9207 repeat = 1;
9208 used[val >> 3] = 1;
9209 }
9210 }
9211 }
9212 while (repeat);
9213
9214 if (elf_section_data (sec)->relocs != relstart)
9215 free (relstart);
9216 }
9217
9218 /* Merge the used and skip arrays. Assume that TOC
9219 doublewords not appearing as either used or unused belong
9220 to to an entry more than one doubleword in size. */
9221 for (drop = skip, keep = used, last = 0, some_unused = 0;
9222 drop < skip + (toc->size + 7) / 8;
9223 ++drop, ++keep)
9224 {
9225 if (*keep)
9226 {
9227 *drop &= ~ref_from_discarded;
9228 if ((*drop & can_optimize) != 0)
9229 some_unused = 1;
9230 last = 0;
9231 }
9232 else if ((*drop & ref_from_discarded) != 0)
9233 {
9234 some_unused = 1;
9235 last = ref_from_discarded;
9236 }
9237 else
9238 *drop = last;
9239 }
9240
9241 free (used);
9242
9243 if (some_unused)
9244 {
9245 bfd_byte *contents, *src;
9246 unsigned long off;
9247 Elf_Internal_Sym *sym;
9248 bfd_boolean local_toc_syms = FALSE;
9249
9250 /* Shuffle the toc contents, and at the same time convert the
9251 skip array from booleans into offsets. */
9252 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9253 goto error_ret;
9254
9255 elf_section_data (toc)->this_hdr.contents = contents;
9256
9257 for (src = contents, off = 0, drop = skip;
9258 src < contents + toc->size;
9259 src += 8, ++drop)
9260 {
9261 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9262 off += 8;
9263 else if (off != 0)
9264 {
9265 *drop = off;
9266 memcpy (src - off, src, 8);
9267 }
9268 }
9269 *drop = off;
9270 toc->rawsize = toc->size;
9271 toc->size = src - contents - off;
9272
9273 /* Adjust addends for relocs against the toc section sym,
9274 and optimize any accesses we can. */
9275 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9276 {
9277 if (sec->reloc_count == 0
9278 || discarded_section (sec))
9279 continue;
9280
9281 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9282 info->keep_memory);
9283 if (relstart == NULL)
9284 goto error_ret;
9285
9286 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9287 {
9288 enum elf_ppc64_reloc_type r_type;
9289 unsigned long r_symndx;
9290 asection *sym_sec;
9291 struct elf_link_hash_entry *h;
9292 bfd_vma val;
9293
9294 r_type = ELF64_R_TYPE (rel->r_info);
9295 switch (r_type)
9296 {
9297 default:
9298 continue;
9299
9300 case R_PPC64_TOC16:
9301 case R_PPC64_TOC16_LO:
9302 case R_PPC64_TOC16_HI:
9303 case R_PPC64_TOC16_HA:
9304 case R_PPC64_TOC16_DS:
9305 case R_PPC64_TOC16_LO_DS:
9306 case R_PPC64_ADDR64:
9307 break;
9308 }
9309
9310 r_symndx = ELF64_R_SYM (rel->r_info);
9311 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9312 r_symndx, ibfd))
9313 goto error_ret;
9314
9315 if (sym_sec != toc)
9316 continue;
9317
9318 if (h != NULL)
9319 val = h->root.u.def.value;
9320 else
9321 {
9322 val = sym->st_value;
9323 if (val != 0)
9324 local_toc_syms = TRUE;
9325 }
9326
9327 val += rel->r_addend;
9328
9329 if (val > toc->rawsize)
9330 val = toc->rawsize;
9331 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9332 continue;
9333 else if ((skip[val >> 3] & can_optimize) != 0)
9334 {
9335 Elf_Internal_Rela *tocrel
9336 = toc_relocs + (skip[val >> 3] >> 2);
9337 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9338
9339 switch (r_type)
9340 {
9341 case R_PPC64_TOC16_HA:
9342 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9343 break;
9344
9345 case R_PPC64_TOC16_LO_DS:
9346 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9347 break;
9348
9349 default:
9350 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9351 ppc_howto_init ();
9352 info->callbacks->einfo
9353 (_("%P: %H: %s references "
9354 "optimized away TOC entry\n"),
9355 ibfd, sec, rel->r_offset,
9356 ppc64_elf_howto_table[r_type]->name);
9357 bfd_set_error (bfd_error_bad_value);
9358 goto error_ret;
9359 }
9360 rel->r_addend = tocrel->r_addend;
9361 elf_section_data (sec)->relocs = relstart;
9362 continue;
9363 }
9364
9365 if (h != NULL || sym->st_value != 0)
9366 continue;
9367
9368 rel->r_addend -= skip[val >> 3];
9369 elf_section_data (sec)->relocs = relstart;
9370 }
9371
9372 if (elf_section_data (sec)->relocs != relstart)
9373 free (relstart);
9374 }
9375
9376 /* We shouldn't have local or global symbols defined in the TOC,
9377 but handle them anyway. */
9378 if (local_syms != NULL)
9379 for (sym = local_syms;
9380 sym < local_syms + symtab_hdr->sh_info;
9381 ++sym)
9382 if (sym->st_value != 0
9383 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9384 {
9385 unsigned long i;
9386
9387 if (sym->st_value > toc->rawsize)
9388 i = toc->rawsize >> 3;
9389 else
9390 i = sym->st_value >> 3;
9391
9392 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9393 {
9394 if (local_toc_syms)
9395 (*_bfd_error_handler)
9396 (_("%s defined on removed toc entry"),
9397 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9398 do
9399 ++i;
9400 while ((skip[i] & (ref_from_discarded | can_optimize)));
9401 sym->st_value = (bfd_vma) i << 3;
9402 }
9403
9404 sym->st_value -= skip[i];
9405 symtab_hdr->contents = (unsigned char *) local_syms;
9406 }
9407
9408 /* Adjust any global syms defined in this toc input section. */
9409 if (toc_inf.global_toc_syms)
9410 {
9411 toc_inf.toc = toc;
9412 toc_inf.skip = skip;
9413 toc_inf.global_toc_syms = FALSE;
9414 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9415 &toc_inf);
9416 }
9417
9418 if (toc->reloc_count != 0)
9419 {
9420 Elf_Internal_Shdr *rel_hdr;
9421 Elf_Internal_Rela *wrel;
9422 bfd_size_type sz;
9423
9424 /* Remove unused toc relocs, and adjust those we keep. */
9425 if (toc_relocs == NULL)
9426 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9427 info->keep_memory);
9428 if (toc_relocs == NULL)
9429 goto error_ret;
9430
9431 wrel = toc_relocs;
9432 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9433 if ((skip[rel->r_offset >> 3]
9434 & (ref_from_discarded | can_optimize)) == 0)
9435 {
9436 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9437 wrel->r_info = rel->r_info;
9438 wrel->r_addend = rel->r_addend;
9439 ++wrel;
9440 }
9441 else if (!dec_dynrel_count (rel->r_info, toc, info,
9442 &local_syms, NULL, NULL))
9443 goto error_ret;
9444
9445 elf_section_data (toc)->relocs = toc_relocs;
9446 toc->reloc_count = wrel - toc_relocs;
9447 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9448 sz = rel_hdr->sh_entsize;
9449 rel_hdr->sh_size = toc->reloc_count * sz;
9450 }
9451 }
9452 else if (toc_relocs != NULL
9453 && elf_section_data (toc)->relocs != toc_relocs)
9454 free (toc_relocs);
9455
9456 if (local_syms != NULL
9457 && symtab_hdr->contents != (unsigned char *) local_syms)
9458 {
9459 if (!info->keep_memory)
9460 free (local_syms);
9461 else
9462 symtab_hdr->contents = (unsigned char *) local_syms;
9463 }
9464 free (skip);
9465 }
9466
9467 return TRUE;
9468 }
9469
9470 /* Return true iff input section I references the TOC using
9471 instructions limited to +/-32k offsets. */
9472
9473 bfd_boolean
9474 ppc64_elf_has_small_toc_reloc (asection *i)
9475 {
9476 return (is_ppc64_elf (i->owner)
9477 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9478 }
9479
9480 /* Allocate space for one GOT entry. */
9481
9482 static void
9483 allocate_got (struct elf_link_hash_entry *h,
9484 struct bfd_link_info *info,
9485 struct got_entry *gent)
9486 {
9487 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9488 bfd_boolean dyn;
9489 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9490 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9491 ? 16 : 8);
9492 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9493 ? 2 : 1) * sizeof (Elf64_External_Rela);
9494 asection *got = ppc64_elf_tdata (gent->owner)->got;
9495
9496 gent->got.offset = got->size;
9497 got->size += entsize;
9498
9499 dyn = htab->elf.dynamic_sections_created;
9500 if (h->type == STT_GNU_IFUNC)
9501 {
9502 htab->elf.irelplt->size += rentsize;
9503 htab->got_reli_size += rentsize;
9504 }
9505 else if ((bfd_link_pic (info)
9506 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9507 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9508 || h->root.type != bfd_link_hash_undefweak))
9509 {
9510 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9511 relgot->size += rentsize;
9512 }
9513 }
9514
9515 /* This function merges got entries in the same toc group. */
9516
9517 static void
9518 merge_got_entries (struct got_entry **pent)
9519 {
9520 struct got_entry *ent, *ent2;
9521
9522 for (ent = *pent; ent != NULL; ent = ent->next)
9523 if (!ent->is_indirect)
9524 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9525 if (!ent2->is_indirect
9526 && ent2->addend == ent->addend
9527 && ent2->tls_type == ent->tls_type
9528 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9529 {
9530 ent2->is_indirect = TRUE;
9531 ent2->got.ent = ent;
9532 }
9533 }
9534
9535 /* Allocate space in .plt, .got and associated reloc sections for
9536 dynamic relocs. */
9537
9538 static bfd_boolean
9539 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9540 {
9541 struct bfd_link_info *info;
9542 struct ppc_link_hash_table *htab;
9543 asection *s;
9544 struct ppc_link_hash_entry *eh;
9545 struct elf_dyn_relocs *p;
9546 struct got_entry **pgent, *gent;
9547
9548 if (h->root.type == bfd_link_hash_indirect)
9549 return TRUE;
9550
9551 info = (struct bfd_link_info *) inf;
9552 htab = ppc_hash_table (info);
9553 if (htab == NULL)
9554 return FALSE;
9555
9556 eh = (struct ppc_link_hash_entry *) h;
9557 /* Run through the TLS GD got entries first if we're changing them
9558 to TPREL. */
9559 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9560 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9561 if (gent->got.refcount > 0
9562 && (gent->tls_type & TLS_GD) != 0)
9563 {
9564 /* This was a GD entry that has been converted to TPREL. If
9565 there happens to be a TPREL entry we can use that one. */
9566 struct got_entry *ent;
9567 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9568 if (ent->got.refcount > 0
9569 && (ent->tls_type & TLS_TPREL) != 0
9570 && ent->addend == gent->addend
9571 && ent->owner == gent->owner)
9572 {
9573 gent->got.refcount = 0;
9574 break;
9575 }
9576
9577 /* If not, then we'll be using our own TPREL entry. */
9578 if (gent->got.refcount != 0)
9579 gent->tls_type = TLS_TLS | TLS_TPREL;
9580 }
9581
9582 /* Remove any list entry that won't generate a word in the GOT before
9583 we call merge_got_entries. Otherwise we risk merging to empty
9584 entries. */
9585 pgent = &h->got.glist;
9586 while ((gent = *pgent) != NULL)
9587 if (gent->got.refcount > 0)
9588 {
9589 if ((gent->tls_type & TLS_LD) != 0
9590 && !h->def_dynamic)
9591 {
9592 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9593 *pgent = gent->next;
9594 }
9595 else
9596 pgent = &gent->next;
9597 }
9598 else
9599 *pgent = gent->next;
9600
9601 if (!htab->do_multi_toc)
9602 merge_got_entries (&h->got.glist);
9603
9604 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9605 if (!gent->is_indirect)
9606 {
9607 /* Make sure this symbol is output as a dynamic symbol.
9608 Undefined weak syms won't yet be marked as dynamic,
9609 nor will all TLS symbols. */
9610 if (h->dynindx == -1
9611 && !h->forced_local
9612 && h->type != STT_GNU_IFUNC
9613 && htab->elf.dynamic_sections_created)
9614 {
9615 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9616 return FALSE;
9617 }
9618
9619 if (!is_ppc64_elf (gent->owner))
9620 abort ();
9621
9622 allocate_got (h, info, gent);
9623 }
9624
9625 if (eh->dyn_relocs != NULL
9626 && (htab->elf.dynamic_sections_created
9627 || h->type == STT_GNU_IFUNC))
9628 {
9629 /* In the shared -Bsymbolic case, discard space allocated for
9630 dynamic pc-relative relocs against symbols which turn out to
9631 be defined in regular objects. For the normal shared case,
9632 discard space for relocs that have become local due to symbol
9633 visibility changes. */
9634
9635 if (bfd_link_pic (info))
9636 {
9637 /* Relocs that use pc_count are those that appear on a call
9638 insn, or certain REL relocs (see must_be_dyn_reloc) that
9639 can be generated via assembly. We want calls to
9640 protected symbols to resolve directly to the function
9641 rather than going via the plt. If people want function
9642 pointer comparisons to work as expected then they should
9643 avoid writing weird assembly. */
9644 if (SYMBOL_CALLS_LOCAL (info, h))
9645 {
9646 struct elf_dyn_relocs **pp;
9647
9648 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9649 {
9650 p->count -= p->pc_count;
9651 p->pc_count = 0;
9652 if (p->count == 0)
9653 *pp = p->next;
9654 else
9655 pp = &p->next;
9656 }
9657 }
9658
9659 /* Also discard relocs on undefined weak syms with
9660 non-default visibility. */
9661 if (eh->dyn_relocs != NULL
9662 && h->root.type == bfd_link_hash_undefweak)
9663 {
9664 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9665 eh->dyn_relocs = NULL;
9666
9667 /* Make sure this symbol is output as a dynamic symbol.
9668 Undefined weak syms won't yet be marked as dynamic. */
9669 else if (h->dynindx == -1
9670 && !h->forced_local)
9671 {
9672 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9673 return FALSE;
9674 }
9675 }
9676 }
9677 else if (h->type == STT_GNU_IFUNC)
9678 {
9679 if (!h->non_got_ref)
9680 eh->dyn_relocs = NULL;
9681 }
9682 else if (ELIMINATE_COPY_RELOCS)
9683 {
9684 /* For the non-shared case, discard space for relocs against
9685 symbols which turn out to need copy relocs or are not
9686 dynamic. */
9687
9688 if (!h->non_got_ref
9689 && !h->def_regular)
9690 {
9691 /* Make sure this symbol is output as a dynamic symbol.
9692 Undefined weak syms won't yet be marked as dynamic. */
9693 if (h->dynindx == -1
9694 && !h->forced_local)
9695 {
9696 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9697 return FALSE;
9698 }
9699
9700 /* If that succeeded, we know we'll be keeping all the
9701 relocs. */
9702 if (h->dynindx != -1)
9703 goto keep;
9704 }
9705
9706 eh->dyn_relocs = NULL;
9707
9708 keep: ;
9709 }
9710
9711 /* Finally, allocate space. */
9712 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9713 {
9714 asection *sreloc = elf_section_data (p->sec)->sreloc;
9715 if (eh->elf.type == STT_GNU_IFUNC)
9716 sreloc = htab->elf.irelplt;
9717 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9718 }
9719 }
9720
9721 if ((htab->elf.dynamic_sections_created
9722 && h->dynindx != -1
9723 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9724 || h->type == STT_GNU_IFUNC)
9725 {
9726 struct plt_entry *pent;
9727 bfd_boolean doneone = FALSE;
9728 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9729 if (pent->plt.refcount > 0)
9730 {
9731 if (!htab->elf.dynamic_sections_created
9732 || h->dynindx == -1)
9733 {
9734 s = htab->elf.iplt;
9735 pent->plt.offset = s->size;
9736 s->size += PLT_ENTRY_SIZE (htab);
9737 s = htab->elf.irelplt;
9738 }
9739 else
9740 {
9741 /* If this is the first .plt entry, make room for the special
9742 first entry. */
9743 s = htab->elf.splt;
9744 if (s->size == 0)
9745 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9746
9747 pent->plt.offset = s->size;
9748
9749 /* Make room for this entry. */
9750 s->size += PLT_ENTRY_SIZE (htab);
9751
9752 /* Make room for the .glink code. */
9753 s = htab->glink;
9754 if (s->size == 0)
9755 s->size += GLINK_CALL_STUB_SIZE;
9756 if (htab->opd_abi)
9757 {
9758 /* We need bigger stubs past index 32767. */
9759 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9760 s->size += 4;
9761 s->size += 2*4;
9762 }
9763 else
9764 s->size += 4;
9765
9766 /* We also need to make an entry in the .rela.plt section. */
9767 s = htab->elf.srelplt;
9768 }
9769 s->size += sizeof (Elf64_External_Rela);
9770 doneone = TRUE;
9771 }
9772 else
9773 pent->plt.offset = (bfd_vma) -1;
9774 if (!doneone)
9775 {
9776 h->plt.plist = NULL;
9777 h->needs_plt = 0;
9778 }
9779 }
9780 else
9781 {
9782 h->plt.plist = NULL;
9783 h->needs_plt = 0;
9784 }
9785
9786 return TRUE;
9787 }
9788
9789 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9790 to set up space for global entry stubs. These are put in glink,
9791 after the branch table. */
9792
9793 static bfd_boolean
9794 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9795 {
9796 struct bfd_link_info *info;
9797 struct ppc_link_hash_table *htab;
9798 struct plt_entry *pent;
9799 asection *s;
9800
9801 if (h->root.type == bfd_link_hash_indirect)
9802 return TRUE;
9803
9804 if (!h->pointer_equality_needed)
9805 return TRUE;
9806
9807 if (h->def_regular)
9808 return TRUE;
9809
9810 info = inf;
9811 htab = ppc_hash_table (info);
9812 if (htab == NULL)
9813 return FALSE;
9814
9815 s = htab->glink;
9816 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9817 if (pent->plt.offset != (bfd_vma) -1
9818 && pent->addend == 0)
9819 {
9820 /* For ELFv2, if this symbol is not defined in a regular file
9821 and we are not generating a shared library or pie, then we
9822 need to define the symbol in the executable on a call stub.
9823 This is to avoid text relocations. */
9824 s->size = (s->size + 15) & -16;
9825 h->root.u.def.section = s;
9826 h->root.u.def.value = s->size;
9827 s->size += 16;
9828 break;
9829 }
9830 return TRUE;
9831 }
9832
9833 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9834 read-only sections. */
9835
9836 static bfd_boolean
9837 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9838 {
9839 if (h->root.type == bfd_link_hash_indirect)
9840 return TRUE;
9841
9842 if (readonly_dynrelocs (h))
9843 {
9844 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9845
9846 /* Not an error, just cut short the traversal. */
9847 return FALSE;
9848 }
9849 return TRUE;
9850 }
9851
9852 /* Set the sizes of the dynamic sections. */
9853
9854 static bfd_boolean
9855 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9856 struct bfd_link_info *info)
9857 {
9858 struct ppc_link_hash_table *htab;
9859 bfd *dynobj;
9860 asection *s;
9861 bfd_boolean relocs;
9862 bfd *ibfd;
9863 struct got_entry *first_tlsld;
9864
9865 htab = ppc_hash_table (info);
9866 if (htab == NULL)
9867 return FALSE;
9868
9869 dynobj = htab->elf.dynobj;
9870 if (dynobj == NULL)
9871 abort ();
9872
9873 if (htab->elf.dynamic_sections_created)
9874 {
9875 /* Set the contents of the .interp section to the interpreter. */
9876 if (bfd_link_executable (info) && !info->nointerp)
9877 {
9878 s = bfd_get_linker_section (dynobj, ".interp");
9879 if (s == NULL)
9880 abort ();
9881 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9882 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9883 }
9884 }
9885
9886 /* Set up .got offsets for local syms, and space for local dynamic
9887 relocs. */
9888 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9889 {
9890 struct got_entry **lgot_ents;
9891 struct got_entry **end_lgot_ents;
9892 struct plt_entry **local_plt;
9893 struct plt_entry **end_local_plt;
9894 unsigned char *lgot_masks;
9895 bfd_size_type locsymcount;
9896 Elf_Internal_Shdr *symtab_hdr;
9897
9898 if (!is_ppc64_elf (ibfd))
9899 continue;
9900
9901 for (s = ibfd->sections; s != NULL; s = s->next)
9902 {
9903 struct ppc_dyn_relocs *p;
9904
9905 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9906 {
9907 if (!bfd_is_abs_section (p->sec)
9908 && bfd_is_abs_section (p->sec->output_section))
9909 {
9910 /* Input section has been discarded, either because
9911 it is a copy of a linkonce section or due to
9912 linker script /DISCARD/, so we'll be discarding
9913 the relocs too. */
9914 }
9915 else if (p->count != 0)
9916 {
9917 asection *srel = elf_section_data (p->sec)->sreloc;
9918 if (p->ifunc)
9919 srel = htab->elf.irelplt;
9920 srel->size += p->count * sizeof (Elf64_External_Rela);
9921 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9922 info->flags |= DF_TEXTREL;
9923 }
9924 }
9925 }
9926
9927 lgot_ents = elf_local_got_ents (ibfd);
9928 if (!lgot_ents)
9929 continue;
9930
9931 symtab_hdr = &elf_symtab_hdr (ibfd);
9932 locsymcount = symtab_hdr->sh_info;
9933 end_lgot_ents = lgot_ents + locsymcount;
9934 local_plt = (struct plt_entry **) end_lgot_ents;
9935 end_local_plt = local_plt + locsymcount;
9936 lgot_masks = (unsigned char *) end_local_plt;
9937 s = ppc64_elf_tdata (ibfd)->got;
9938 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9939 {
9940 struct got_entry **pent, *ent;
9941
9942 pent = lgot_ents;
9943 while ((ent = *pent) != NULL)
9944 if (ent->got.refcount > 0)
9945 {
9946 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9947 {
9948 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9949 *pent = ent->next;
9950 }
9951 else
9952 {
9953 unsigned int ent_size = 8;
9954 unsigned int rel_size = sizeof (Elf64_External_Rela);
9955
9956 ent->got.offset = s->size;
9957 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9958 {
9959 ent_size *= 2;
9960 rel_size *= 2;
9961 }
9962 s->size += ent_size;
9963 if ((*lgot_masks & PLT_IFUNC) != 0)
9964 {
9965 htab->elf.irelplt->size += rel_size;
9966 htab->got_reli_size += rel_size;
9967 }
9968 else if (bfd_link_pic (info))
9969 {
9970 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9971 srel->size += rel_size;
9972 }
9973 pent = &ent->next;
9974 }
9975 }
9976 else
9977 *pent = ent->next;
9978 }
9979
9980 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9981 for (; local_plt < end_local_plt; ++local_plt)
9982 {
9983 struct plt_entry *ent;
9984
9985 for (ent = *local_plt; ent != NULL; ent = ent->next)
9986 if (ent->plt.refcount > 0)
9987 {
9988 s = htab->elf.iplt;
9989 ent->plt.offset = s->size;
9990 s->size += PLT_ENTRY_SIZE (htab);
9991
9992 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9993 }
9994 else
9995 ent->plt.offset = (bfd_vma) -1;
9996 }
9997 }
9998
9999 /* Allocate global sym .plt and .got entries, and space for global
10000 sym dynamic relocs. */
10001 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10002 /* Stash the end of glink branch table. */
10003 if (htab->glink != NULL)
10004 htab->glink->rawsize = htab->glink->size;
10005
10006 if (!htab->opd_abi && !bfd_link_pic (info))
10007 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10008
10009 first_tlsld = NULL;
10010 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10011 {
10012 struct got_entry *ent;
10013
10014 if (!is_ppc64_elf (ibfd))
10015 continue;
10016
10017 ent = ppc64_tlsld_got (ibfd);
10018 if (ent->got.refcount > 0)
10019 {
10020 if (!htab->do_multi_toc && first_tlsld != NULL)
10021 {
10022 ent->is_indirect = TRUE;
10023 ent->got.ent = first_tlsld;
10024 }
10025 else
10026 {
10027 if (first_tlsld == NULL)
10028 first_tlsld = ent;
10029 s = ppc64_elf_tdata (ibfd)->got;
10030 ent->got.offset = s->size;
10031 ent->owner = ibfd;
10032 s->size += 16;
10033 if (bfd_link_pic (info))
10034 {
10035 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10036 srel->size += sizeof (Elf64_External_Rela);
10037 }
10038 }
10039 }
10040 else
10041 ent->got.offset = (bfd_vma) -1;
10042 }
10043
10044 /* We now have determined the sizes of the various dynamic sections.
10045 Allocate memory for them. */
10046 relocs = FALSE;
10047 for (s = dynobj->sections; s != NULL; s = s->next)
10048 {
10049 if ((s->flags & SEC_LINKER_CREATED) == 0)
10050 continue;
10051
10052 if (s == htab->brlt || s == htab->relbrlt)
10053 /* These haven't been allocated yet; don't strip. */
10054 continue;
10055 else if (s == htab->elf.sgot
10056 || s == htab->elf.splt
10057 || s == htab->elf.iplt
10058 || s == htab->glink
10059 || s == htab->dynbss)
10060 {
10061 /* Strip this section if we don't need it; see the
10062 comment below. */
10063 }
10064 else if (s == htab->glink_eh_frame)
10065 {
10066 if (!bfd_is_abs_section (s->output_section))
10067 /* Not sized yet. */
10068 continue;
10069 }
10070 else if (CONST_STRNEQ (s->name, ".rela"))
10071 {
10072 if (s->size != 0)
10073 {
10074 if (s != htab->elf.srelplt)
10075 relocs = TRUE;
10076
10077 /* We use the reloc_count field as a counter if we need
10078 to copy relocs into the output file. */
10079 s->reloc_count = 0;
10080 }
10081 }
10082 else
10083 {
10084 /* It's not one of our sections, so don't allocate space. */
10085 continue;
10086 }
10087
10088 if (s->size == 0)
10089 {
10090 /* If we don't need this section, strip it from the
10091 output file. This is mostly to handle .rela.bss and
10092 .rela.plt. We must create both sections in
10093 create_dynamic_sections, because they must be created
10094 before the linker maps input sections to output
10095 sections. The linker does that before
10096 adjust_dynamic_symbol is called, and it is that
10097 function which decides whether anything needs to go
10098 into these sections. */
10099 s->flags |= SEC_EXCLUDE;
10100 continue;
10101 }
10102
10103 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10104 continue;
10105
10106 /* Allocate memory for the section contents. We use bfd_zalloc
10107 here in case unused entries are not reclaimed before the
10108 section's contents are written out. This should not happen,
10109 but this way if it does we get a R_PPC64_NONE reloc in .rela
10110 sections instead of garbage.
10111 We also rely on the section contents being zero when writing
10112 the GOT. */
10113 s->contents = bfd_zalloc (dynobj, s->size);
10114 if (s->contents == NULL)
10115 return FALSE;
10116 }
10117
10118 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10119 {
10120 if (!is_ppc64_elf (ibfd))
10121 continue;
10122
10123 s = ppc64_elf_tdata (ibfd)->got;
10124 if (s != NULL && s != htab->elf.sgot)
10125 {
10126 if (s->size == 0)
10127 s->flags |= SEC_EXCLUDE;
10128 else
10129 {
10130 s->contents = bfd_zalloc (ibfd, s->size);
10131 if (s->contents == NULL)
10132 return FALSE;
10133 }
10134 }
10135 s = ppc64_elf_tdata (ibfd)->relgot;
10136 if (s != NULL)
10137 {
10138 if (s->size == 0)
10139 s->flags |= SEC_EXCLUDE;
10140 else
10141 {
10142 s->contents = bfd_zalloc (ibfd, s->size);
10143 if (s->contents == NULL)
10144 return FALSE;
10145 relocs = TRUE;
10146 s->reloc_count = 0;
10147 }
10148 }
10149 }
10150
10151 if (htab->elf.dynamic_sections_created)
10152 {
10153 bfd_boolean tls_opt;
10154
10155 /* Add some entries to the .dynamic section. We fill in the
10156 values later, in ppc64_elf_finish_dynamic_sections, but we
10157 must add the entries now so that we get the correct size for
10158 the .dynamic section. The DT_DEBUG entry is filled in by the
10159 dynamic linker and used by the debugger. */
10160 #define add_dynamic_entry(TAG, VAL) \
10161 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10162
10163 if (bfd_link_executable (info))
10164 {
10165 if (!add_dynamic_entry (DT_DEBUG, 0))
10166 return FALSE;
10167 }
10168
10169 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10170 {
10171 if (!add_dynamic_entry (DT_PLTGOT, 0)
10172 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10173 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10174 || !add_dynamic_entry (DT_JMPREL, 0)
10175 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10176 return FALSE;
10177 }
10178
10179 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10180 {
10181 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10182 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10183 return FALSE;
10184 }
10185
10186 tls_opt = (htab->params->tls_get_addr_opt
10187 && htab->tls_get_addr_fd != NULL
10188 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10189 if (tls_opt || !htab->opd_abi)
10190 {
10191 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10192 return FALSE;
10193 }
10194
10195 if (relocs)
10196 {
10197 if (!add_dynamic_entry (DT_RELA, 0)
10198 || !add_dynamic_entry (DT_RELASZ, 0)
10199 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10200 return FALSE;
10201
10202 /* If any dynamic relocs apply to a read-only section,
10203 then we need a DT_TEXTREL entry. */
10204 if ((info->flags & DF_TEXTREL) == 0)
10205 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10206
10207 if ((info->flags & DF_TEXTREL) != 0)
10208 {
10209 if (!add_dynamic_entry (DT_TEXTREL, 0))
10210 return FALSE;
10211 }
10212 }
10213 }
10214 #undef add_dynamic_entry
10215
10216 return TRUE;
10217 }
10218
10219 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10220
10221 static bfd_boolean
10222 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10223 {
10224 if (h->plt.plist != NULL
10225 && !h->def_regular
10226 && !h->pointer_equality_needed)
10227 return FALSE;
10228
10229 return _bfd_elf_hash_symbol (h);
10230 }
10231
10232 /* Determine the type of stub needed, if any, for a call. */
10233
10234 static inline enum ppc_stub_type
10235 ppc_type_of_stub (asection *input_sec,
10236 const Elf_Internal_Rela *rel,
10237 struct ppc_link_hash_entry **hash,
10238 struct plt_entry **plt_ent,
10239 bfd_vma destination,
10240 unsigned long local_off)
10241 {
10242 struct ppc_link_hash_entry *h = *hash;
10243 bfd_vma location;
10244 bfd_vma branch_offset;
10245 bfd_vma max_branch_offset;
10246 enum elf_ppc64_reloc_type r_type;
10247
10248 if (h != NULL)
10249 {
10250 struct plt_entry *ent;
10251 struct ppc_link_hash_entry *fdh = h;
10252 if (h->oh != NULL
10253 && h->oh->is_func_descriptor)
10254 {
10255 fdh = ppc_follow_link (h->oh);
10256 *hash = fdh;
10257 }
10258
10259 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10260 if (ent->addend == rel->r_addend
10261 && ent->plt.offset != (bfd_vma) -1)
10262 {
10263 *plt_ent = ent;
10264 return ppc_stub_plt_call;
10265 }
10266
10267 /* Here, we know we don't have a plt entry. If we don't have a
10268 either a defined function descriptor or a defined entry symbol
10269 in a regular object file, then it is pointless trying to make
10270 any other type of stub. */
10271 if (!is_static_defined (&fdh->elf)
10272 && !is_static_defined (&h->elf))
10273 return ppc_stub_none;
10274 }
10275 else if (elf_local_got_ents (input_sec->owner) != NULL)
10276 {
10277 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10278 struct plt_entry **local_plt = (struct plt_entry **)
10279 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10280 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10281
10282 if (local_plt[r_symndx] != NULL)
10283 {
10284 struct plt_entry *ent;
10285
10286 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10287 if (ent->addend == rel->r_addend
10288 && ent->plt.offset != (bfd_vma) -1)
10289 {
10290 *plt_ent = ent;
10291 return ppc_stub_plt_call;
10292 }
10293 }
10294 }
10295
10296 /* Determine where the call point is. */
10297 location = (input_sec->output_offset
10298 + input_sec->output_section->vma
10299 + rel->r_offset);
10300
10301 branch_offset = destination - location;
10302 r_type = ELF64_R_TYPE (rel->r_info);
10303
10304 /* Determine if a long branch stub is needed. */
10305 max_branch_offset = 1 << 25;
10306 if (r_type != R_PPC64_REL24)
10307 max_branch_offset = 1 << 15;
10308
10309 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10310 /* We need a stub. Figure out whether a long_branch or plt_branch
10311 is needed later. */
10312 return ppc_stub_long_branch;
10313
10314 return ppc_stub_none;
10315 }
10316
10317 /* With power7 weakly ordered memory model, it is possible for ld.so
10318 to update a plt entry in one thread and have another thread see a
10319 stale zero toc entry. To avoid this we need some sort of acquire
10320 barrier in the call stub. One solution is to make the load of the
10321 toc word seem to appear to depend on the load of the function entry
10322 word. Another solution is to test for r2 being zero, and branch to
10323 the appropriate glink entry if so.
10324
10325 . fake dep barrier compare
10326 . ld 12,xxx(2) ld 12,xxx(2)
10327 . mtctr 12 mtctr 12
10328 . xor 11,12,12 ld 2,xxx+8(2)
10329 . add 2,2,11 cmpldi 2,0
10330 . ld 2,xxx+8(2) bnectr+
10331 . bctr b <glink_entry>
10332
10333 The solution involving the compare turns out to be faster, so
10334 that's what we use unless the branch won't reach. */
10335
10336 #define ALWAYS_USE_FAKE_DEP 0
10337 #define ALWAYS_EMIT_R2SAVE 0
10338
10339 #define PPC_LO(v) ((v) & 0xffff)
10340 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10341 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10342
10343 static inline unsigned int
10344 plt_stub_size (struct ppc_link_hash_table *htab,
10345 struct ppc_stub_hash_entry *stub_entry,
10346 bfd_vma off)
10347 {
10348 unsigned size = 12;
10349
10350 if (ALWAYS_EMIT_R2SAVE
10351 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10352 size += 4;
10353 if (PPC_HA (off) != 0)
10354 size += 4;
10355 if (htab->opd_abi)
10356 {
10357 size += 4;
10358 if (htab->params->plt_static_chain)
10359 size += 4;
10360 if (htab->params->plt_thread_safe
10361 && htab->elf.dynamic_sections_created
10362 && stub_entry->h != NULL
10363 && stub_entry->h->elf.dynindx != -1)
10364 size += 8;
10365 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10366 size += 4;
10367 }
10368 if (stub_entry->h != NULL
10369 && (stub_entry->h == htab->tls_get_addr_fd
10370 || stub_entry->h == htab->tls_get_addr)
10371 && htab->params->tls_get_addr_opt)
10372 size += 13 * 4;
10373 return size;
10374 }
10375
10376 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10377 then return the padding needed to do so. */
10378 static inline unsigned int
10379 plt_stub_pad (struct ppc_link_hash_table *htab,
10380 struct ppc_stub_hash_entry *stub_entry,
10381 bfd_vma plt_off)
10382 {
10383 int stub_align = 1 << htab->params->plt_stub_align;
10384 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10385 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10386
10387 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10388 > ((stub_size - 1) & -stub_align))
10389 return stub_align - (stub_off & (stub_align - 1));
10390 return 0;
10391 }
10392
10393 /* Build a .plt call stub. */
10394
10395 static inline bfd_byte *
10396 build_plt_stub (struct ppc_link_hash_table *htab,
10397 struct ppc_stub_hash_entry *stub_entry,
10398 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10399 {
10400 bfd *obfd = htab->params->stub_bfd;
10401 bfd_boolean plt_load_toc = htab->opd_abi;
10402 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10403 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10404 && htab->elf.dynamic_sections_created
10405 && stub_entry->h != NULL
10406 && stub_entry->h->elf.dynindx != -1);
10407 bfd_boolean use_fake_dep = plt_thread_safe;
10408 bfd_vma cmp_branch_off = 0;
10409
10410 if (!ALWAYS_USE_FAKE_DEP
10411 && plt_load_toc
10412 && plt_thread_safe
10413 && !((stub_entry->h == htab->tls_get_addr_fd
10414 || stub_entry->h == htab->tls_get_addr)
10415 && htab->params->tls_get_addr_opt))
10416 {
10417 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10418 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10419 / PLT_ENTRY_SIZE (htab));
10420 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10421 bfd_vma to, from;
10422
10423 if (pltindex > 32768)
10424 glinkoff += (pltindex - 32768) * 4;
10425 to = (glinkoff
10426 + htab->glink->output_offset
10427 + htab->glink->output_section->vma);
10428 from = (p - stub_entry->group->stub_sec->contents
10429 + 4 * (ALWAYS_EMIT_R2SAVE
10430 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10431 + 4 * (PPC_HA (offset) != 0)
10432 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10433 != PPC_HA (offset))
10434 + 4 * (plt_static_chain != 0)
10435 + 20
10436 + stub_entry->group->stub_sec->output_offset
10437 + stub_entry->group->stub_sec->output_section->vma);
10438 cmp_branch_off = to - from;
10439 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10440 }
10441
10442 if (PPC_HA (offset) != 0)
10443 {
10444 if (r != NULL)
10445 {
10446 if (ALWAYS_EMIT_R2SAVE
10447 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10448 r[0].r_offset += 4;
10449 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10450 r[1].r_offset = r[0].r_offset + 4;
10451 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10452 r[1].r_addend = r[0].r_addend;
10453 if (plt_load_toc)
10454 {
10455 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10456 {
10457 r[2].r_offset = r[1].r_offset + 4;
10458 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10459 r[2].r_addend = r[0].r_addend;
10460 }
10461 else
10462 {
10463 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10464 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10465 r[2].r_addend = r[0].r_addend + 8;
10466 if (plt_static_chain)
10467 {
10468 r[3].r_offset = r[2].r_offset + 4;
10469 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10470 r[3].r_addend = r[0].r_addend + 16;
10471 }
10472 }
10473 }
10474 }
10475 if (ALWAYS_EMIT_R2SAVE
10476 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10477 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10478 if (plt_load_toc)
10479 {
10480 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10481 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10482 }
10483 else
10484 {
10485 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10486 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10487 }
10488 if (plt_load_toc
10489 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10490 {
10491 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10492 offset = 0;
10493 }
10494 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10495 if (plt_load_toc)
10496 {
10497 if (use_fake_dep)
10498 {
10499 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10500 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10501 }
10502 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10503 if (plt_static_chain)
10504 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10505 }
10506 }
10507 else
10508 {
10509 if (r != NULL)
10510 {
10511 if (ALWAYS_EMIT_R2SAVE
10512 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10513 r[0].r_offset += 4;
10514 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10515 if (plt_load_toc)
10516 {
10517 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10518 {
10519 r[1].r_offset = r[0].r_offset + 4;
10520 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10521 r[1].r_addend = r[0].r_addend;
10522 }
10523 else
10524 {
10525 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10526 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10527 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10528 if (plt_static_chain)
10529 {
10530 r[2].r_offset = r[1].r_offset + 4;
10531 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10532 r[2].r_addend = r[0].r_addend + 8;
10533 }
10534 }
10535 }
10536 }
10537 if (ALWAYS_EMIT_R2SAVE
10538 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10539 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10540 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10541 if (plt_load_toc
10542 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10543 {
10544 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10545 offset = 0;
10546 }
10547 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10548 if (plt_load_toc)
10549 {
10550 if (use_fake_dep)
10551 {
10552 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10553 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10554 }
10555 if (plt_static_chain)
10556 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10557 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10558 }
10559 }
10560 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10561 {
10562 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10563 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10564 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10565 }
10566 else
10567 bfd_put_32 (obfd, BCTR, p), p += 4;
10568 return p;
10569 }
10570
10571 /* Build a special .plt call stub for __tls_get_addr. */
10572
10573 #define LD_R11_0R3 0xe9630000
10574 #define LD_R12_0R3 0xe9830000
10575 #define MR_R0_R3 0x7c601b78
10576 #define CMPDI_R11_0 0x2c2b0000
10577 #define ADD_R3_R12_R13 0x7c6c6a14
10578 #define BEQLR 0x4d820020
10579 #define MR_R3_R0 0x7c030378
10580 #define STD_R11_0R1 0xf9610000
10581 #define BCTRL 0x4e800421
10582 #define LD_R11_0R1 0xe9610000
10583 #define MTLR_R11 0x7d6803a6
10584
10585 static inline bfd_byte *
10586 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10587 struct ppc_stub_hash_entry *stub_entry,
10588 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10589 {
10590 bfd *obfd = htab->params->stub_bfd;
10591
10592 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10593 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10594 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10595 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10596 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10597 bfd_put_32 (obfd, BEQLR, p), p += 4;
10598 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10599 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10600 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10601
10602 if (r != NULL)
10603 r[0].r_offset += 9 * 4;
10604 p = build_plt_stub (htab, stub_entry, p, offset, r);
10605 bfd_put_32 (obfd, BCTRL, p - 4);
10606
10607 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10608 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10609 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10610 bfd_put_32 (obfd, BLR, p), p += 4;
10611
10612 return p;
10613 }
10614
10615 static Elf_Internal_Rela *
10616 get_relocs (asection *sec, int count)
10617 {
10618 Elf_Internal_Rela *relocs;
10619 struct bfd_elf_section_data *elfsec_data;
10620
10621 elfsec_data = elf_section_data (sec);
10622 relocs = elfsec_data->relocs;
10623 if (relocs == NULL)
10624 {
10625 bfd_size_type relsize;
10626 relsize = sec->reloc_count * sizeof (*relocs);
10627 relocs = bfd_alloc (sec->owner, relsize);
10628 if (relocs == NULL)
10629 return NULL;
10630 elfsec_data->relocs = relocs;
10631 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10632 sizeof (Elf_Internal_Shdr));
10633 if (elfsec_data->rela.hdr == NULL)
10634 return NULL;
10635 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10636 * sizeof (Elf64_External_Rela));
10637 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10638 sec->reloc_count = 0;
10639 }
10640 relocs += sec->reloc_count;
10641 sec->reloc_count += count;
10642 return relocs;
10643 }
10644
10645 static bfd_vma
10646 get_r2off (struct bfd_link_info *info,
10647 struct ppc_stub_hash_entry *stub_entry)
10648 {
10649 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10650 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10651
10652 if (r2off == 0)
10653 {
10654 /* Support linking -R objects. Get the toc pointer from the
10655 opd entry. */
10656 char buf[8];
10657 if (!htab->opd_abi)
10658 return r2off;
10659 asection *opd = stub_entry->h->elf.root.u.def.section;
10660 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10661
10662 if (strcmp (opd->name, ".opd") != 0
10663 || opd->reloc_count != 0)
10664 {
10665 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10666 stub_entry->h->elf.root.root.string);
10667 bfd_set_error (bfd_error_bad_value);
10668 return (bfd_vma) -1;
10669 }
10670 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10671 return (bfd_vma) -1;
10672 r2off = bfd_get_64 (opd->owner, buf);
10673 r2off -= elf_gp (info->output_bfd);
10674 }
10675 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10676 return r2off;
10677 }
10678
10679 static bfd_boolean
10680 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10681 {
10682 struct ppc_stub_hash_entry *stub_entry;
10683 struct ppc_branch_hash_entry *br_entry;
10684 struct bfd_link_info *info;
10685 struct ppc_link_hash_table *htab;
10686 bfd_byte *loc;
10687 bfd_byte *p;
10688 bfd_vma dest, off;
10689 int size;
10690 Elf_Internal_Rela *r;
10691 asection *plt;
10692
10693 /* Massage our args to the form they really have. */
10694 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10695 info = in_arg;
10696
10697 htab = ppc_hash_table (info);
10698 if (htab == NULL)
10699 return FALSE;
10700
10701 /* Make a note of the offset within the stubs for this entry. */
10702 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10703 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10704
10705 htab->stub_count[stub_entry->stub_type - 1] += 1;
10706 switch (stub_entry->stub_type)
10707 {
10708 case ppc_stub_long_branch:
10709 case ppc_stub_long_branch_r2off:
10710 /* Branches are relative. This is where we are going to. */
10711 dest = (stub_entry->target_value
10712 + stub_entry->target_section->output_offset
10713 + stub_entry->target_section->output_section->vma);
10714 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10715 off = dest;
10716
10717 /* And this is where we are coming from. */
10718 off -= (stub_entry->stub_offset
10719 + stub_entry->group->stub_sec->output_offset
10720 + stub_entry->group->stub_sec->output_section->vma);
10721
10722 size = 4;
10723 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10724 {
10725 bfd_vma r2off = get_r2off (info, stub_entry);
10726
10727 if (r2off == (bfd_vma) -1)
10728 {
10729 htab->stub_error = TRUE;
10730 return FALSE;
10731 }
10732 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10733 loc += 4;
10734 size = 8;
10735 if (PPC_HA (r2off) != 0)
10736 {
10737 bfd_put_32 (htab->params->stub_bfd,
10738 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10739 loc += 4;
10740 size += 4;
10741 }
10742 if (PPC_LO (r2off) != 0)
10743 {
10744 bfd_put_32 (htab->params->stub_bfd,
10745 ADDI_R2_R2 | PPC_LO (r2off), loc);
10746 loc += 4;
10747 size += 4;
10748 }
10749 off -= size - 4;
10750 }
10751 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10752
10753 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10754 {
10755 info->callbacks->einfo
10756 (_("%P: long branch stub `%s' offset overflow\n"),
10757 stub_entry->root.string);
10758 htab->stub_error = TRUE;
10759 return FALSE;
10760 }
10761
10762 if (info->emitrelocations)
10763 {
10764 r = get_relocs (stub_entry->group->stub_sec, 1);
10765 if (r == NULL)
10766 return FALSE;
10767 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10768 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10769 r->r_addend = dest;
10770 if (stub_entry->h != NULL)
10771 {
10772 struct elf_link_hash_entry **hashes;
10773 unsigned long symndx;
10774 struct ppc_link_hash_entry *h;
10775
10776 hashes = elf_sym_hashes (htab->params->stub_bfd);
10777 if (hashes == NULL)
10778 {
10779 bfd_size_type hsize;
10780
10781 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10782 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10783 if (hashes == NULL)
10784 return FALSE;
10785 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10786 htab->stub_globals = 1;
10787 }
10788 symndx = htab->stub_globals++;
10789 h = stub_entry->h;
10790 hashes[symndx] = &h->elf;
10791 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10792 if (h->oh != NULL && h->oh->is_func)
10793 h = ppc_follow_link (h->oh);
10794 if (h->elf.root.u.def.section != stub_entry->target_section)
10795 /* H is an opd symbol. The addend must be zero. */
10796 r->r_addend = 0;
10797 else
10798 {
10799 off = (h->elf.root.u.def.value
10800 + h->elf.root.u.def.section->output_offset
10801 + h->elf.root.u.def.section->output_section->vma);
10802 r->r_addend -= off;
10803 }
10804 }
10805 }
10806 break;
10807
10808 case ppc_stub_plt_branch:
10809 case ppc_stub_plt_branch_r2off:
10810 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10811 stub_entry->root.string + 9,
10812 FALSE, FALSE);
10813 if (br_entry == NULL)
10814 {
10815 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10816 stub_entry->root.string);
10817 htab->stub_error = TRUE;
10818 return FALSE;
10819 }
10820
10821 dest = (stub_entry->target_value
10822 + stub_entry->target_section->output_offset
10823 + stub_entry->target_section->output_section->vma);
10824 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10825 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10826
10827 bfd_put_64 (htab->brlt->owner, dest,
10828 htab->brlt->contents + br_entry->offset);
10829
10830 if (br_entry->iter == htab->stub_iteration)
10831 {
10832 br_entry->iter = 0;
10833
10834 if (htab->relbrlt != NULL)
10835 {
10836 /* Create a reloc for the branch lookup table entry. */
10837 Elf_Internal_Rela rela;
10838 bfd_byte *rl;
10839
10840 rela.r_offset = (br_entry->offset
10841 + htab->brlt->output_offset
10842 + htab->brlt->output_section->vma);
10843 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10844 rela.r_addend = dest;
10845
10846 rl = htab->relbrlt->contents;
10847 rl += (htab->relbrlt->reloc_count++
10848 * sizeof (Elf64_External_Rela));
10849 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10850 }
10851 else if (info->emitrelocations)
10852 {
10853 r = get_relocs (htab->brlt, 1);
10854 if (r == NULL)
10855 return FALSE;
10856 /* brlt, being SEC_LINKER_CREATED does not go through the
10857 normal reloc processing. Symbols and offsets are not
10858 translated from input file to output file form, so
10859 set up the offset per the output file. */
10860 r->r_offset = (br_entry->offset
10861 + htab->brlt->output_offset
10862 + htab->brlt->output_section->vma);
10863 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10864 r->r_addend = dest;
10865 }
10866 }
10867
10868 dest = (br_entry->offset
10869 + htab->brlt->output_offset
10870 + htab->brlt->output_section->vma);
10871
10872 off = (dest
10873 - elf_gp (htab->brlt->output_section->owner)
10874 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10875
10876 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10877 {
10878 info->callbacks->einfo
10879 (_("%P: linkage table error against `%T'\n"),
10880 stub_entry->root.string);
10881 bfd_set_error (bfd_error_bad_value);
10882 htab->stub_error = TRUE;
10883 return FALSE;
10884 }
10885
10886 if (info->emitrelocations)
10887 {
10888 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10889 if (r == NULL)
10890 return FALSE;
10891 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10892 if (bfd_big_endian (info->output_bfd))
10893 r[0].r_offset += 2;
10894 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10895 r[0].r_offset += 4;
10896 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10897 r[0].r_addend = dest;
10898 if (PPC_HA (off) != 0)
10899 {
10900 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10901 r[1].r_offset = r[0].r_offset + 4;
10902 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10903 r[1].r_addend = r[0].r_addend;
10904 }
10905 }
10906
10907 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10908 {
10909 if (PPC_HA (off) != 0)
10910 {
10911 size = 16;
10912 bfd_put_32 (htab->params->stub_bfd,
10913 ADDIS_R12_R2 | PPC_HA (off), loc);
10914 loc += 4;
10915 bfd_put_32 (htab->params->stub_bfd,
10916 LD_R12_0R12 | PPC_LO (off), loc);
10917 }
10918 else
10919 {
10920 size = 12;
10921 bfd_put_32 (htab->params->stub_bfd,
10922 LD_R12_0R2 | PPC_LO (off), loc);
10923 }
10924 }
10925 else
10926 {
10927 bfd_vma r2off = get_r2off (info, stub_entry);
10928
10929 if (r2off == (bfd_vma) -1)
10930 {
10931 htab->stub_error = TRUE;
10932 return FALSE;
10933 }
10934
10935 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10936 loc += 4;
10937 size = 16;
10938 if (PPC_HA (off) != 0)
10939 {
10940 size += 4;
10941 bfd_put_32 (htab->params->stub_bfd,
10942 ADDIS_R12_R2 | PPC_HA (off), loc);
10943 loc += 4;
10944 bfd_put_32 (htab->params->stub_bfd,
10945 LD_R12_0R12 | PPC_LO (off), loc);
10946 }
10947 else
10948 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10949
10950 if (PPC_HA (r2off) != 0)
10951 {
10952 size += 4;
10953 loc += 4;
10954 bfd_put_32 (htab->params->stub_bfd,
10955 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10956 }
10957 if (PPC_LO (r2off) != 0)
10958 {
10959 size += 4;
10960 loc += 4;
10961 bfd_put_32 (htab->params->stub_bfd,
10962 ADDI_R2_R2 | PPC_LO (r2off), loc);
10963 }
10964 }
10965 loc += 4;
10966 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10967 loc += 4;
10968 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10969 break;
10970
10971 case ppc_stub_plt_call:
10972 case ppc_stub_plt_call_r2save:
10973 if (stub_entry->h != NULL
10974 && stub_entry->h->is_func_descriptor
10975 && stub_entry->h->oh != NULL)
10976 {
10977 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10978
10979 /* If the old-ABI "dot-symbol" is undefined make it weak so
10980 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
10981 if (fh->elf.root.type == bfd_link_hash_undefined)
10982 fh->elf.root.type = bfd_link_hash_undefweak;
10983 /* Stop undo_symbol_twiddle changing it back to undefined. */
10984 fh->was_undefined = 0;
10985 }
10986
10987 /* Now build the stub. */
10988 dest = stub_entry->plt_ent->plt.offset & ~1;
10989 if (dest >= (bfd_vma) -2)
10990 abort ();
10991
10992 plt = htab->elf.splt;
10993 if (!htab->elf.dynamic_sections_created
10994 || stub_entry->h == NULL
10995 || stub_entry->h->elf.dynindx == -1)
10996 plt = htab->elf.iplt;
10997
10998 dest += plt->output_offset + plt->output_section->vma;
10999
11000 if (stub_entry->h == NULL
11001 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11002 {
11003 Elf_Internal_Rela rela;
11004 bfd_byte *rl;
11005
11006 rela.r_offset = dest;
11007 if (htab->opd_abi)
11008 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11009 else
11010 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11011 rela.r_addend = (stub_entry->target_value
11012 + stub_entry->target_section->output_offset
11013 + stub_entry->target_section->output_section->vma);
11014
11015 rl = (htab->elf.irelplt->contents
11016 + (htab->elf.irelplt->reloc_count++
11017 * sizeof (Elf64_External_Rela)));
11018 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11019 stub_entry->plt_ent->plt.offset |= 1;
11020 }
11021
11022 off = (dest
11023 - elf_gp (plt->output_section->owner)
11024 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11025
11026 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11027 {
11028 info->callbacks->einfo
11029 (_("%P: linkage table error against `%T'\n"),
11030 stub_entry->h != NULL
11031 ? stub_entry->h->elf.root.root.string
11032 : "<local sym>");
11033 bfd_set_error (bfd_error_bad_value);
11034 htab->stub_error = TRUE;
11035 return FALSE;
11036 }
11037
11038 if (htab->params->plt_stub_align != 0)
11039 {
11040 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11041
11042 stub_entry->group->stub_sec->size += pad;
11043 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11044 loc += pad;
11045 }
11046
11047 r = NULL;
11048 if (info->emitrelocations)
11049 {
11050 r = get_relocs (stub_entry->group->stub_sec,
11051 ((PPC_HA (off) != 0)
11052 + (htab->opd_abi
11053 ? 2 + (htab->params->plt_static_chain
11054 && PPC_HA (off + 16) == PPC_HA (off))
11055 : 1)));
11056 if (r == NULL)
11057 return FALSE;
11058 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11059 if (bfd_big_endian (info->output_bfd))
11060 r[0].r_offset += 2;
11061 r[0].r_addend = dest;
11062 }
11063 if (stub_entry->h != NULL
11064 && (stub_entry->h == htab->tls_get_addr_fd
11065 || stub_entry->h == htab->tls_get_addr)
11066 && htab->params->tls_get_addr_opt)
11067 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11068 else
11069 p = build_plt_stub (htab, stub_entry, loc, off, r);
11070 size = p - loc;
11071 break;
11072
11073 case ppc_stub_save_res:
11074 return TRUE;
11075
11076 default:
11077 BFD_FAIL ();
11078 return FALSE;
11079 }
11080
11081 stub_entry->group->stub_sec->size += size;
11082
11083 if (htab->params->emit_stub_syms)
11084 {
11085 struct elf_link_hash_entry *h;
11086 size_t len1, len2;
11087 char *name;
11088 const char *const stub_str[] = { "long_branch",
11089 "long_branch_r2off",
11090 "plt_branch",
11091 "plt_branch_r2off",
11092 "plt_call",
11093 "plt_call" };
11094
11095 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11096 len2 = strlen (stub_entry->root.string);
11097 name = bfd_malloc (len1 + len2 + 2);
11098 if (name == NULL)
11099 return FALSE;
11100 memcpy (name, stub_entry->root.string, 9);
11101 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11102 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11103 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11104 if (h == NULL)
11105 return FALSE;
11106 if (h->root.type == bfd_link_hash_new)
11107 {
11108 h->root.type = bfd_link_hash_defined;
11109 h->root.u.def.section = stub_entry->group->stub_sec;
11110 h->root.u.def.value = stub_entry->stub_offset;
11111 h->ref_regular = 1;
11112 h->def_regular = 1;
11113 h->ref_regular_nonweak = 1;
11114 h->forced_local = 1;
11115 h->non_elf = 0;
11116 h->root.linker_def = 1;
11117 }
11118 }
11119
11120 return TRUE;
11121 }
11122
11123 /* As above, but don't actually build the stub. Just bump offset so
11124 we know stub section sizes, and select plt_branch stubs where
11125 long_branch stubs won't do. */
11126
11127 static bfd_boolean
11128 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11129 {
11130 struct ppc_stub_hash_entry *stub_entry;
11131 struct bfd_link_info *info;
11132 struct ppc_link_hash_table *htab;
11133 bfd_vma off;
11134 int size;
11135
11136 /* Massage our args to the form they really have. */
11137 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11138 info = in_arg;
11139
11140 htab = ppc_hash_table (info);
11141 if (htab == NULL)
11142 return FALSE;
11143
11144 if (stub_entry->h != NULL
11145 && stub_entry->h->save_res
11146 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11147 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11148 {
11149 /* Don't make stubs to out-of-line register save/restore
11150 functions. Instead, emit copies of the functions. */
11151 stub_entry->group->needs_save_res = 1;
11152 stub_entry->stub_type = ppc_stub_save_res;
11153 return TRUE;
11154 }
11155
11156 if (stub_entry->stub_type == ppc_stub_plt_call
11157 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11158 {
11159 asection *plt;
11160 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11161 if (off >= (bfd_vma) -2)
11162 abort ();
11163 plt = htab->elf.splt;
11164 if (!htab->elf.dynamic_sections_created
11165 || stub_entry->h == NULL
11166 || stub_entry->h->elf.dynindx == -1)
11167 plt = htab->elf.iplt;
11168 off += (plt->output_offset
11169 + plt->output_section->vma
11170 - elf_gp (plt->output_section->owner)
11171 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11172
11173 size = plt_stub_size (htab, stub_entry, off);
11174 if (htab->params->plt_stub_align)
11175 size += plt_stub_pad (htab, stub_entry, off);
11176 if (info->emitrelocations)
11177 {
11178 stub_entry->group->stub_sec->reloc_count
11179 += ((PPC_HA (off) != 0)
11180 + (htab->opd_abi
11181 ? 2 + (htab->params->plt_static_chain
11182 && PPC_HA (off + 16) == PPC_HA (off))
11183 : 1));
11184 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11185 }
11186 }
11187 else
11188 {
11189 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11190 variants. */
11191 bfd_vma r2off = 0;
11192 bfd_vma local_off = 0;
11193
11194 off = (stub_entry->target_value
11195 + stub_entry->target_section->output_offset
11196 + stub_entry->target_section->output_section->vma);
11197 off -= (stub_entry->group->stub_sec->size
11198 + stub_entry->group->stub_sec->output_offset
11199 + stub_entry->group->stub_sec->output_section->vma);
11200
11201 /* Reset the stub type from the plt variant in case we now
11202 can reach with a shorter stub. */
11203 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11204 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11205
11206 size = 4;
11207 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11208 {
11209 r2off = get_r2off (info, stub_entry);
11210 if (r2off == (bfd_vma) -1)
11211 {
11212 htab->stub_error = TRUE;
11213 return FALSE;
11214 }
11215 size = 8;
11216 if (PPC_HA (r2off) != 0)
11217 size += 4;
11218 if (PPC_LO (r2off) != 0)
11219 size += 4;
11220 off -= size - 4;
11221 }
11222
11223 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11224
11225 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11226 Do the same for -R objects without function descriptors. */
11227 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11228 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11229 && r2off == 0
11230 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11231 {
11232 struct ppc_branch_hash_entry *br_entry;
11233
11234 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11235 stub_entry->root.string + 9,
11236 TRUE, FALSE);
11237 if (br_entry == NULL)
11238 {
11239 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11240 stub_entry->root.string);
11241 htab->stub_error = TRUE;
11242 return FALSE;
11243 }
11244
11245 if (br_entry->iter != htab->stub_iteration)
11246 {
11247 br_entry->iter = htab->stub_iteration;
11248 br_entry->offset = htab->brlt->size;
11249 htab->brlt->size += 8;
11250
11251 if (htab->relbrlt != NULL)
11252 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11253 else if (info->emitrelocations)
11254 {
11255 htab->brlt->reloc_count += 1;
11256 htab->brlt->flags |= SEC_RELOC;
11257 }
11258 }
11259
11260 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11261 off = (br_entry->offset
11262 + htab->brlt->output_offset
11263 + htab->brlt->output_section->vma
11264 - elf_gp (htab->brlt->output_section->owner)
11265 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11266
11267 if (info->emitrelocations)
11268 {
11269 stub_entry->group->stub_sec->reloc_count
11270 += 1 + (PPC_HA (off) != 0);
11271 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11272 }
11273
11274 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11275 {
11276 size = 12;
11277 if (PPC_HA (off) != 0)
11278 size = 16;
11279 }
11280 else
11281 {
11282 size = 16;
11283 if (PPC_HA (off) != 0)
11284 size += 4;
11285
11286 if (PPC_HA (r2off) != 0)
11287 size += 4;
11288 if (PPC_LO (r2off) != 0)
11289 size += 4;
11290 }
11291 }
11292 else if (info->emitrelocations)
11293 {
11294 stub_entry->group->stub_sec->reloc_count += 1;
11295 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11296 }
11297 }
11298
11299 stub_entry->group->stub_sec->size += size;
11300 return TRUE;
11301 }
11302
11303 /* Set up various things so that we can make a list of input sections
11304 for each output section included in the link. Returns -1 on error,
11305 0 when no stubs will be needed, and 1 on success. */
11306
11307 int
11308 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11309 {
11310 unsigned int id;
11311 bfd_size_type amt;
11312 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11313
11314 if (htab == NULL)
11315 return -1;
11316
11317 htab->sec_info_arr_size = bfd_get_next_section_id ();
11318 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11319 htab->sec_info = bfd_zmalloc (amt);
11320 if (htab->sec_info == NULL)
11321 return -1;
11322
11323 /* Set toc_off for com, und, abs and ind sections. */
11324 for (id = 0; id < 3; id++)
11325 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11326
11327 return 1;
11328 }
11329
11330 /* Set up for first pass at multitoc partitioning. */
11331
11332 void
11333 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11334 {
11335 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11336
11337 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11338 htab->toc_bfd = NULL;
11339 htab->toc_first_sec = NULL;
11340 }
11341
11342 /* The linker repeatedly calls this function for each TOC input section
11343 and linker generated GOT section. Group input bfds such that the toc
11344 within a group is less than 64k in size. */
11345
11346 bfd_boolean
11347 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11348 {
11349 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11350 bfd_vma addr, off, limit;
11351
11352 if (htab == NULL)
11353 return FALSE;
11354
11355 if (!htab->second_toc_pass)
11356 {
11357 /* Keep track of the first .toc or .got section for this input bfd. */
11358 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11359
11360 if (new_bfd)
11361 {
11362 htab->toc_bfd = isec->owner;
11363 htab->toc_first_sec = isec;
11364 }
11365
11366 addr = isec->output_offset + isec->output_section->vma;
11367 off = addr - htab->toc_curr;
11368 limit = 0x80008000;
11369 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11370 limit = 0x10000;
11371 if (off + isec->size > limit)
11372 {
11373 addr = (htab->toc_first_sec->output_offset
11374 + htab->toc_first_sec->output_section->vma);
11375 htab->toc_curr = addr;
11376 htab->toc_curr &= -TOC_BASE_ALIGN;
11377 }
11378
11379 /* toc_curr is the base address of this toc group. Set elf_gp
11380 for the input section to be the offset relative to the
11381 output toc base plus 0x8000. Making the input elf_gp an
11382 offset allows us to move the toc as a whole without
11383 recalculating input elf_gp. */
11384 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11385 off += TOC_BASE_OFF;
11386
11387 /* Die if someone uses a linker script that doesn't keep input
11388 file .toc and .got together. */
11389 if (new_bfd
11390 && elf_gp (isec->owner) != 0
11391 && elf_gp (isec->owner) != off)
11392 return FALSE;
11393
11394 elf_gp (isec->owner) = off;
11395 return TRUE;
11396 }
11397
11398 /* During the second pass toc_first_sec points to the start of
11399 a toc group, and toc_curr is used to track the old elf_gp.
11400 We use toc_bfd to ensure we only look at each bfd once. */
11401 if (htab->toc_bfd == isec->owner)
11402 return TRUE;
11403 htab->toc_bfd = isec->owner;
11404
11405 if (htab->toc_first_sec == NULL
11406 || htab->toc_curr != elf_gp (isec->owner))
11407 {
11408 htab->toc_curr = elf_gp (isec->owner);
11409 htab->toc_first_sec = isec;
11410 }
11411 addr = (htab->toc_first_sec->output_offset
11412 + htab->toc_first_sec->output_section->vma);
11413 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11414 elf_gp (isec->owner) = off;
11415
11416 return TRUE;
11417 }
11418
11419 /* Called via elf_link_hash_traverse to merge GOT entries for global
11420 symbol H. */
11421
11422 static bfd_boolean
11423 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11424 {
11425 if (h->root.type == bfd_link_hash_indirect)
11426 return TRUE;
11427
11428 merge_got_entries (&h->got.glist);
11429
11430 return TRUE;
11431 }
11432
11433 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11434 symbol H. */
11435
11436 static bfd_boolean
11437 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11438 {
11439 struct got_entry *gent;
11440
11441 if (h->root.type == bfd_link_hash_indirect)
11442 return TRUE;
11443
11444 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11445 if (!gent->is_indirect)
11446 allocate_got (h, (struct bfd_link_info *) inf, gent);
11447 return TRUE;
11448 }
11449
11450 /* Called on the first multitoc pass after the last call to
11451 ppc64_elf_next_toc_section. This function removes duplicate GOT
11452 entries. */
11453
11454 bfd_boolean
11455 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11456 {
11457 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11458 struct bfd *ibfd, *ibfd2;
11459 bfd_boolean done_something;
11460
11461 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11462
11463 if (!htab->do_multi_toc)
11464 return FALSE;
11465
11466 /* Merge global sym got entries within a toc group. */
11467 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11468
11469 /* And tlsld_got. */
11470 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11471 {
11472 struct got_entry *ent, *ent2;
11473
11474 if (!is_ppc64_elf (ibfd))
11475 continue;
11476
11477 ent = ppc64_tlsld_got (ibfd);
11478 if (!ent->is_indirect
11479 && ent->got.offset != (bfd_vma) -1)
11480 {
11481 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11482 {
11483 if (!is_ppc64_elf (ibfd2))
11484 continue;
11485
11486 ent2 = ppc64_tlsld_got (ibfd2);
11487 if (!ent2->is_indirect
11488 && ent2->got.offset != (bfd_vma) -1
11489 && elf_gp (ibfd2) == elf_gp (ibfd))
11490 {
11491 ent2->is_indirect = TRUE;
11492 ent2->got.ent = ent;
11493 }
11494 }
11495 }
11496 }
11497
11498 /* Zap sizes of got sections. */
11499 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11500 htab->elf.irelplt->size -= htab->got_reli_size;
11501 htab->got_reli_size = 0;
11502
11503 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11504 {
11505 asection *got, *relgot;
11506
11507 if (!is_ppc64_elf (ibfd))
11508 continue;
11509
11510 got = ppc64_elf_tdata (ibfd)->got;
11511 if (got != NULL)
11512 {
11513 got->rawsize = got->size;
11514 got->size = 0;
11515 relgot = ppc64_elf_tdata (ibfd)->relgot;
11516 relgot->rawsize = relgot->size;
11517 relgot->size = 0;
11518 }
11519 }
11520
11521 /* Now reallocate the got, local syms first. We don't need to
11522 allocate section contents again since we never increase size. */
11523 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11524 {
11525 struct got_entry **lgot_ents;
11526 struct got_entry **end_lgot_ents;
11527 struct plt_entry **local_plt;
11528 struct plt_entry **end_local_plt;
11529 unsigned char *lgot_masks;
11530 bfd_size_type locsymcount;
11531 Elf_Internal_Shdr *symtab_hdr;
11532 asection *s;
11533
11534 if (!is_ppc64_elf (ibfd))
11535 continue;
11536
11537 lgot_ents = elf_local_got_ents (ibfd);
11538 if (!lgot_ents)
11539 continue;
11540
11541 symtab_hdr = &elf_symtab_hdr (ibfd);
11542 locsymcount = symtab_hdr->sh_info;
11543 end_lgot_ents = lgot_ents + locsymcount;
11544 local_plt = (struct plt_entry **) end_lgot_ents;
11545 end_local_plt = local_plt + locsymcount;
11546 lgot_masks = (unsigned char *) end_local_plt;
11547 s = ppc64_elf_tdata (ibfd)->got;
11548 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11549 {
11550 struct got_entry *ent;
11551
11552 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11553 {
11554 unsigned int ent_size = 8;
11555 unsigned int rel_size = sizeof (Elf64_External_Rela);
11556
11557 ent->got.offset = s->size;
11558 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11559 {
11560 ent_size *= 2;
11561 rel_size *= 2;
11562 }
11563 s->size += ent_size;
11564 if ((*lgot_masks & PLT_IFUNC) != 0)
11565 {
11566 htab->elf.irelplt->size += rel_size;
11567 htab->got_reli_size += rel_size;
11568 }
11569 else if (bfd_link_pic (info))
11570 {
11571 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11572 srel->size += rel_size;
11573 }
11574 }
11575 }
11576 }
11577
11578 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11579
11580 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11581 {
11582 struct got_entry *ent;
11583
11584 if (!is_ppc64_elf (ibfd))
11585 continue;
11586
11587 ent = ppc64_tlsld_got (ibfd);
11588 if (!ent->is_indirect
11589 && ent->got.offset != (bfd_vma) -1)
11590 {
11591 asection *s = ppc64_elf_tdata (ibfd)->got;
11592 ent->got.offset = s->size;
11593 s->size += 16;
11594 if (bfd_link_pic (info))
11595 {
11596 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11597 srel->size += sizeof (Elf64_External_Rela);
11598 }
11599 }
11600 }
11601
11602 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11603 if (!done_something)
11604 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11605 {
11606 asection *got;
11607
11608 if (!is_ppc64_elf (ibfd))
11609 continue;
11610
11611 got = ppc64_elf_tdata (ibfd)->got;
11612 if (got != NULL)
11613 {
11614 done_something = got->rawsize != got->size;
11615 if (done_something)
11616 break;
11617 }
11618 }
11619
11620 if (done_something)
11621 (*htab->params->layout_sections_again) ();
11622
11623 /* Set up for second pass over toc sections to recalculate elf_gp
11624 on input sections. */
11625 htab->toc_bfd = NULL;
11626 htab->toc_first_sec = NULL;
11627 htab->second_toc_pass = TRUE;
11628 return done_something;
11629 }
11630
11631 /* Called after second pass of multitoc partitioning. */
11632
11633 void
11634 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11635 {
11636 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11637
11638 /* After the second pass, toc_curr tracks the TOC offset used
11639 for code sections below in ppc64_elf_next_input_section. */
11640 htab->toc_curr = TOC_BASE_OFF;
11641 }
11642
11643 /* No toc references were found in ISEC. If the code in ISEC makes no
11644 calls, then there's no need to use toc adjusting stubs when branching
11645 into ISEC. Actually, indirect calls from ISEC are OK as they will
11646 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11647 needed, and 2 if a cyclical call-graph was found but no other reason
11648 for a stub was detected. If called from the top level, a return of
11649 2 means the same as a return of 0. */
11650
11651 static int
11652 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11653 {
11654 int ret;
11655
11656 /* Mark this section as checked. */
11657 isec->call_check_done = 1;
11658
11659 /* We know none of our code bearing sections will need toc stubs. */
11660 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11661 return 0;
11662
11663 if (isec->size == 0)
11664 return 0;
11665
11666 if (isec->output_section == NULL)
11667 return 0;
11668
11669 ret = 0;
11670 if (isec->reloc_count != 0)
11671 {
11672 Elf_Internal_Rela *relstart, *rel;
11673 Elf_Internal_Sym *local_syms;
11674 struct ppc_link_hash_table *htab;
11675
11676 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11677 info->keep_memory);
11678 if (relstart == NULL)
11679 return -1;
11680
11681 /* Look for branches to outside of this section. */
11682 local_syms = NULL;
11683 htab = ppc_hash_table (info);
11684 if (htab == NULL)
11685 return -1;
11686
11687 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11688 {
11689 enum elf_ppc64_reloc_type r_type;
11690 unsigned long r_symndx;
11691 struct elf_link_hash_entry *h;
11692 struct ppc_link_hash_entry *eh;
11693 Elf_Internal_Sym *sym;
11694 asection *sym_sec;
11695 struct _opd_sec_data *opd;
11696 bfd_vma sym_value;
11697 bfd_vma dest;
11698
11699 r_type = ELF64_R_TYPE (rel->r_info);
11700 if (r_type != R_PPC64_REL24
11701 && r_type != R_PPC64_REL14
11702 && r_type != R_PPC64_REL14_BRTAKEN
11703 && r_type != R_PPC64_REL14_BRNTAKEN)
11704 continue;
11705
11706 r_symndx = ELF64_R_SYM (rel->r_info);
11707 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11708 isec->owner))
11709 {
11710 ret = -1;
11711 break;
11712 }
11713
11714 /* Calls to dynamic lib functions go through a plt call stub
11715 that uses r2. */
11716 eh = (struct ppc_link_hash_entry *) h;
11717 if (eh != NULL
11718 && (eh->elf.plt.plist != NULL
11719 || (eh->oh != NULL
11720 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11721 {
11722 ret = 1;
11723 break;
11724 }
11725
11726 if (sym_sec == NULL)
11727 /* Ignore other undefined symbols. */
11728 continue;
11729
11730 /* Assume branches to other sections not included in the
11731 link need stubs too, to cover -R and absolute syms. */
11732 if (sym_sec->output_section == NULL)
11733 {
11734 ret = 1;
11735 break;
11736 }
11737
11738 if (h == NULL)
11739 sym_value = sym->st_value;
11740 else
11741 {
11742 if (h->root.type != bfd_link_hash_defined
11743 && h->root.type != bfd_link_hash_defweak)
11744 abort ();
11745 sym_value = h->root.u.def.value;
11746 }
11747 sym_value += rel->r_addend;
11748
11749 /* If this branch reloc uses an opd sym, find the code section. */
11750 opd = get_opd_info (sym_sec);
11751 if (opd != NULL)
11752 {
11753 if (h == NULL && opd->adjust != NULL)
11754 {
11755 long adjust;
11756
11757 adjust = opd->adjust[OPD_NDX (sym_value)];
11758 if (adjust == -1)
11759 /* Assume deleted functions won't ever be called. */
11760 continue;
11761 sym_value += adjust;
11762 }
11763
11764 dest = opd_entry_value (sym_sec, sym_value,
11765 &sym_sec, NULL, FALSE);
11766 if (dest == (bfd_vma) -1)
11767 continue;
11768 }
11769 else
11770 dest = (sym_value
11771 + sym_sec->output_offset
11772 + sym_sec->output_section->vma);
11773
11774 /* Ignore branch to self. */
11775 if (sym_sec == isec)
11776 continue;
11777
11778 /* If the called function uses the toc, we need a stub. */
11779 if (sym_sec->has_toc_reloc
11780 || sym_sec->makes_toc_func_call)
11781 {
11782 ret = 1;
11783 break;
11784 }
11785
11786 /* Assume any branch that needs a long branch stub might in fact
11787 need a plt_branch stub. A plt_branch stub uses r2. */
11788 else if (dest - (isec->output_offset
11789 + isec->output_section->vma
11790 + rel->r_offset) + (1 << 25)
11791 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11792 ? h->other
11793 : sym->st_other))
11794 {
11795 ret = 1;
11796 break;
11797 }
11798
11799 /* If calling back to a section in the process of being
11800 tested, we can't say for sure that no toc adjusting stubs
11801 are needed, so don't return zero. */
11802 else if (sym_sec->call_check_in_progress)
11803 ret = 2;
11804
11805 /* Branches to another section that itself doesn't have any TOC
11806 references are OK. Recursively call ourselves to check. */
11807 else if (!sym_sec->call_check_done)
11808 {
11809 int recur;
11810
11811 /* Mark current section as indeterminate, so that other
11812 sections that call back to current won't be marked as
11813 known. */
11814 isec->call_check_in_progress = 1;
11815 recur = toc_adjusting_stub_needed (info, sym_sec);
11816 isec->call_check_in_progress = 0;
11817
11818 if (recur != 0)
11819 {
11820 ret = recur;
11821 if (recur != 2)
11822 break;
11823 }
11824 }
11825 }
11826
11827 if (local_syms != NULL
11828 && (elf_symtab_hdr (isec->owner).contents
11829 != (unsigned char *) local_syms))
11830 free (local_syms);
11831 if (elf_section_data (isec)->relocs != relstart)
11832 free (relstart);
11833 }
11834
11835 if ((ret & 1) == 0
11836 && isec->map_head.s != NULL
11837 && (strcmp (isec->output_section->name, ".init") == 0
11838 || strcmp (isec->output_section->name, ".fini") == 0))
11839 {
11840 if (isec->map_head.s->has_toc_reloc
11841 || isec->map_head.s->makes_toc_func_call)
11842 ret = 1;
11843 else if (!isec->map_head.s->call_check_done)
11844 {
11845 int recur;
11846 isec->call_check_in_progress = 1;
11847 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11848 isec->call_check_in_progress = 0;
11849 if (recur != 0)
11850 ret = recur;
11851 }
11852 }
11853
11854 if (ret == 1)
11855 isec->makes_toc_func_call = 1;
11856
11857 return ret;
11858 }
11859
11860 /* The linker repeatedly calls this function for each input section,
11861 in the order that input sections are linked into output sections.
11862 Build lists of input sections to determine groupings between which
11863 we may insert linker stubs. */
11864
11865 bfd_boolean
11866 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11867 {
11868 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11869
11870 if (htab == NULL)
11871 return FALSE;
11872
11873 if ((isec->output_section->flags & SEC_CODE) != 0
11874 && isec->output_section->id < htab->sec_info_arr_size)
11875 {
11876 /* This happens to make the list in reverse order,
11877 which is what we want. */
11878 htab->sec_info[isec->id].u.list
11879 = htab->sec_info[isec->output_section->id].u.list;
11880 htab->sec_info[isec->output_section->id].u.list = isec;
11881 }
11882
11883 if (htab->multi_toc_needed)
11884 {
11885 /* Analyse sections that aren't already flagged as needing a
11886 valid toc pointer. Exclude .fixup for the linux kernel.
11887 .fixup contains branches, but only back to the function that
11888 hit an exception. */
11889 if (!(isec->has_toc_reloc
11890 || (isec->flags & SEC_CODE) == 0
11891 || strcmp (isec->name, ".fixup") == 0
11892 || isec->call_check_done))
11893 {
11894 if (toc_adjusting_stub_needed (info, isec) < 0)
11895 return FALSE;
11896 }
11897 /* Make all sections use the TOC assigned for this object file.
11898 This will be wrong for pasted sections; We fix that in
11899 check_pasted_section(). */
11900 if (elf_gp (isec->owner) != 0)
11901 htab->toc_curr = elf_gp (isec->owner);
11902 }
11903
11904 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11905 return TRUE;
11906 }
11907
11908 /* Check that all .init and .fini sections use the same toc, if they
11909 have toc relocs. */
11910
11911 static bfd_boolean
11912 check_pasted_section (struct bfd_link_info *info, const char *name)
11913 {
11914 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11915
11916 if (o != NULL)
11917 {
11918 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11919 bfd_vma toc_off = 0;
11920 asection *i;
11921
11922 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11923 if (i->has_toc_reloc)
11924 {
11925 if (toc_off == 0)
11926 toc_off = htab->sec_info[i->id].toc_off;
11927 else if (toc_off != htab->sec_info[i->id].toc_off)
11928 return FALSE;
11929 }
11930
11931 if (toc_off == 0)
11932 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11933 if (i->makes_toc_func_call)
11934 {
11935 toc_off = htab->sec_info[i->id].toc_off;
11936 break;
11937 }
11938
11939 /* Make sure the whole pasted function uses the same toc offset. */
11940 if (toc_off != 0)
11941 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11942 htab->sec_info[i->id].toc_off = toc_off;
11943 }
11944 return TRUE;
11945 }
11946
11947 bfd_boolean
11948 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11949 {
11950 return (check_pasted_section (info, ".init")
11951 & check_pasted_section (info, ".fini"));
11952 }
11953
11954 /* See whether we can group stub sections together. Grouping stub
11955 sections may result in fewer stubs. More importantly, we need to
11956 put all .init* and .fini* stubs at the beginning of the .init or
11957 .fini output sections respectively, because glibc splits the
11958 _init and _fini functions into multiple parts. Putting a stub in
11959 the middle of a function is not a good idea. */
11960
11961 static bfd_boolean
11962 group_sections (struct bfd_link_info *info,
11963 bfd_size_type stub_group_size,
11964 bfd_boolean stubs_always_before_branch)
11965 {
11966 struct ppc_link_hash_table *htab;
11967 asection *osec;
11968 bfd_size_type stub14_group_size;
11969 bfd_boolean suppress_size_errors;
11970
11971 htab = ppc_hash_table (info);
11972 if (htab == NULL)
11973 return FALSE;
11974
11975 suppress_size_errors = FALSE;
11976 stub14_group_size = stub_group_size >> 10;
11977 if (stub_group_size == 1)
11978 {
11979 /* Default values. */
11980 if (stubs_always_before_branch)
11981 {
11982 stub_group_size = 0x1e00000;
11983 stub14_group_size = 0x7800;
11984 }
11985 else
11986 {
11987 stub_group_size = 0x1c00000;
11988 stub14_group_size = 0x7000;
11989 }
11990 suppress_size_errors = TRUE;
11991 }
11992
11993 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11994 {
11995 asection *tail;
11996
11997 if (osec->id >= htab->sec_info_arr_size)
11998 continue;
11999
12000 tail = htab->sec_info[osec->id].u.list;
12001 while (tail != NULL)
12002 {
12003 asection *curr;
12004 asection *prev;
12005 bfd_size_type total;
12006 bfd_boolean big_sec;
12007 bfd_vma curr_toc;
12008 struct map_stub *group;
12009
12010 curr = tail;
12011 total = tail->size;
12012 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12013 && ppc64_elf_section_data (tail)->has_14bit_branch
12014 ? stub14_group_size : stub_group_size);
12015 if (big_sec && !suppress_size_errors)
12016 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12017 tail->owner, tail);
12018 curr_toc = htab->sec_info[tail->id].toc_off;
12019
12020 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12021 && ((total += curr->output_offset - prev->output_offset)
12022 < (ppc64_elf_section_data (prev) != NULL
12023 && ppc64_elf_section_data (prev)->has_14bit_branch
12024 ? stub14_group_size : stub_group_size))
12025 && htab->sec_info[prev->id].toc_off == curr_toc)
12026 curr = prev;
12027
12028 /* OK, the size from the start of CURR to the end is less
12029 than stub_group_size and thus can be handled by one stub
12030 section. (or the tail section is itself larger than
12031 stub_group_size, in which case we may be toast.) We
12032 should really be keeping track of the total size of stubs
12033 added here, as stubs contribute to the final output
12034 section size. That's a little tricky, and this way will
12035 only break if stubs added make the total size more than
12036 2^25, ie. for the default stub_group_size, if stubs total
12037 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12038 group = bfd_alloc (curr->owner, sizeof (*group));
12039 if (group == NULL)
12040 return FALSE;
12041 group->link_sec = curr;
12042 group->stub_sec = NULL;
12043 group->needs_save_res = 0;
12044 group->next = htab->group;
12045 htab->group = group;
12046 do
12047 {
12048 prev = htab->sec_info[tail->id].u.list;
12049 /* Set up this stub group. */
12050 htab->sec_info[tail->id].u.group = group;
12051 }
12052 while (tail != curr && (tail = prev) != NULL);
12053
12054 /* But wait, there's more! Input sections up to stub_group_size
12055 bytes before the stub section can be handled by it too.
12056 Don't do this if we have a really large section after the
12057 stubs, as adding more stubs increases the chance that
12058 branches may not reach into the stub section. */
12059 if (!stubs_always_before_branch && !big_sec)
12060 {
12061 total = 0;
12062 while (prev != NULL
12063 && ((total += tail->output_offset - prev->output_offset)
12064 < (ppc64_elf_section_data (prev) != NULL
12065 && ppc64_elf_section_data (prev)->has_14bit_branch
12066 ? stub14_group_size : stub_group_size))
12067 && htab->sec_info[prev->id].toc_off == curr_toc)
12068 {
12069 tail = prev;
12070 prev = htab->sec_info[tail->id].u.list;
12071 htab->sec_info[tail->id].u.group = group;
12072 }
12073 }
12074 tail = prev;
12075 }
12076 }
12077 return TRUE;
12078 }
12079
12080 static const unsigned char glink_eh_frame_cie[] =
12081 {
12082 0, 0, 0, 16, /* length. */
12083 0, 0, 0, 0, /* id. */
12084 1, /* CIE version. */
12085 'z', 'R', 0, /* Augmentation string. */
12086 4, /* Code alignment. */
12087 0x78, /* Data alignment. */
12088 65, /* RA reg. */
12089 1, /* Augmentation size. */
12090 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12091 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12092 0, 0, 0, 0
12093 };
12094
12095 /* Stripping output sections is normally done before dynamic section
12096 symbols have been allocated. This function is called later, and
12097 handles cases like htab->brlt which is mapped to its own output
12098 section. */
12099
12100 static void
12101 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12102 {
12103 if (isec->size == 0
12104 && isec->output_section->size == 0
12105 && !(isec->output_section->flags & SEC_KEEP)
12106 && !bfd_section_removed_from_list (info->output_bfd,
12107 isec->output_section)
12108 && elf_section_data (isec->output_section)->dynindx == 0)
12109 {
12110 isec->output_section->flags |= SEC_EXCLUDE;
12111 bfd_section_list_remove (info->output_bfd, isec->output_section);
12112 info->output_bfd->section_count--;
12113 }
12114 }
12115
12116 /* Determine and set the size of the stub section for a final link.
12117
12118 The basic idea here is to examine all the relocations looking for
12119 PC-relative calls to a target that is unreachable with a "bl"
12120 instruction. */
12121
12122 bfd_boolean
12123 ppc64_elf_size_stubs (struct bfd_link_info *info)
12124 {
12125 bfd_size_type stub_group_size;
12126 bfd_boolean stubs_always_before_branch;
12127 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12128
12129 if (htab == NULL)
12130 return FALSE;
12131
12132 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12133 htab->params->plt_thread_safe = 1;
12134 if (!htab->opd_abi)
12135 htab->params->plt_thread_safe = 0;
12136 else if (htab->params->plt_thread_safe == -1)
12137 {
12138 static const char *const thread_starter[] =
12139 {
12140 "pthread_create",
12141 /* libstdc++ */
12142 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12143 /* librt */
12144 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12145 "mq_notify", "create_timer",
12146 /* libanl */
12147 "getaddrinfo_a",
12148 /* libgomp */
12149 "GOMP_parallel",
12150 "GOMP_parallel_start",
12151 "GOMP_parallel_loop_static",
12152 "GOMP_parallel_loop_static_start",
12153 "GOMP_parallel_loop_dynamic",
12154 "GOMP_parallel_loop_dynamic_start",
12155 "GOMP_parallel_loop_guided",
12156 "GOMP_parallel_loop_guided_start",
12157 "GOMP_parallel_loop_runtime",
12158 "GOMP_parallel_loop_runtime_start",
12159 "GOMP_parallel_sections",
12160 "GOMP_parallel_sections_start",
12161 /* libgo */
12162 "__go_go",
12163 };
12164 unsigned i;
12165
12166 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12167 {
12168 struct elf_link_hash_entry *h;
12169 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12170 FALSE, FALSE, TRUE);
12171 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12172 if (htab->params->plt_thread_safe)
12173 break;
12174 }
12175 }
12176 stubs_always_before_branch = htab->params->group_size < 0;
12177 if (htab->params->group_size < 0)
12178 stub_group_size = -htab->params->group_size;
12179 else
12180 stub_group_size = htab->params->group_size;
12181
12182 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12183 return FALSE;
12184
12185 while (1)
12186 {
12187 bfd *input_bfd;
12188 unsigned int bfd_indx;
12189 struct map_stub *group;
12190 asection *stub_sec;
12191
12192 htab->stub_iteration += 1;
12193
12194 for (input_bfd = info->input_bfds, bfd_indx = 0;
12195 input_bfd != NULL;
12196 input_bfd = input_bfd->link.next, bfd_indx++)
12197 {
12198 Elf_Internal_Shdr *symtab_hdr;
12199 asection *section;
12200 Elf_Internal_Sym *local_syms = NULL;
12201
12202 if (!is_ppc64_elf (input_bfd))
12203 continue;
12204
12205 /* We'll need the symbol table in a second. */
12206 symtab_hdr = &elf_symtab_hdr (input_bfd);
12207 if (symtab_hdr->sh_info == 0)
12208 continue;
12209
12210 /* Walk over each section attached to the input bfd. */
12211 for (section = input_bfd->sections;
12212 section != NULL;
12213 section = section->next)
12214 {
12215 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12216
12217 /* If there aren't any relocs, then there's nothing more
12218 to do. */
12219 if ((section->flags & SEC_RELOC) == 0
12220 || (section->flags & SEC_ALLOC) == 0
12221 || (section->flags & SEC_LOAD) == 0
12222 || (section->flags & SEC_CODE) == 0
12223 || section->reloc_count == 0)
12224 continue;
12225
12226 /* If this section is a link-once section that will be
12227 discarded, then don't create any stubs. */
12228 if (section->output_section == NULL
12229 || section->output_section->owner != info->output_bfd)
12230 continue;
12231
12232 /* Get the relocs. */
12233 internal_relocs
12234 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12235 info->keep_memory);
12236 if (internal_relocs == NULL)
12237 goto error_ret_free_local;
12238
12239 /* Now examine each relocation. */
12240 irela = internal_relocs;
12241 irelaend = irela + section->reloc_count;
12242 for (; irela < irelaend; irela++)
12243 {
12244 enum elf_ppc64_reloc_type r_type;
12245 unsigned int r_indx;
12246 enum ppc_stub_type stub_type;
12247 struct ppc_stub_hash_entry *stub_entry;
12248 asection *sym_sec, *code_sec;
12249 bfd_vma sym_value, code_value;
12250 bfd_vma destination;
12251 unsigned long local_off;
12252 bfd_boolean ok_dest;
12253 struct ppc_link_hash_entry *hash;
12254 struct ppc_link_hash_entry *fdh;
12255 struct elf_link_hash_entry *h;
12256 Elf_Internal_Sym *sym;
12257 char *stub_name;
12258 const asection *id_sec;
12259 struct _opd_sec_data *opd;
12260 struct plt_entry *plt_ent;
12261
12262 r_type = ELF64_R_TYPE (irela->r_info);
12263 r_indx = ELF64_R_SYM (irela->r_info);
12264
12265 if (r_type >= R_PPC64_max)
12266 {
12267 bfd_set_error (bfd_error_bad_value);
12268 goto error_ret_free_internal;
12269 }
12270
12271 /* Only look for stubs on branch instructions. */
12272 if (r_type != R_PPC64_REL24
12273 && r_type != R_PPC64_REL14
12274 && r_type != R_PPC64_REL14_BRTAKEN
12275 && r_type != R_PPC64_REL14_BRNTAKEN)
12276 continue;
12277
12278 /* Now determine the call target, its name, value,
12279 section. */
12280 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12281 r_indx, input_bfd))
12282 goto error_ret_free_internal;
12283 hash = (struct ppc_link_hash_entry *) h;
12284
12285 ok_dest = FALSE;
12286 fdh = NULL;
12287 sym_value = 0;
12288 if (hash == NULL)
12289 {
12290 sym_value = sym->st_value;
12291 if (sym_sec != NULL
12292 && sym_sec->output_section != NULL)
12293 ok_dest = TRUE;
12294 }
12295 else if (hash->elf.root.type == bfd_link_hash_defined
12296 || hash->elf.root.type == bfd_link_hash_defweak)
12297 {
12298 sym_value = hash->elf.root.u.def.value;
12299 if (sym_sec->output_section != NULL)
12300 ok_dest = TRUE;
12301 }
12302 else if (hash->elf.root.type == bfd_link_hash_undefweak
12303 || hash->elf.root.type == bfd_link_hash_undefined)
12304 {
12305 /* Recognise an old ABI func code entry sym, and
12306 use the func descriptor sym instead if it is
12307 defined. */
12308 if (hash->elf.root.root.string[0] == '.'
12309 && (fdh = lookup_fdh (hash, htab)) != NULL)
12310 {
12311 if (fdh->elf.root.type == bfd_link_hash_defined
12312 || fdh->elf.root.type == bfd_link_hash_defweak)
12313 {
12314 sym_sec = fdh->elf.root.u.def.section;
12315 sym_value = fdh->elf.root.u.def.value;
12316 if (sym_sec->output_section != NULL)
12317 ok_dest = TRUE;
12318 }
12319 else
12320 fdh = NULL;
12321 }
12322 }
12323 else
12324 {
12325 bfd_set_error (bfd_error_bad_value);
12326 goto error_ret_free_internal;
12327 }
12328
12329 destination = 0;
12330 local_off = 0;
12331 if (ok_dest)
12332 {
12333 sym_value += irela->r_addend;
12334 destination = (sym_value
12335 + sym_sec->output_offset
12336 + sym_sec->output_section->vma);
12337 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12338 ? hash->elf.other
12339 : sym->st_other);
12340 }
12341
12342 code_sec = sym_sec;
12343 code_value = sym_value;
12344 opd = get_opd_info (sym_sec);
12345 if (opd != NULL)
12346 {
12347 bfd_vma dest;
12348
12349 if (hash == NULL && opd->adjust != NULL)
12350 {
12351 long adjust = opd->adjust[OPD_NDX (sym_value)];
12352 if (adjust == -1)
12353 continue;
12354 code_value += adjust;
12355 sym_value += adjust;
12356 }
12357 dest = opd_entry_value (sym_sec, sym_value,
12358 &code_sec, &code_value, FALSE);
12359 if (dest != (bfd_vma) -1)
12360 {
12361 destination = dest;
12362 if (fdh != NULL)
12363 {
12364 /* Fixup old ABI sym to point at code
12365 entry. */
12366 hash->elf.root.type = bfd_link_hash_defweak;
12367 hash->elf.root.u.def.section = code_sec;
12368 hash->elf.root.u.def.value = code_value;
12369 }
12370 }
12371 }
12372
12373 /* Determine what (if any) linker stub is needed. */
12374 plt_ent = NULL;
12375 stub_type = ppc_type_of_stub (section, irela, &hash,
12376 &plt_ent, destination,
12377 local_off);
12378
12379 if (stub_type != ppc_stub_plt_call)
12380 {
12381 /* Check whether we need a TOC adjusting stub.
12382 Since the linker pastes together pieces from
12383 different object files when creating the
12384 _init and _fini functions, it may be that a
12385 call to what looks like a local sym is in
12386 fact a call needing a TOC adjustment. */
12387 if (code_sec != NULL
12388 && code_sec->output_section != NULL
12389 && (htab->sec_info[code_sec->id].toc_off
12390 != htab->sec_info[section->id].toc_off)
12391 && (code_sec->has_toc_reloc
12392 || code_sec->makes_toc_func_call))
12393 stub_type = ppc_stub_long_branch_r2off;
12394 }
12395
12396 if (stub_type == ppc_stub_none)
12397 continue;
12398
12399 /* __tls_get_addr calls might be eliminated. */
12400 if (stub_type != ppc_stub_plt_call
12401 && hash != NULL
12402 && (hash == htab->tls_get_addr
12403 || hash == htab->tls_get_addr_fd)
12404 && section->has_tls_reloc
12405 && irela != internal_relocs)
12406 {
12407 /* Get tls info. */
12408 unsigned char *tls_mask;
12409
12410 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12411 irela - 1, input_bfd))
12412 goto error_ret_free_internal;
12413 if (*tls_mask != 0)
12414 continue;
12415 }
12416
12417 if (stub_type == ppc_stub_plt_call
12418 && irela + 1 < irelaend
12419 && irela[1].r_offset == irela->r_offset + 4
12420 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12421 {
12422 if (!tocsave_find (htab, INSERT,
12423 &local_syms, irela + 1, input_bfd))
12424 goto error_ret_free_internal;
12425 }
12426 else if (stub_type == ppc_stub_plt_call)
12427 stub_type = ppc_stub_plt_call_r2save;
12428
12429 /* Support for grouping stub sections. */
12430 id_sec = htab->sec_info[section->id].u.group->link_sec;
12431
12432 /* Get the name of this stub. */
12433 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12434 if (!stub_name)
12435 goto error_ret_free_internal;
12436
12437 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12438 stub_name, FALSE, FALSE);
12439 if (stub_entry != NULL)
12440 {
12441 /* The proper stub has already been created. */
12442 free (stub_name);
12443 if (stub_type == ppc_stub_plt_call_r2save)
12444 stub_entry->stub_type = stub_type;
12445 continue;
12446 }
12447
12448 stub_entry = ppc_add_stub (stub_name, section, info);
12449 if (stub_entry == NULL)
12450 {
12451 free (stub_name);
12452 error_ret_free_internal:
12453 if (elf_section_data (section)->relocs == NULL)
12454 free (internal_relocs);
12455 error_ret_free_local:
12456 if (local_syms != NULL
12457 && (symtab_hdr->contents
12458 != (unsigned char *) local_syms))
12459 free (local_syms);
12460 return FALSE;
12461 }
12462
12463 stub_entry->stub_type = stub_type;
12464 if (stub_type != ppc_stub_plt_call
12465 && stub_type != ppc_stub_plt_call_r2save)
12466 {
12467 stub_entry->target_value = code_value;
12468 stub_entry->target_section = code_sec;
12469 }
12470 else
12471 {
12472 stub_entry->target_value = sym_value;
12473 stub_entry->target_section = sym_sec;
12474 }
12475 stub_entry->h = hash;
12476 stub_entry->plt_ent = plt_ent;
12477 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12478
12479 if (stub_entry->h != NULL)
12480 htab->stub_globals += 1;
12481 }
12482
12483 /* We're done with the internal relocs, free them. */
12484 if (elf_section_data (section)->relocs != internal_relocs)
12485 free (internal_relocs);
12486 }
12487
12488 if (local_syms != NULL
12489 && symtab_hdr->contents != (unsigned char *) local_syms)
12490 {
12491 if (!info->keep_memory)
12492 free (local_syms);
12493 else
12494 symtab_hdr->contents = (unsigned char *) local_syms;
12495 }
12496 }
12497
12498 /* We may have added some stubs. Find out the new size of the
12499 stub sections. */
12500 for (stub_sec = htab->params->stub_bfd->sections;
12501 stub_sec != NULL;
12502 stub_sec = stub_sec->next)
12503 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12504 {
12505 stub_sec->rawsize = stub_sec->size;
12506 stub_sec->size = 0;
12507 stub_sec->reloc_count = 0;
12508 stub_sec->flags &= ~SEC_RELOC;
12509 }
12510
12511 htab->brlt->size = 0;
12512 htab->brlt->reloc_count = 0;
12513 htab->brlt->flags &= ~SEC_RELOC;
12514 if (htab->relbrlt != NULL)
12515 htab->relbrlt->size = 0;
12516
12517 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12518
12519 for (group = htab->group; group != NULL; group = group->next)
12520 if (group->needs_save_res)
12521 group->stub_sec->size += htab->sfpr->size;
12522
12523 if (info->emitrelocations
12524 && htab->glink != NULL && htab->glink->size != 0)
12525 {
12526 htab->glink->reloc_count = 1;
12527 htab->glink->flags |= SEC_RELOC;
12528 }
12529
12530 if (htab->glink_eh_frame != NULL
12531 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12532 && htab->glink_eh_frame->output_section->size != 0)
12533 {
12534 size_t size = 0, align;
12535
12536 for (stub_sec = htab->params->stub_bfd->sections;
12537 stub_sec != NULL;
12538 stub_sec = stub_sec->next)
12539 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12540 size += 24;
12541 if (htab->glink != NULL && htab->glink->size != 0)
12542 size += 24;
12543 if (size != 0)
12544 size += sizeof (glink_eh_frame_cie);
12545 align = 1;
12546 align <<= htab->glink_eh_frame->output_section->alignment_power;
12547 align -= 1;
12548 size = (size + align) & ~align;
12549 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12550 htab->glink_eh_frame->size = size;
12551 }
12552
12553 if (htab->params->plt_stub_align != 0)
12554 for (stub_sec = htab->params->stub_bfd->sections;
12555 stub_sec != NULL;
12556 stub_sec = stub_sec->next)
12557 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12558 stub_sec->size = ((stub_sec->size
12559 + (1 << htab->params->plt_stub_align) - 1)
12560 & -(1 << htab->params->plt_stub_align));
12561
12562 for (stub_sec = htab->params->stub_bfd->sections;
12563 stub_sec != NULL;
12564 stub_sec = stub_sec->next)
12565 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12566 && stub_sec->rawsize != stub_sec->size)
12567 break;
12568
12569 /* Exit from this loop when no stubs have been added, and no stubs
12570 have changed size. */
12571 if (stub_sec == NULL
12572 && (htab->glink_eh_frame == NULL
12573 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12574 break;
12575
12576 /* Ask the linker to do its stuff. */
12577 (*htab->params->layout_sections_again) ();
12578 }
12579
12580 if (htab->glink_eh_frame != NULL
12581 && htab->glink_eh_frame->size != 0)
12582 {
12583 bfd_vma val;
12584 bfd_byte *p, *last_fde;
12585 size_t last_fde_len, size, align, pad;
12586 asection *stub_sec;
12587
12588 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12589 if (p == NULL)
12590 return FALSE;
12591 htab->glink_eh_frame->contents = p;
12592 last_fde = p;
12593
12594 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12595 /* CIE length (rewrite in case little-endian). */
12596 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12597 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12598 p += sizeof (glink_eh_frame_cie);
12599
12600 for (stub_sec = htab->params->stub_bfd->sections;
12601 stub_sec != NULL;
12602 stub_sec = stub_sec->next)
12603 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12604 {
12605 last_fde = p;
12606 last_fde_len = 20;
12607 /* FDE length. */
12608 bfd_put_32 (htab->elf.dynobj, 20, p);
12609 p += 4;
12610 /* CIE pointer. */
12611 val = p - htab->glink_eh_frame->contents;
12612 bfd_put_32 (htab->elf.dynobj, val, p);
12613 p += 4;
12614 /* Offset to stub section, written later. */
12615 p += 4;
12616 /* stub section size. */
12617 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12618 p += 4;
12619 /* Augmentation. */
12620 p += 1;
12621 /* Pad. */
12622 p += 7;
12623 }
12624 if (htab->glink != NULL && htab->glink->size != 0)
12625 {
12626 last_fde = p;
12627 last_fde_len = 20;
12628 /* FDE length. */
12629 bfd_put_32 (htab->elf.dynobj, 20, p);
12630 p += 4;
12631 /* CIE pointer. */
12632 val = p - htab->glink_eh_frame->contents;
12633 bfd_put_32 (htab->elf.dynobj, val, p);
12634 p += 4;
12635 /* Offset to .glink, written later. */
12636 p += 4;
12637 /* .glink size. */
12638 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12639 p += 4;
12640 /* Augmentation. */
12641 p += 1;
12642
12643 *p++ = DW_CFA_advance_loc + 1;
12644 *p++ = DW_CFA_register;
12645 *p++ = 65;
12646 *p++ = htab->opd_abi ? 12 : 0;
12647 *p++ = DW_CFA_advance_loc + 4;
12648 *p++ = DW_CFA_restore_extended;
12649 *p++ = 65;
12650 }
12651 /* Subsume any padding into the last FDE if user .eh_frame
12652 sections are aligned more than glink_eh_frame. Otherwise any
12653 zero padding will be seen as a terminator. */
12654 size = p - htab->glink_eh_frame->contents;
12655 align = 1;
12656 align <<= htab->glink_eh_frame->output_section->alignment_power;
12657 align -= 1;
12658 pad = ((size + align) & ~align) - size;
12659 htab->glink_eh_frame->size = size + pad;
12660 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12661 }
12662
12663 maybe_strip_output (info, htab->brlt);
12664 if (htab->glink_eh_frame != NULL)
12665 maybe_strip_output (info, htab->glink_eh_frame);
12666
12667 return TRUE;
12668 }
12669
12670 /* Called after we have determined section placement. If sections
12671 move, we'll be called again. Provide a value for TOCstart. */
12672
12673 bfd_vma
12674 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12675 {
12676 asection *s;
12677 bfd_vma TOCstart, adjust;
12678
12679 if (info != NULL)
12680 {
12681 struct elf_link_hash_entry *h;
12682 struct elf_link_hash_table *htab = elf_hash_table (info);
12683
12684 if (is_elf_hash_table (htab)
12685 && htab->hgot != NULL)
12686 h = htab->hgot;
12687 else
12688 {
12689 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12690 if (is_elf_hash_table (htab))
12691 htab->hgot = h;
12692 }
12693 if (h != NULL
12694 && h->root.type == bfd_link_hash_defined
12695 && !h->root.linker_def
12696 && (!is_elf_hash_table (htab)
12697 || h->def_regular))
12698 {
12699 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12700 + h->root.u.def.section->output_offset
12701 + h->root.u.def.section->output_section->vma);
12702 _bfd_set_gp_value (obfd, TOCstart);
12703 return TOCstart;
12704 }
12705 }
12706
12707 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12708 order. The TOC starts where the first of these sections starts. */
12709 s = bfd_get_section_by_name (obfd, ".got");
12710 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12711 s = bfd_get_section_by_name (obfd, ".toc");
12712 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12713 s = bfd_get_section_by_name (obfd, ".tocbss");
12714 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12715 s = bfd_get_section_by_name (obfd, ".plt");
12716 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12717 {
12718 /* This may happen for
12719 o references to TOC base (SYM@toc / TOC[tc0]) without a
12720 .toc directive
12721 o bad linker script
12722 o --gc-sections and empty TOC sections
12723
12724 FIXME: Warn user? */
12725
12726 /* Look for a likely section. We probably won't even be
12727 using TOCstart. */
12728 for (s = obfd->sections; s != NULL; s = s->next)
12729 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12730 | SEC_EXCLUDE))
12731 == (SEC_ALLOC | SEC_SMALL_DATA))
12732 break;
12733 if (s == NULL)
12734 for (s = obfd->sections; s != NULL; s = s->next)
12735 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12736 == (SEC_ALLOC | SEC_SMALL_DATA))
12737 break;
12738 if (s == NULL)
12739 for (s = obfd->sections; s != NULL; s = s->next)
12740 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12741 == SEC_ALLOC)
12742 break;
12743 if (s == NULL)
12744 for (s = obfd->sections; s != NULL; s = s->next)
12745 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12746 break;
12747 }
12748
12749 TOCstart = 0;
12750 if (s != NULL)
12751 TOCstart = s->output_section->vma + s->output_offset;
12752
12753 /* Force alignment. */
12754 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12755 TOCstart -= adjust;
12756 _bfd_set_gp_value (obfd, TOCstart);
12757
12758 if (info != NULL && s != NULL)
12759 {
12760 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12761
12762 if (htab != NULL)
12763 {
12764 if (htab->elf.hgot != NULL)
12765 {
12766 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12767 htab->elf.hgot->root.u.def.section = s;
12768 }
12769 }
12770 else
12771 {
12772 struct bfd_link_hash_entry *bh = NULL;
12773 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12774 s, TOC_BASE_OFF - adjust,
12775 NULL, FALSE, FALSE, &bh);
12776 }
12777 }
12778 return TOCstart;
12779 }
12780
12781 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12782 write out any global entry stubs. */
12783
12784 static bfd_boolean
12785 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12786 {
12787 struct bfd_link_info *info;
12788 struct ppc_link_hash_table *htab;
12789 struct plt_entry *pent;
12790 asection *s;
12791
12792 if (h->root.type == bfd_link_hash_indirect)
12793 return TRUE;
12794
12795 if (!h->pointer_equality_needed)
12796 return TRUE;
12797
12798 if (h->def_regular)
12799 return TRUE;
12800
12801 info = inf;
12802 htab = ppc_hash_table (info);
12803 if (htab == NULL)
12804 return FALSE;
12805
12806 s = htab->glink;
12807 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12808 if (pent->plt.offset != (bfd_vma) -1
12809 && pent->addend == 0)
12810 {
12811 bfd_byte *p;
12812 asection *plt;
12813 bfd_vma off;
12814
12815 p = s->contents + h->root.u.def.value;
12816 plt = htab->elf.splt;
12817 if (!htab->elf.dynamic_sections_created
12818 || h->dynindx == -1)
12819 plt = htab->elf.iplt;
12820 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12821 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12822
12823 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12824 {
12825 info->callbacks->einfo
12826 (_("%P: linkage table error against `%T'\n"),
12827 h->root.root.string);
12828 bfd_set_error (bfd_error_bad_value);
12829 htab->stub_error = TRUE;
12830 }
12831
12832 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12833 if (htab->params->emit_stub_syms)
12834 {
12835 size_t len = strlen (h->root.root.string);
12836 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12837
12838 if (name == NULL)
12839 return FALSE;
12840
12841 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12842 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12843 if (h == NULL)
12844 return FALSE;
12845 if (h->root.type == bfd_link_hash_new)
12846 {
12847 h->root.type = bfd_link_hash_defined;
12848 h->root.u.def.section = s;
12849 h->root.u.def.value = p - s->contents;
12850 h->ref_regular = 1;
12851 h->def_regular = 1;
12852 h->ref_regular_nonweak = 1;
12853 h->forced_local = 1;
12854 h->non_elf = 0;
12855 h->root.linker_def = 1;
12856 }
12857 }
12858
12859 if (PPC_HA (off) != 0)
12860 {
12861 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12862 p += 4;
12863 }
12864 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12865 p += 4;
12866 bfd_put_32 (s->owner, MTCTR_R12, p);
12867 p += 4;
12868 bfd_put_32 (s->owner, BCTR, p);
12869 break;
12870 }
12871 return TRUE;
12872 }
12873
12874 /* Build all the stubs associated with the current output file.
12875 The stubs are kept in a hash table attached to the main linker
12876 hash table. This function is called via gldelf64ppc_finish. */
12877
12878 bfd_boolean
12879 ppc64_elf_build_stubs (struct bfd_link_info *info,
12880 char **stats)
12881 {
12882 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12883 struct map_stub *group;
12884 asection *stub_sec;
12885 bfd_byte *p;
12886 int stub_sec_count = 0;
12887
12888 if (htab == NULL)
12889 return FALSE;
12890
12891 /* Allocate memory to hold the linker stubs. */
12892 for (stub_sec = htab->params->stub_bfd->sections;
12893 stub_sec != NULL;
12894 stub_sec = stub_sec->next)
12895 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12896 && stub_sec->size != 0)
12897 {
12898 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12899 if (stub_sec->contents == NULL)
12900 return FALSE;
12901 /* We want to check that built size is the same as calculated
12902 size. rawsize is a convenient location to use. */
12903 stub_sec->rawsize = stub_sec->size;
12904 stub_sec->size = 0;
12905 }
12906
12907 if (htab->glink != NULL && htab->glink->size != 0)
12908 {
12909 unsigned int indx;
12910 bfd_vma plt0;
12911
12912 /* Build the .glink plt call stub. */
12913 if (htab->params->emit_stub_syms)
12914 {
12915 struct elf_link_hash_entry *h;
12916 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12917 TRUE, FALSE, FALSE);
12918 if (h == NULL)
12919 return FALSE;
12920 if (h->root.type == bfd_link_hash_new)
12921 {
12922 h->root.type = bfd_link_hash_defined;
12923 h->root.u.def.section = htab->glink;
12924 h->root.u.def.value = 8;
12925 h->ref_regular = 1;
12926 h->def_regular = 1;
12927 h->ref_regular_nonweak = 1;
12928 h->forced_local = 1;
12929 h->non_elf = 0;
12930 h->root.linker_def = 1;
12931 }
12932 }
12933 plt0 = (htab->elf.splt->output_section->vma
12934 + htab->elf.splt->output_offset
12935 - 16);
12936 if (info->emitrelocations)
12937 {
12938 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12939 if (r == NULL)
12940 return FALSE;
12941 r->r_offset = (htab->glink->output_offset
12942 + htab->glink->output_section->vma);
12943 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12944 r->r_addend = plt0;
12945 }
12946 p = htab->glink->contents;
12947 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12948 bfd_put_64 (htab->glink->owner, plt0, p);
12949 p += 8;
12950 if (htab->opd_abi)
12951 {
12952 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12953 p += 4;
12954 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12955 p += 4;
12956 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12957 p += 4;
12958 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12959 p += 4;
12960 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12961 p += 4;
12962 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12963 p += 4;
12964 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12965 p += 4;
12966 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12967 p += 4;
12968 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12969 p += 4;
12970 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12971 p += 4;
12972 }
12973 else
12974 {
12975 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12976 p += 4;
12977 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12978 p += 4;
12979 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12980 p += 4;
12981 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12982 p += 4;
12983 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12984 p += 4;
12985 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12986 p += 4;
12987 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12988 p += 4;
12989 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12990 p += 4;
12991 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12992 p += 4;
12993 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12994 p += 4;
12995 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12996 p += 4;
12997 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12998 p += 4;
12999 }
13000 bfd_put_32 (htab->glink->owner, BCTR, p);
13001 p += 4;
13002 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13003 {
13004 bfd_put_32 (htab->glink->owner, NOP, p);
13005 p += 4;
13006 }
13007
13008 /* Build the .glink lazy link call stubs. */
13009 indx = 0;
13010 while (p < htab->glink->contents + htab->glink->rawsize)
13011 {
13012 if (htab->opd_abi)
13013 {
13014 if (indx < 0x8000)
13015 {
13016 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13017 p += 4;
13018 }
13019 else
13020 {
13021 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13022 p += 4;
13023 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13024 p);
13025 p += 4;
13026 }
13027 }
13028 bfd_put_32 (htab->glink->owner,
13029 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13030 indx++;
13031 p += 4;
13032 }
13033
13034 /* Build .glink global entry stubs. */
13035 if (htab->glink->size > htab->glink->rawsize)
13036 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13037 }
13038
13039 if (htab->brlt != NULL && htab->brlt->size != 0)
13040 {
13041 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13042 htab->brlt->size);
13043 if (htab->brlt->contents == NULL)
13044 return FALSE;
13045 }
13046 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13047 {
13048 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13049 htab->relbrlt->size);
13050 if (htab->relbrlt->contents == NULL)
13051 return FALSE;
13052 }
13053
13054 /* Build the stubs as directed by the stub hash table. */
13055 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13056
13057 for (group = htab->group; group != NULL; group = group->next)
13058 if (group->needs_save_res)
13059 {
13060 stub_sec = group->stub_sec;
13061 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13062 htab->sfpr->size);
13063 if (htab->params->emit_stub_syms)
13064 {
13065 unsigned int i;
13066
13067 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13068 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13069 return FALSE;
13070 }
13071 stub_sec->size += htab->sfpr->size;
13072 }
13073
13074 if (htab->relbrlt != NULL)
13075 htab->relbrlt->reloc_count = 0;
13076
13077 if (htab->params->plt_stub_align != 0)
13078 for (stub_sec = htab->params->stub_bfd->sections;
13079 stub_sec != NULL;
13080 stub_sec = stub_sec->next)
13081 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13082 stub_sec->size = ((stub_sec->size
13083 + (1 << htab->params->plt_stub_align) - 1)
13084 & -(1 << htab->params->plt_stub_align));
13085
13086 for (stub_sec = htab->params->stub_bfd->sections;
13087 stub_sec != NULL;
13088 stub_sec = stub_sec->next)
13089 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13090 {
13091 stub_sec_count += 1;
13092 if (stub_sec->rawsize != stub_sec->size)
13093 break;
13094 }
13095
13096 /* Note that the glink_eh_frame check here is not only testing that
13097 the generated size matched the calculated size but also that
13098 bfd_elf_discard_info didn't make any changes to the section. */
13099 if (stub_sec != NULL
13100 || (htab->glink_eh_frame != NULL
13101 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13102 {
13103 htab->stub_error = TRUE;
13104 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13105 }
13106
13107 if (htab->stub_error)
13108 return FALSE;
13109
13110 if (stats != NULL)
13111 {
13112 *stats = bfd_malloc (500);
13113 if (*stats == NULL)
13114 return FALSE;
13115
13116 sprintf (*stats, _("linker stubs in %u group%s\n"
13117 " branch %lu\n"
13118 " toc adjust %lu\n"
13119 " long branch %lu\n"
13120 " long toc adj %lu\n"
13121 " plt call %lu\n"
13122 " plt call toc %lu\n"
13123 " global entry %lu"),
13124 stub_sec_count,
13125 stub_sec_count == 1 ? "" : "s",
13126 htab->stub_count[ppc_stub_long_branch - 1],
13127 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13128 htab->stub_count[ppc_stub_plt_branch - 1],
13129 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13130 htab->stub_count[ppc_stub_plt_call - 1],
13131 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13132 htab->stub_count[ppc_stub_global_entry - 1]);
13133 }
13134 return TRUE;
13135 }
13136
13137 /* This function undoes the changes made by add_symbol_adjust. */
13138
13139 static bfd_boolean
13140 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13141 {
13142 struct ppc_link_hash_entry *eh;
13143
13144 if (h->root.type == bfd_link_hash_indirect)
13145 return TRUE;
13146
13147 eh = (struct ppc_link_hash_entry *) h;
13148 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13149 return TRUE;
13150
13151 eh->elf.root.type = bfd_link_hash_undefined;
13152 return TRUE;
13153 }
13154
13155 void
13156 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13157 {
13158 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13159
13160 if (htab != NULL)
13161 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13162 }
13163
13164 /* What to do when ld finds relocations against symbols defined in
13165 discarded sections. */
13166
13167 static unsigned int
13168 ppc64_elf_action_discarded (asection *sec)
13169 {
13170 if (strcmp (".opd", sec->name) == 0)
13171 return 0;
13172
13173 if (strcmp (".toc", sec->name) == 0)
13174 return 0;
13175
13176 if (strcmp (".toc1", sec->name) == 0)
13177 return 0;
13178
13179 return _bfd_elf_default_action_discarded (sec);
13180 }
13181
13182 /* The RELOCATE_SECTION function is called by the ELF backend linker
13183 to handle the relocations for a section.
13184
13185 The relocs are always passed as Rela structures; if the section
13186 actually uses Rel structures, the r_addend field will always be
13187 zero.
13188
13189 This function is responsible for adjust the section contents as
13190 necessary, and (if using Rela relocs and generating a
13191 relocatable output file) adjusting the reloc addend as
13192 necessary.
13193
13194 This function does not have to worry about setting the reloc
13195 address or the reloc symbol index.
13196
13197 LOCAL_SYMS is a pointer to the swapped in local symbols.
13198
13199 LOCAL_SECTIONS is an array giving the section in the input file
13200 corresponding to the st_shndx field of each local symbol.
13201
13202 The global hash table entry for the global symbols can be found
13203 via elf_sym_hashes (input_bfd).
13204
13205 When generating relocatable output, this function must handle
13206 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13207 going to be the section symbol corresponding to the output
13208 section, which means that the addend must be adjusted
13209 accordingly. */
13210
13211 static bfd_boolean
13212 ppc64_elf_relocate_section (bfd *output_bfd,
13213 struct bfd_link_info *info,
13214 bfd *input_bfd,
13215 asection *input_section,
13216 bfd_byte *contents,
13217 Elf_Internal_Rela *relocs,
13218 Elf_Internal_Sym *local_syms,
13219 asection **local_sections)
13220 {
13221 struct ppc_link_hash_table *htab;
13222 Elf_Internal_Shdr *symtab_hdr;
13223 struct elf_link_hash_entry **sym_hashes;
13224 Elf_Internal_Rela *rel;
13225 Elf_Internal_Rela *wrel;
13226 Elf_Internal_Rela *relend;
13227 Elf_Internal_Rela outrel;
13228 bfd_byte *loc;
13229 struct got_entry **local_got_ents;
13230 bfd_vma TOCstart;
13231 bfd_boolean ret = TRUE;
13232 bfd_boolean is_opd;
13233 /* Assume 'at' branch hints. */
13234 bfd_boolean is_isa_v2 = TRUE;
13235 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13236
13237 /* Initialize howto table if needed. */
13238 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13239 ppc_howto_init ();
13240
13241 htab = ppc_hash_table (info);
13242 if (htab == NULL)
13243 return FALSE;
13244
13245 /* Don't relocate stub sections. */
13246 if (input_section->owner == htab->params->stub_bfd)
13247 return TRUE;
13248
13249 BFD_ASSERT (is_ppc64_elf (input_bfd));
13250
13251 local_got_ents = elf_local_got_ents (input_bfd);
13252 TOCstart = elf_gp (output_bfd);
13253 symtab_hdr = &elf_symtab_hdr (input_bfd);
13254 sym_hashes = elf_sym_hashes (input_bfd);
13255 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13256
13257 rel = wrel = relocs;
13258 relend = relocs + input_section->reloc_count;
13259 for (; rel < relend; wrel++, rel++)
13260 {
13261 enum elf_ppc64_reloc_type r_type;
13262 bfd_vma addend;
13263 bfd_reloc_status_type r;
13264 Elf_Internal_Sym *sym;
13265 asection *sec;
13266 struct elf_link_hash_entry *h_elf;
13267 struct ppc_link_hash_entry *h;
13268 struct ppc_link_hash_entry *fdh;
13269 const char *sym_name;
13270 unsigned long r_symndx, toc_symndx;
13271 bfd_vma toc_addend;
13272 unsigned char tls_mask, tls_gd, tls_type;
13273 unsigned char sym_type;
13274 bfd_vma relocation;
13275 bfd_boolean unresolved_reloc;
13276 bfd_boolean warned;
13277 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13278 unsigned int insn;
13279 unsigned int mask;
13280 struct ppc_stub_hash_entry *stub_entry;
13281 bfd_vma max_br_offset;
13282 bfd_vma from;
13283 Elf_Internal_Rela orig_rel;
13284 reloc_howto_type *howto;
13285 struct reloc_howto_struct alt_howto;
13286
13287 again:
13288 orig_rel = *rel;
13289
13290 r_type = ELF64_R_TYPE (rel->r_info);
13291 r_symndx = ELF64_R_SYM (rel->r_info);
13292
13293 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13294 symbol of the previous ADDR64 reloc. The symbol gives us the
13295 proper TOC base to use. */
13296 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13297 && wrel != relocs
13298 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13299 && is_opd)
13300 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13301
13302 sym = NULL;
13303 sec = NULL;
13304 h_elf = NULL;
13305 sym_name = NULL;
13306 unresolved_reloc = FALSE;
13307 warned = FALSE;
13308
13309 if (r_symndx < symtab_hdr->sh_info)
13310 {
13311 /* It's a local symbol. */
13312 struct _opd_sec_data *opd;
13313
13314 sym = local_syms + r_symndx;
13315 sec = local_sections[r_symndx];
13316 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13317 sym_type = ELF64_ST_TYPE (sym->st_info);
13318 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13319 opd = get_opd_info (sec);
13320 if (opd != NULL && opd->adjust != NULL)
13321 {
13322 long adjust = opd->adjust[OPD_NDX (sym->st_value
13323 + rel->r_addend)];
13324 if (adjust == -1)
13325 relocation = 0;
13326 else
13327 {
13328 /* If this is a relocation against the opd section sym
13329 and we have edited .opd, adjust the reloc addend so
13330 that ld -r and ld --emit-relocs output is correct.
13331 If it is a reloc against some other .opd symbol,
13332 then the symbol value will be adjusted later. */
13333 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13334 rel->r_addend += adjust;
13335 else
13336 relocation += adjust;
13337 }
13338 }
13339 }
13340 else
13341 {
13342 bfd_boolean ignored;
13343
13344 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13345 r_symndx, symtab_hdr, sym_hashes,
13346 h_elf, sec, relocation,
13347 unresolved_reloc, warned, ignored);
13348 sym_name = h_elf->root.root.string;
13349 sym_type = h_elf->type;
13350 if (sec != NULL
13351 && sec->owner == output_bfd
13352 && strcmp (sec->name, ".opd") == 0)
13353 {
13354 /* This is a symbol defined in a linker script. All
13355 such are defined in output sections, even those
13356 defined by simple assignment from a symbol defined in
13357 an input section. Transfer the symbol to an
13358 appropriate input .opd section, so that a branch to
13359 this symbol will be mapped to the location specified
13360 by the opd entry. */
13361 struct bfd_link_order *lo;
13362 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13363 if (lo->type == bfd_indirect_link_order)
13364 {
13365 asection *isec = lo->u.indirect.section;
13366 if (h_elf->root.u.def.value >= isec->output_offset
13367 && h_elf->root.u.def.value < (isec->output_offset
13368 + isec->size))
13369 {
13370 h_elf->root.u.def.value -= isec->output_offset;
13371 h_elf->root.u.def.section = isec;
13372 sec = isec;
13373 break;
13374 }
13375 }
13376 }
13377 }
13378 h = (struct ppc_link_hash_entry *) h_elf;
13379
13380 if (sec != NULL && discarded_section (sec))
13381 {
13382 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13383 input_bfd, input_section,
13384 contents + rel->r_offset);
13385 wrel->r_offset = rel->r_offset;
13386 wrel->r_info = 0;
13387 wrel->r_addend = 0;
13388
13389 /* For ld -r, remove relocations in debug sections against
13390 sections defined in discarded sections. Not done for
13391 non-debug to preserve relocs in .eh_frame which the
13392 eh_frame editing code expects to be present. */
13393 if (bfd_link_relocatable (info)
13394 && (input_section->flags & SEC_DEBUGGING))
13395 wrel--;
13396
13397 continue;
13398 }
13399
13400 if (bfd_link_relocatable (info))
13401 goto copy_reloc;
13402
13403 if (h != NULL && &h->elf == htab->elf.hgot)
13404 {
13405 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13406 sec = bfd_abs_section_ptr;
13407 unresolved_reloc = FALSE;
13408 }
13409
13410 /* TLS optimizations. Replace instruction sequences and relocs
13411 based on information we collected in tls_optimize. We edit
13412 RELOCS so that --emit-relocs will output something sensible
13413 for the final instruction stream. */
13414 tls_mask = 0;
13415 tls_gd = 0;
13416 toc_symndx = 0;
13417 if (h != NULL)
13418 tls_mask = h->tls_mask;
13419 else if (local_got_ents != NULL)
13420 {
13421 struct plt_entry **local_plt = (struct plt_entry **)
13422 (local_got_ents + symtab_hdr->sh_info);
13423 unsigned char *lgot_masks = (unsigned char *)
13424 (local_plt + symtab_hdr->sh_info);
13425 tls_mask = lgot_masks[r_symndx];
13426 }
13427 if (tls_mask == 0
13428 && (r_type == R_PPC64_TLS
13429 || r_type == R_PPC64_TLSGD
13430 || r_type == R_PPC64_TLSLD))
13431 {
13432 /* Check for toc tls entries. */
13433 unsigned char *toc_tls;
13434
13435 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13436 &local_syms, rel, input_bfd))
13437 return FALSE;
13438
13439 if (toc_tls)
13440 tls_mask = *toc_tls;
13441 }
13442
13443 /* Check that tls relocs are used with tls syms, and non-tls
13444 relocs are used with non-tls syms. */
13445 if (r_symndx != STN_UNDEF
13446 && r_type != R_PPC64_NONE
13447 && (h == NULL
13448 || h->elf.root.type == bfd_link_hash_defined
13449 || h->elf.root.type == bfd_link_hash_defweak)
13450 && (IS_PPC64_TLS_RELOC (r_type)
13451 != (sym_type == STT_TLS
13452 || (sym_type == STT_SECTION
13453 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13454 {
13455 if (tls_mask != 0
13456 && (r_type == R_PPC64_TLS
13457 || r_type == R_PPC64_TLSGD
13458 || r_type == R_PPC64_TLSLD))
13459 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13460 ;
13461 else
13462 info->callbacks->einfo
13463 (!IS_PPC64_TLS_RELOC (r_type)
13464 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13465 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13466 input_bfd, input_section, rel->r_offset,
13467 ppc64_elf_howto_table[r_type]->name,
13468 sym_name);
13469 }
13470
13471 /* Ensure reloc mapping code below stays sane. */
13472 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13473 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13474 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13475 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13476 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13477 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13478 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13479 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13480 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13481 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13482 abort ();
13483
13484 switch (r_type)
13485 {
13486 default:
13487 break;
13488
13489 case R_PPC64_LO_DS_OPT:
13490 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13491 if ((insn & (0x3f << 26)) != 58u << 26)
13492 abort ();
13493 insn += (14u << 26) - (58u << 26);
13494 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13495 r_type = R_PPC64_TOC16_LO;
13496 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13497 break;
13498
13499 case R_PPC64_TOC16:
13500 case R_PPC64_TOC16_LO:
13501 case R_PPC64_TOC16_DS:
13502 case R_PPC64_TOC16_LO_DS:
13503 {
13504 /* Check for toc tls entries. */
13505 unsigned char *toc_tls;
13506 int retval;
13507
13508 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13509 &local_syms, rel, input_bfd);
13510 if (retval == 0)
13511 return FALSE;
13512
13513 if (toc_tls)
13514 {
13515 tls_mask = *toc_tls;
13516 if (r_type == R_PPC64_TOC16_DS
13517 || r_type == R_PPC64_TOC16_LO_DS)
13518 {
13519 if (tls_mask != 0
13520 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13521 goto toctprel;
13522 }
13523 else
13524 {
13525 /* If we found a GD reloc pair, then we might be
13526 doing a GD->IE transition. */
13527 if (retval == 2)
13528 {
13529 tls_gd = TLS_TPRELGD;
13530 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13531 goto tls_ldgd_opt;
13532 }
13533 else if (retval == 3)
13534 {
13535 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13536 goto tls_ldgd_opt;
13537 }
13538 }
13539 }
13540 }
13541 break;
13542
13543 case R_PPC64_GOT_TPREL16_HI:
13544 case R_PPC64_GOT_TPREL16_HA:
13545 if (tls_mask != 0
13546 && (tls_mask & TLS_TPREL) == 0)
13547 {
13548 rel->r_offset -= d_offset;
13549 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13550 r_type = R_PPC64_NONE;
13551 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13552 }
13553 break;
13554
13555 case R_PPC64_GOT_TPREL16_DS:
13556 case R_PPC64_GOT_TPREL16_LO_DS:
13557 if (tls_mask != 0
13558 && (tls_mask & TLS_TPREL) == 0)
13559 {
13560 toctprel:
13561 insn = bfd_get_32 (output_bfd,
13562 contents + rel->r_offset - d_offset);
13563 insn &= 31 << 21;
13564 insn |= 0x3c0d0000; /* addis 0,13,0 */
13565 bfd_put_32 (output_bfd, insn,
13566 contents + rel->r_offset - d_offset);
13567 r_type = R_PPC64_TPREL16_HA;
13568 if (toc_symndx != 0)
13569 {
13570 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13571 rel->r_addend = toc_addend;
13572 /* We changed the symbol. Start over in order to
13573 get h, sym, sec etc. right. */
13574 goto again;
13575 }
13576 else
13577 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13578 }
13579 break;
13580
13581 case R_PPC64_TLS:
13582 if (tls_mask != 0
13583 && (tls_mask & TLS_TPREL) == 0)
13584 {
13585 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13586 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13587 if (insn == 0)
13588 abort ();
13589 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13590 /* Was PPC64_TLS which sits on insn boundary, now
13591 PPC64_TPREL16_LO which is at low-order half-word. */
13592 rel->r_offset += d_offset;
13593 r_type = R_PPC64_TPREL16_LO;
13594 if (toc_symndx != 0)
13595 {
13596 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13597 rel->r_addend = toc_addend;
13598 /* We changed the symbol. Start over in order to
13599 get h, sym, sec etc. right. */
13600 goto again;
13601 }
13602 else
13603 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13604 }
13605 break;
13606
13607 case R_PPC64_GOT_TLSGD16_HI:
13608 case R_PPC64_GOT_TLSGD16_HA:
13609 tls_gd = TLS_TPRELGD;
13610 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13611 goto tls_gdld_hi;
13612 break;
13613
13614 case R_PPC64_GOT_TLSLD16_HI:
13615 case R_PPC64_GOT_TLSLD16_HA:
13616 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13617 {
13618 tls_gdld_hi:
13619 if ((tls_mask & tls_gd) != 0)
13620 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13621 + R_PPC64_GOT_TPREL16_DS);
13622 else
13623 {
13624 rel->r_offset -= d_offset;
13625 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13626 r_type = R_PPC64_NONE;
13627 }
13628 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13629 }
13630 break;
13631
13632 case R_PPC64_GOT_TLSGD16:
13633 case R_PPC64_GOT_TLSGD16_LO:
13634 tls_gd = TLS_TPRELGD;
13635 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13636 goto tls_ldgd_opt;
13637 break;
13638
13639 case R_PPC64_GOT_TLSLD16:
13640 case R_PPC64_GOT_TLSLD16_LO:
13641 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13642 {
13643 unsigned int insn1, insn2, insn3;
13644 bfd_vma offset;
13645
13646 tls_ldgd_opt:
13647 offset = (bfd_vma) -1;
13648 /* If not using the newer R_PPC64_TLSGD/LD to mark
13649 __tls_get_addr calls, we must trust that the call
13650 stays with its arg setup insns, ie. that the next
13651 reloc is the __tls_get_addr call associated with
13652 the current reloc. Edit both insns. */
13653 if (input_section->has_tls_get_addr_call
13654 && rel + 1 < relend
13655 && branch_reloc_hash_match (input_bfd, rel + 1,
13656 htab->tls_get_addr,
13657 htab->tls_get_addr_fd))
13658 offset = rel[1].r_offset;
13659 /* We read the low GOT_TLS (or TOC16) insn because we
13660 need to keep the destination reg. It may be
13661 something other than the usual r3, and moved to r3
13662 before the call by intervening code. */
13663 insn1 = bfd_get_32 (output_bfd,
13664 contents + rel->r_offset - d_offset);
13665 if ((tls_mask & tls_gd) != 0)
13666 {
13667 /* IE */
13668 insn1 &= (0x1f << 21) | (0x1f << 16);
13669 insn1 |= 58 << 26; /* ld */
13670 insn2 = 0x7c636a14; /* add 3,3,13 */
13671 if (offset != (bfd_vma) -1)
13672 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13673 if ((tls_mask & TLS_EXPLICIT) == 0)
13674 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13675 + R_PPC64_GOT_TPREL16_DS);
13676 else
13677 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13678 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13679 }
13680 else
13681 {
13682 /* LE */
13683 insn1 &= 0x1f << 21;
13684 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13685 insn2 = 0x38630000; /* addi 3,3,0 */
13686 if (tls_gd == 0)
13687 {
13688 /* Was an LD reloc. */
13689 if (toc_symndx)
13690 sec = local_sections[toc_symndx];
13691 for (r_symndx = 0;
13692 r_symndx < symtab_hdr->sh_info;
13693 r_symndx++)
13694 if (local_sections[r_symndx] == sec)
13695 break;
13696 if (r_symndx >= symtab_hdr->sh_info)
13697 r_symndx = STN_UNDEF;
13698 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13699 if (r_symndx != STN_UNDEF)
13700 rel->r_addend -= (local_syms[r_symndx].st_value
13701 + sec->output_offset
13702 + sec->output_section->vma);
13703 }
13704 else if (toc_symndx != 0)
13705 {
13706 r_symndx = toc_symndx;
13707 rel->r_addend = toc_addend;
13708 }
13709 r_type = R_PPC64_TPREL16_HA;
13710 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13711 if (offset != (bfd_vma) -1)
13712 {
13713 rel[1].r_info = ELF64_R_INFO (r_symndx,
13714 R_PPC64_TPREL16_LO);
13715 rel[1].r_offset = offset + d_offset;
13716 rel[1].r_addend = rel->r_addend;
13717 }
13718 }
13719 bfd_put_32 (output_bfd, insn1,
13720 contents + rel->r_offset - d_offset);
13721 if (offset != (bfd_vma) -1)
13722 {
13723 insn3 = bfd_get_32 (output_bfd,
13724 contents + offset + 4);
13725 if (insn3 == NOP
13726 || insn3 == CROR_151515 || insn3 == CROR_313131)
13727 {
13728 rel[1].r_offset += 4;
13729 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13730 insn2 = NOP;
13731 }
13732 bfd_put_32 (output_bfd, insn2, contents + offset);
13733 }
13734 if ((tls_mask & tls_gd) == 0
13735 && (tls_gd == 0 || toc_symndx != 0))
13736 {
13737 /* We changed the symbol. Start over in order
13738 to get h, sym, sec etc. right. */
13739 goto again;
13740 }
13741 }
13742 break;
13743
13744 case R_PPC64_TLSGD:
13745 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13746 {
13747 unsigned int insn2, insn3;
13748 bfd_vma offset = rel->r_offset;
13749
13750 if ((tls_mask & TLS_TPRELGD) != 0)
13751 {
13752 /* IE */
13753 r_type = R_PPC64_NONE;
13754 insn2 = 0x7c636a14; /* add 3,3,13 */
13755 }
13756 else
13757 {
13758 /* LE */
13759 if (toc_symndx != 0)
13760 {
13761 r_symndx = toc_symndx;
13762 rel->r_addend = toc_addend;
13763 }
13764 r_type = R_PPC64_TPREL16_LO;
13765 rel->r_offset = offset + d_offset;
13766 insn2 = 0x38630000; /* addi 3,3,0 */
13767 }
13768 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13769 /* Zap the reloc on the _tls_get_addr call too. */
13770 BFD_ASSERT (offset == rel[1].r_offset);
13771 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13772 insn3 = bfd_get_32 (output_bfd,
13773 contents + offset + 4);
13774 if (insn3 == NOP
13775 || insn3 == CROR_151515 || insn3 == CROR_313131)
13776 {
13777 rel->r_offset += 4;
13778 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13779 insn2 = NOP;
13780 }
13781 bfd_put_32 (output_bfd, insn2, contents + offset);
13782 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13783 goto again;
13784 }
13785 break;
13786
13787 case R_PPC64_TLSLD:
13788 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13789 {
13790 unsigned int insn2, insn3;
13791 bfd_vma offset = rel->r_offset;
13792
13793 if (toc_symndx)
13794 sec = local_sections[toc_symndx];
13795 for (r_symndx = 0;
13796 r_symndx < symtab_hdr->sh_info;
13797 r_symndx++)
13798 if (local_sections[r_symndx] == sec)
13799 break;
13800 if (r_symndx >= symtab_hdr->sh_info)
13801 r_symndx = STN_UNDEF;
13802 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13803 if (r_symndx != STN_UNDEF)
13804 rel->r_addend -= (local_syms[r_symndx].st_value
13805 + sec->output_offset
13806 + sec->output_section->vma);
13807
13808 r_type = R_PPC64_TPREL16_LO;
13809 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13810 rel->r_offset = offset + d_offset;
13811 /* Zap the reloc on the _tls_get_addr call too. */
13812 BFD_ASSERT (offset == rel[1].r_offset);
13813 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13814 insn2 = 0x38630000; /* addi 3,3,0 */
13815 insn3 = bfd_get_32 (output_bfd,
13816 contents + offset + 4);
13817 if (insn3 == NOP
13818 || insn3 == CROR_151515 || insn3 == CROR_313131)
13819 {
13820 rel->r_offset += 4;
13821 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13822 insn2 = NOP;
13823 }
13824 bfd_put_32 (output_bfd, insn2, contents + offset);
13825 goto again;
13826 }
13827 break;
13828
13829 case R_PPC64_DTPMOD64:
13830 if (rel + 1 < relend
13831 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13832 && rel[1].r_offset == rel->r_offset + 8)
13833 {
13834 if ((tls_mask & TLS_GD) == 0)
13835 {
13836 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13837 if ((tls_mask & TLS_TPRELGD) != 0)
13838 r_type = R_PPC64_TPREL64;
13839 else
13840 {
13841 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13842 r_type = R_PPC64_NONE;
13843 }
13844 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13845 }
13846 }
13847 else
13848 {
13849 if ((tls_mask & TLS_LD) == 0)
13850 {
13851 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13852 r_type = R_PPC64_NONE;
13853 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13854 }
13855 }
13856 break;
13857
13858 case R_PPC64_TPREL64:
13859 if ((tls_mask & TLS_TPREL) == 0)
13860 {
13861 r_type = R_PPC64_NONE;
13862 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13863 }
13864 break;
13865
13866 case R_PPC64_ENTRY:
13867 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13868 if (!bfd_link_pic (info)
13869 && !info->traditional_format
13870 && relocation + 0x80008000 <= 0xffffffff)
13871 {
13872 unsigned int insn1, insn2;
13873
13874 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13875 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13876 if ((insn1 & ~0xfffc) == LD_R2_0R12
13877 && insn2 == ADD_R2_R2_R12)
13878 {
13879 bfd_put_32 (output_bfd,
13880 LIS_R2 + PPC_HA (relocation),
13881 contents + rel->r_offset);
13882 bfd_put_32 (output_bfd,
13883 ADDI_R2_R2 + PPC_LO (relocation),
13884 contents + rel->r_offset + 4);
13885 }
13886 }
13887 else
13888 {
13889 relocation -= (rel->r_offset
13890 + input_section->output_offset
13891 + input_section->output_section->vma);
13892 if (relocation + 0x80008000 <= 0xffffffff)
13893 {
13894 unsigned int insn1, insn2;
13895
13896 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13897 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13898 if ((insn1 & ~0xfffc) == LD_R2_0R12
13899 && insn2 == ADD_R2_R2_R12)
13900 {
13901 bfd_put_32 (output_bfd,
13902 ADDIS_R2_R12 + PPC_HA (relocation),
13903 contents + rel->r_offset);
13904 bfd_put_32 (output_bfd,
13905 ADDI_R2_R2 + PPC_LO (relocation),
13906 contents + rel->r_offset + 4);
13907 }
13908 }
13909 }
13910 break;
13911
13912 case R_PPC64_REL16_HA:
13913 /* If we are generating a non-PIC executable, edit
13914 . 0: addis 2,12,.TOC.-0b@ha
13915 . addi 2,2,.TOC.-0b@l
13916 used by ELFv2 global entry points to set up r2, to
13917 . lis 2,.TOC.@ha
13918 . addi 2,2,.TOC.@l
13919 if .TOC. is in range. */
13920 if (!bfd_link_pic (info)
13921 && !info->traditional_format
13922 && !htab->opd_abi
13923 && rel->r_addend == d_offset
13924 && h != NULL && &h->elf == htab->elf.hgot
13925 && rel + 1 < relend
13926 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13927 && rel[1].r_offset == rel->r_offset + 4
13928 && rel[1].r_addend == rel->r_addend + 4
13929 && relocation + 0x80008000 <= 0xffffffff)
13930 {
13931 unsigned int insn1, insn2;
13932 bfd_vma offset = rel->r_offset - d_offset;
13933 insn1 = bfd_get_32 (output_bfd, contents + offset);
13934 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13935 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13936 && (insn2 & 0xffff0000) == ADDI_R2_R2)
13937 {
13938 r_type = R_PPC64_ADDR16_HA;
13939 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13940 rel->r_addend -= d_offset;
13941 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13942 rel[1].r_addend -= d_offset + 4;
13943 bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13944 }
13945 }
13946 break;
13947 }
13948
13949 /* Handle other relocations that tweak non-addend part of insn. */
13950 insn = 0;
13951 max_br_offset = 1 << 25;
13952 addend = rel->r_addend;
13953 reloc_dest = DEST_NORMAL;
13954 switch (r_type)
13955 {
13956 default:
13957 break;
13958
13959 case R_PPC64_TOCSAVE:
13960 if (relocation + addend == (rel->r_offset
13961 + input_section->output_offset
13962 + input_section->output_section->vma)
13963 && tocsave_find (htab, NO_INSERT,
13964 &local_syms, rel, input_bfd))
13965 {
13966 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13967 if (insn == NOP
13968 || insn == CROR_151515 || insn == CROR_313131)
13969 bfd_put_32 (input_bfd,
13970 STD_R2_0R1 + STK_TOC (htab),
13971 contents + rel->r_offset);
13972 }
13973 break;
13974
13975 /* Branch taken prediction relocations. */
13976 case R_PPC64_ADDR14_BRTAKEN:
13977 case R_PPC64_REL14_BRTAKEN:
13978 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13979 /* Fall thru. */
13980
13981 /* Branch not taken prediction relocations. */
13982 case R_PPC64_ADDR14_BRNTAKEN:
13983 case R_PPC64_REL14_BRNTAKEN:
13984 insn |= bfd_get_32 (output_bfd,
13985 contents + rel->r_offset) & ~(0x01 << 21);
13986 /* Fall thru. */
13987
13988 case R_PPC64_REL14:
13989 max_br_offset = 1 << 15;
13990 /* Fall thru. */
13991
13992 case R_PPC64_REL24:
13993 /* Calls to functions with a different TOC, such as calls to
13994 shared objects, need to alter the TOC pointer. This is
13995 done using a linkage stub. A REL24 branching to these
13996 linkage stubs needs to be followed by a nop, as the nop
13997 will be replaced with an instruction to restore the TOC
13998 base pointer. */
13999 fdh = h;
14000 if (h != NULL
14001 && h->oh != NULL
14002 && h->oh->is_func_descriptor)
14003 fdh = ppc_follow_link (h->oh);
14004 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14005 htab);
14006 if (stub_entry != NULL
14007 && (stub_entry->stub_type == ppc_stub_plt_call
14008 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14009 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14010 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14011 {
14012 bfd_boolean can_plt_call = FALSE;
14013
14014 /* All of these stubs will modify r2, so there must be a
14015 branch and link followed by a nop. The nop is
14016 replaced by an insn to restore r2. */
14017 if (rel->r_offset + 8 <= input_section->size)
14018 {
14019 unsigned long br;
14020
14021 br = bfd_get_32 (input_bfd,
14022 contents + rel->r_offset);
14023 if ((br & 1) != 0)
14024 {
14025 unsigned long nop;
14026
14027 nop = bfd_get_32 (input_bfd,
14028 contents + rel->r_offset + 4);
14029 if (nop == NOP
14030 || nop == CROR_151515 || nop == CROR_313131)
14031 {
14032 if (h != NULL
14033 && (h == htab->tls_get_addr_fd
14034 || h == htab->tls_get_addr)
14035 && htab->params->tls_get_addr_opt)
14036 {
14037 /* Special stub used, leave nop alone. */
14038 }
14039 else
14040 bfd_put_32 (input_bfd,
14041 LD_R2_0R1 + STK_TOC (htab),
14042 contents + rel->r_offset + 4);
14043 can_plt_call = TRUE;
14044 }
14045 }
14046 }
14047
14048 if (!can_plt_call && h != NULL)
14049 {
14050 const char *name = h->elf.root.root.string;
14051
14052 if (*name == '.')
14053 ++name;
14054
14055 if (strncmp (name, "__libc_start_main", 17) == 0
14056 && (name[17] == 0 || name[17] == '@'))
14057 {
14058 /* Allow crt1 branch to go via a toc adjusting
14059 stub. Other calls that never return could do
14060 the same, if we could detect such. */
14061 can_plt_call = TRUE;
14062 }
14063 }
14064
14065 if (!can_plt_call)
14066 {
14067 /* g++ as of 20130507 emits self-calls without a
14068 following nop. This is arguably wrong since we
14069 have conflicting information. On the one hand a
14070 global symbol and on the other a local call
14071 sequence, but don't error for this special case.
14072 It isn't possible to cheaply verify we have
14073 exactly such a call. Allow all calls to the same
14074 section. */
14075 asection *code_sec = sec;
14076
14077 if (get_opd_info (sec) != NULL)
14078 {
14079 bfd_vma off = (relocation + addend
14080 - sec->output_section->vma
14081 - sec->output_offset);
14082
14083 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14084 }
14085 if (code_sec == input_section)
14086 can_plt_call = TRUE;
14087 }
14088
14089 if (!can_plt_call)
14090 {
14091 if (stub_entry->stub_type == ppc_stub_plt_call
14092 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14093 info->callbacks->einfo
14094 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14095 "recompile with -fPIC\n"),
14096 input_bfd, input_section, rel->r_offset, sym_name);
14097 else
14098 info->callbacks->einfo
14099 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14100 "(-mcmodel=small toc adjust stub)\n"),
14101 input_bfd, input_section, rel->r_offset, sym_name);
14102
14103 bfd_set_error (bfd_error_bad_value);
14104 ret = FALSE;
14105 }
14106
14107 if (can_plt_call
14108 && (stub_entry->stub_type == ppc_stub_plt_call
14109 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14110 unresolved_reloc = FALSE;
14111 }
14112
14113 if ((stub_entry == NULL
14114 || stub_entry->stub_type == ppc_stub_long_branch
14115 || stub_entry->stub_type == ppc_stub_plt_branch)
14116 && get_opd_info (sec) != NULL)
14117 {
14118 /* The branch destination is the value of the opd entry. */
14119 bfd_vma off = (relocation + addend
14120 - sec->output_section->vma
14121 - sec->output_offset);
14122 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14123 if (dest != (bfd_vma) -1)
14124 {
14125 relocation = dest;
14126 addend = 0;
14127 reloc_dest = DEST_OPD;
14128 }
14129 }
14130
14131 /* If the branch is out of reach we ought to have a long
14132 branch stub. */
14133 from = (rel->r_offset
14134 + input_section->output_offset
14135 + input_section->output_section->vma);
14136
14137 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14138 ? fdh->elf.other
14139 : sym->st_other);
14140
14141 if (stub_entry != NULL
14142 && (stub_entry->stub_type == ppc_stub_long_branch
14143 || stub_entry->stub_type == ppc_stub_plt_branch)
14144 && (r_type == R_PPC64_ADDR14_BRTAKEN
14145 || r_type == R_PPC64_ADDR14_BRNTAKEN
14146 || (relocation + addend - from + max_br_offset
14147 < 2 * max_br_offset)))
14148 /* Don't use the stub if this branch is in range. */
14149 stub_entry = NULL;
14150
14151 if (stub_entry != NULL)
14152 {
14153 /* Munge up the value and addend so that we call the stub
14154 rather than the procedure directly. */
14155 asection *stub_sec = stub_entry->group->stub_sec;
14156
14157 if (stub_entry->stub_type == ppc_stub_save_res)
14158 relocation += (stub_sec->output_offset
14159 + stub_sec->output_section->vma
14160 + stub_sec->size - htab->sfpr->size
14161 - htab->sfpr->output_offset
14162 - htab->sfpr->output_section->vma);
14163 else
14164 relocation = (stub_entry->stub_offset
14165 + stub_sec->output_offset
14166 + stub_sec->output_section->vma);
14167 addend = 0;
14168 reloc_dest = DEST_STUB;
14169
14170 if ((stub_entry->stub_type == ppc_stub_plt_call
14171 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14172 && (ALWAYS_EMIT_R2SAVE
14173 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14174 && rel + 1 < relend
14175 && rel[1].r_offset == rel->r_offset + 4
14176 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14177 relocation += 4;
14178 }
14179
14180 if (insn != 0)
14181 {
14182 if (is_isa_v2)
14183 {
14184 /* Set 'a' bit. This is 0b00010 in BO field for branch
14185 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14186 for branch on CTR insns (BO == 1a00t or 1a01t). */
14187 if ((insn & (0x14 << 21)) == (0x04 << 21))
14188 insn |= 0x02 << 21;
14189 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14190 insn |= 0x08 << 21;
14191 else
14192 break;
14193 }
14194 else
14195 {
14196 /* Invert 'y' bit if not the default. */
14197 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14198 insn ^= 0x01 << 21;
14199 }
14200
14201 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14202 }
14203
14204 /* NOP out calls to undefined weak functions.
14205 We can thus call a weak function without first
14206 checking whether the function is defined. */
14207 else if (h != NULL
14208 && h->elf.root.type == bfd_link_hash_undefweak
14209 && h->elf.dynindx == -1
14210 && r_type == R_PPC64_REL24
14211 && relocation == 0
14212 && addend == 0)
14213 {
14214 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14215 goto copy_reloc;
14216 }
14217 break;
14218 }
14219
14220 /* Set `addend'. */
14221 tls_type = 0;
14222 switch (r_type)
14223 {
14224 default:
14225 info->callbacks->einfo
14226 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14227 input_bfd, (int) r_type, sym_name);
14228
14229 bfd_set_error (bfd_error_bad_value);
14230 ret = FALSE;
14231 goto copy_reloc;
14232
14233 case R_PPC64_NONE:
14234 case R_PPC64_TLS:
14235 case R_PPC64_TLSGD:
14236 case R_PPC64_TLSLD:
14237 case R_PPC64_TOCSAVE:
14238 case R_PPC64_GNU_VTINHERIT:
14239 case R_PPC64_GNU_VTENTRY:
14240 case R_PPC64_ENTRY:
14241 goto copy_reloc;
14242
14243 /* GOT16 relocations. Like an ADDR16 using the symbol's
14244 address in the GOT as relocation value instead of the
14245 symbol's value itself. Also, create a GOT entry for the
14246 symbol and put the symbol value there. */
14247 case R_PPC64_GOT_TLSGD16:
14248 case R_PPC64_GOT_TLSGD16_LO:
14249 case R_PPC64_GOT_TLSGD16_HI:
14250 case R_PPC64_GOT_TLSGD16_HA:
14251 tls_type = TLS_TLS | TLS_GD;
14252 goto dogot;
14253
14254 case R_PPC64_GOT_TLSLD16:
14255 case R_PPC64_GOT_TLSLD16_LO:
14256 case R_PPC64_GOT_TLSLD16_HI:
14257 case R_PPC64_GOT_TLSLD16_HA:
14258 tls_type = TLS_TLS | TLS_LD;
14259 goto dogot;
14260
14261 case R_PPC64_GOT_TPREL16_DS:
14262 case R_PPC64_GOT_TPREL16_LO_DS:
14263 case R_PPC64_GOT_TPREL16_HI:
14264 case R_PPC64_GOT_TPREL16_HA:
14265 tls_type = TLS_TLS | TLS_TPREL;
14266 goto dogot;
14267
14268 case R_PPC64_GOT_DTPREL16_DS:
14269 case R_PPC64_GOT_DTPREL16_LO_DS:
14270 case R_PPC64_GOT_DTPREL16_HI:
14271 case R_PPC64_GOT_DTPREL16_HA:
14272 tls_type = TLS_TLS | TLS_DTPREL;
14273 goto dogot;
14274
14275 case R_PPC64_GOT16:
14276 case R_PPC64_GOT16_LO:
14277 case R_PPC64_GOT16_HI:
14278 case R_PPC64_GOT16_HA:
14279 case R_PPC64_GOT16_DS:
14280 case R_PPC64_GOT16_LO_DS:
14281 dogot:
14282 {
14283 /* Relocation is to the entry for this symbol in the global
14284 offset table. */
14285 asection *got;
14286 bfd_vma *offp;
14287 bfd_vma off;
14288 unsigned long indx = 0;
14289 struct got_entry *ent;
14290
14291 if (tls_type == (TLS_TLS | TLS_LD)
14292 && (h == NULL
14293 || !h->elf.def_dynamic))
14294 ent = ppc64_tlsld_got (input_bfd);
14295 else
14296 {
14297
14298 if (h != NULL)
14299 {
14300 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14301 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14302 &h->elf)
14303 || (bfd_link_pic (info)
14304 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14305 /* This is actually a static link, or it is a
14306 -Bsymbolic link and the symbol is defined
14307 locally, or the symbol was forced to be local
14308 because of a version file. */
14309 ;
14310 else
14311 {
14312 BFD_ASSERT (h->elf.dynindx != -1);
14313 indx = h->elf.dynindx;
14314 unresolved_reloc = FALSE;
14315 }
14316 ent = h->elf.got.glist;
14317 }
14318 else
14319 {
14320 if (local_got_ents == NULL)
14321 abort ();
14322 ent = local_got_ents[r_symndx];
14323 }
14324
14325 for (; ent != NULL; ent = ent->next)
14326 if (ent->addend == orig_rel.r_addend
14327 && ent->owner == input_bfd
14328 && ent->tls_type == tls_type)
14329 break;
14330 }
14331
14332 if (ent == NULL)
14333 abort ();
14334 if (ent->is_indirect)
14335 ent = ent->got.ent;
14336 offp = &ent->got.offset;
14337 got = ppc64_elf_tdata (ent->owner)->got;
14338 if (got == NULL)
14339 abort ();
14340
14341 /* The offset must always be a multiple of 8. We use the
14342 least significant bit to record whether we have already
14343 processed this entry. */
14344 off = *offp;
14345 if ((off & 1) != 0)
14346 off &= ~1;
14347 else
14348 {
14349 /* Generate relocs for the dynamic linker, except in
14350 the case of TLSLD where we'll use one entry per
14351 module. */
14352 asection *relgot;
14353 bfd_boolean ifunc;
14354
14355 *offp = off | 1;
14356 relgot = NULL;
14357 ifunc = (h != NULL
14358 ? h->elf.type == STT_GNU_IFUNC
14359 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14360 if (ifunc)
14361 relgot = htab->elf.irelplt;
14362 else if ((bfd_link_pic (info) || indx != 0)
14363 && (h == NULL
14364 || (tls_type == (TLS_TLS | TLS_LD)
14365 && !h->elf.def_dynamic)
14366 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14367 || h->elf.root.type != bfd_link_hash_undefweak))
14368 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14369 if (relgot != NULL)
14370 {
14371 outrel.r_offset = (got->output_section->vma
14372 + got->output_offset
14373 + off);
14374 outrel.r_addend = addend;
14375 if (tls_type & (TLS_LD | TLS_GD))
14376 {
14377 outrel.r_addend = 0;
14378 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14379 if (tls_type == (TLS_TLS | TLS_GD))
14380 {
14381 loc = relgot->contents;
14382 loc += (relgot->reloc_count++
14383 * sizeof (Elf64_External_Rela));
14384 bfd_elf64_swap_reloca_out (output_bfd,
14385 &outrel, loc);
14386 outrel.r_offset += 8;
14387 outrel.r_addend = addend;
14388 outrel.r_info
14389 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14390 }
14391 }
14392 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14393 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14394 else if (tls_type == (TLS_TLS | TLS_TPREL))
14395 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14396 else if (indx != 0)
14397 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14398 else
14399 {
14400 if (ifunc)
14401 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14402 else
14403 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14404
14405 /* Write the .got section contents for the sake
14406 of prelink. */
14407 loc = got->contents + off;
14408 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14409 loc);
14410 }
14411
14412 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14413 {
14414 outrel.r_addend += relocation;
14415 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14416 {
14417 if (htab->elf.tls_sec == NULL)
14418 outrel.r_addend = 0;
14419 else
14420 outrel.r_addend -= htab->elf.tls_sec->vma;
14421 }
14422 }
14423 loc = relgot->contents;
14424 loc += (relgot->reloc_count++
14425 * sizeof (Elf64_External_Rela));
14426 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14427 }
14428
14429 /* Init the .got section contents here if we're not
14430 emitting a reloc. */
14431 else
14432 {
14433 relocation += addend;
14434 if (tls_type == (TLS_TLS | TLS_LD))
14435 relocation = 1;
14436 else if (tls_type != 0)
14437 {
14438 if (htab->elf.tls_sec == NULL)
14439 relocation = 0;
14440 else
14441 {
14442 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14443 if (tls_type == (TLS_TLS | TLS_TPREL))
14444 relocation += DTP_OFFSET - TP_OFFSET;
14445 }
14446
14447 if (tls_type == (TLS_TLS | TLS_GD))
14448 {
14449 bfd_put_64 (output_bfd, relocation,
14450 got->contents + off + 8);
14451 relocation = 1;
14452 }
14453 }
14454
14455 bfd_put_64 (output_bfd, relocation,
14456 got->contents + off);
14457 }
14458 }
14459
14460 if (off >= (bfd_vma) -2)
14461 abort ();
14462
14463 relocation = got->output_section->vma + got->output_offset + off;
14464 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14465 }
14466 break;
14467
14468 case R_PPC64_PLT16_HA:
14469 case R_PPC64_PLT16_HI:
14470 case R_PPC64_PLT16_LO:
14471 case R_PPC64_PLT32:
14472 case R_PPC64_PLT64:
14473 /* Relocation is to the entry for this symbol in the
14474 procedure linkage table. */
14475 {
14476 struct plt_entry **plt_list = NULL;
14477 if (h != NULL)
14478 plt_list = &h->elf.plt.plist;
14479 else if (local_got_ents != NULL)
14480 {
14481 struct plt_entry **local_plt = (struct plt_entry **)
14482 (local_got_ents + symtab_hdr->sh_info);
14483 unsigned char *local_got_tls_masks = (unsigned char *)
14484 (local_plt + symtab_hdr->sh_info);
14485 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14486 plt_list = local_plt + r_symndx;
14487 }
14488 if (plt_list)
14489 {
14490 struct plt_entry *ent;
14491
14492 for (ent = *plt_list; ent != NULL; ent = ent->next)
14493 if (ent->plt.offset != (bfd_vma) -1
14494 && ent->addend == orig_rel.r_addend)
14495 {
14496 asection *plt;
14497
14498 plt = htab->elf.splt;
14499 if (!htab->elf.dynamic_sections_created
14500 || h == NULL
14501 || h->elf.dynindx == -1)
14502 plt = htab->elf.iplt;
14503 relocation = (plt->output_section->vma
14504 + plt->output_offset
14505 + ent->plt.offset);
14506 addend = 0;
14507 unresolved_reloc = FALSE;
14508 break;
14509 }
14510 }
14511 }
14512 break;
14513
14514 case R_PPC64_TOC:
14515 /* Relocation value is TOC base. */
14516 relocation = TOCstart;
14517 if (r_symndx == STN_UNDEF)
14518 relocation += htab->sec_info[input_section->id].toc_off;
14519 else if (unresolved_reloc)
14520 ;
14521 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14522 relocation += htab->sec_info[sec->id].toc_off;
14523 else
14524 unresolved_reloc = TRUE;
14525 goto dodyn;
14526
14527 /* TOC16 relocs. We want the offset relative to the TOC base,
14528 which is the address of the start of the TOC plus 0x8000.
14529 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14530 in this order. */
14531 case R_PPC64_TOC16:
14532 case R_PPC64_TOC16_LO:
14533 case R_PPC64_TOC16_HI:
14534 case R_PPC64_TOC16_DS:
14535 case R_PPC64_TOC16_LO_DS:
14536 case R_PPC64_TOC16_HA:
14537 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14538 break;
14539
14540 /* Relocate against the beginning of the section. */
14541 case R_PPC64_SECTOFF:
14542 case R_PPC64_SECTOFF_LO:
14543 case R_PPC64_SECTOFF_HI:
14544 case R_PPC64_SECTOFF_DS:
14545 case R_PPC64_SECTOFF_LO_DS:
14546 case R_PPC64_SECTOFF_HA:
14547 if (sec != NULL)
14548 addend -= sec->output_section->vma;
14549 break;
14550
14551 case R_PPC64_REL16:
14552 case R_PPC64_REL16_LO:
14553 case R_PPC64_REL16_HI:
14554 case R_PPC64_REL16_HA:
14555 case R_PPC64_REL16DX_HA:
14556 break;
14557
14558 case R_PPC64_REL14:
14559 case R_PPC64_REL14_BRNTAKEN:
14560 case R_PPC64_REL14_BRTAKEN:
14561 case R_PPC64_REL24:
14562 break;
14563
14564 case R_PPC64_TPREL16:
14565 case R_PPC64_TPREL16_LO:
14566 case R_PPC64_TPREL16_HI:
14567 case R_PPC64_TPREL16_HA:
14568 case R_PPC64_TPREL16_DS:
14569 case R_PPC64_TPREL16_LO_DS:
14570 case R_PPC64_TPREL16_HIGH:
14571 case R_PPC64_TPREL16_HIGHA:
14572 case R_PPC64_TPREL16_HIGHER:
14573 case R_PPC64_TPREL16_HIGHERA:
14574 case R_PPC64_TPREL16_HIGHEST:
14575 case R_PPC64_TPREL16_HIGHESTA:
14576 if (h != NULL
14577 && h->elf.root.type == bfd_link_hash_undefweak
14578 && h->elf.dynindx == -1)
14579 {
14580 /* Make this relocation against an undefined weak symbol
14581 resolve to zero. This is really just a tweak, since
14582 code using weak externs ought to check that they are
14583 defined before using them. */
14584 bfd_byte *p = contents + rel->r_offset - d_offset;
14585
14586 insn = bfd_get_32 (output_bfd, p);
14587 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14588 if (insn != 0)
14589 bfd_put_32 (output_bfd, insn, p);
14590 break;
14591 }
14592 if (htab->elf.tls_sec != NULL)
14593 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14594 if (bfd_link_pic (info))
14595 /* The TPREL16 relocs shouldn't really be used in shared
14596 libs as they will result in DT_TEXTREL being set, but
14597 support them anyway. */
14598 goto dodyn;
14599 break;
14600
14601 case R_PPC64_DTPREL16:
14602 case R_PPC64_DTPREL16_LO:
14603 case R_PPC64_DTPREL16_HI:
14604 case R_PPC64_DTPREL16_HA:
14605 case R_PPC64_DTPREL16_DS:
14606 case R_PPC64_DTPREL16_LO_DS:
14607 case R_PPC64_DTPREL16_HIGH:
14608 case R_PPC64_DTPREL16_HIGHA:
14609 case R_PPC64_DTPREL16_HIGHER:
14610 case R_PPC64_DTPREL16_HIGHERA:
14611 case R_PPC64_DTPREL16_HIGHEST:
14612 case R_PPC64_DTPREL16_HIGHESTA:
14613 if (htab->elf.tls_sec != NULL)
14614 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14615 break;
14616
14617 case R_PPC64_ADDR64_LOCAL:
14618 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14619 ? h->elf.other
14620 : sym->st_other);
14621 break;
14622
14623 case R_PPC64_DTPMOD64:
14624 relocation = 1;
14625 addend = 0;
14626 goto dodyn;
14627
14628 case R_PPC64_TPREL64:
14629 if (htab->elf.tls_sec != NULL)
14630 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14631 goto dodyn;
14632
14633 case R_PPC64_DTPREL64:
14634 if (htab->elf.tls_sec != NULL)
14635 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14636 /* Fall thru */
14637
14638 /* Relocations that may need to be propagated if this is a
14639 dynamic object. */
14640 case R_PPC64_REL30:
14641 case R_PPC64_REL32:
14642 case R_PPC64_REL64:
14643 case R_PPC64_ADDR14:
14644 case R_PPC64_ADDR14_BRNTAKEN:
14645 case R_PPC64_ADDR14_BRTAKEN:
14646 case R_PPC64_ADDR16:
14647 case R_PPC64_ADDR16_DS:
14648 case R_PPC64_ADDR16_HA:
14649 case R_PPC64_ADDR16_HI:
14650 case R_PPC64_ADDR16_HIGH:
14651 case R_PPC64_ADDR16_HIGHA:
14652 case R_PPC64_ADDR16_HIGHER:
14653 case R_PPC64_ADDR16_HIGHERA:
14654 case R_PPC64_ADDR16_HIGHEST:
14655 case R_PPC64_ADDR16_HIGHESTA:
14656 case R_PPC64_ADDR16_LO:
14657 case R_PPC64_ADDR16_LO_DS:
14658 case R_PPC64_ADDR24:
14659 case R_PPC64_ADDR32:
14660 case R_PPC64_ADDR64:
14661 case R_PPC64_UADDR16:
14662 case R_PPC64_UADDR32:
14663 case R_PPC64_UADDR64:
14664 dodyn:
14665 if ((input_section->flags & SEC_ALLOC) == 0)
14666 break;
14667
14668 if (NO_OPD_RELOCS && is_opd)
14669 break;
14670
14671 if ((bfd_link_pic (info)
14672 && (h == NULL
14673 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14674 || h->elf.root.type != bfd_link_hash_undefweak)
14675 && (must_be_dyn_reloc (info, r_type)
14676 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14677 || (ELIMINATE_COPY_RELOCS
14678 && !bfd_link_pic (info)
14679 && h != NULL
14680 && h->elf.dynindx != -1
14681 && !h->elf.non_got_ref
14682 && !h->elf.def_regular)
14683 || (!bfd_link_pic (info)
14684 && (h != NULL
14685 ? h->elf.type == STT_GNU_IFUNC
14686 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14687 {
14688 bfd_boolean skip, relocate;
14689 asection *sreloc;
14690 bfd_vma out_off;
14691
14692 /* When generating a dynamic object, these relocations
14693 are copied into the output file to be resolved at run
14694 time. */
14695
14696 skip = FALSE;
14697 relocate = FALSE;
14698
14699 out_off = _bfd_elf_section_offset (output_bfd, info,
14700 input_section, rel->r_offset);
14701 if (out_off == (bfd_vma) -1)
14702 skip = TRUE;
14703 else if (out_off == (bfd_vma) -2)
14704 skip = TRUE, relocate = TRUE;
14705 out_off += (input_section->output_section->vma
14706 + input_section->output_offset);
14707 outrel.r_offset = out_off;
14708 outrel.r_addend = rel->r_addend;
14709
14710 /* Optimize unaligned reloc use. */
14711 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14712 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14713 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14714 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14715 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14716 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14717 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14718 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14719 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14720
14721 if (skip)
14722 memset (&outrel, 0, sizeof outrel);
14723 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14724 && !is_opd
14725 && r_type != R_PPC64_TOC)
14726 {
14727 BFD_ASSERT (h->elf.dynindx != -1);
14728 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14729 }
14730 else
14731 {
14732 /* This symbol is local, or marked to become local,
14733 or this is an opd section reloc which must point
14734 at a local function. */
14735 outrel.r_addend += relocation;
14736 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14737 {
14738 if (is_opd && h != NULL)
14739 {
14740 /* Lie about opd entries. This case occurs
14741 when building shared libraries and we
14742 reference a function in another shared
14743 lib. The same thing happens for a weak
14744 definition in an application that's
14745 overridden by a strong definition in a
14746 shared lib. (I believe this is a generic
14747 bug in binutils handling of weak syms.)
14748 In these cases we won't use the opd
14749 entry in this lib. */
14750 unresolved_reloc = FALSE;
14751 }
14752 if (!is_opd
14753 && r_type == R_PPC64_ADDR64
14754 && (h != NULL
14755 ? h->elf.type == STT_GNU_IFUNC
14756 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14757 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14758 else
14759 {
14760 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14761
14762 /* We need to relocate .opd contents for ld.so.
14763 Prelink also wants simple and consistent rules
14764 for relocs. This make all RELATIVE relocs have
14765 *r_offset equal to r_addend. */
14766 relocate = TRUE;
14767 }
14768 }
14769 else
14770 {
14771 long indx = 0;
14772
14773 if (h != NULL
14774 ? h->elf.type == STT_GNU_IFUNC
14775 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14776 {
14777 info->callbacks->einfo
14778 (_("%P: %H: %s for indirect "
14779 "function `%T' unsupported\n"),
14780 input_bfd, input_section, rel->r_offset,
14781 ppc64_elf_howto_table[r_type]->name,
14782 sym_name);
14783 ret = FALSE;
14784 }
14785 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14786 ;
14787 else if (sec == NULL || sec->owner == NULL)
14788 {
14789 bfd_set_error (bfd_error_bad_value);
14790 return FALSE;
14791 }
14792 else
14793 {
14794 asection *osec;
14795
14796 osec = sec->output_section;
14797 indx = elf_section_data (osec)->dynindx;
14798
14799 if (indx == 0)
14800 {
14801 if ((osec->flags & SEC_READONLY) == 0
14802 && htab->elf.data_index_section != NULL)
14803 osec = htab->elf.data_index_section;
14804 else
14805 osec = htab->elf.text_index_section;
14806 indx = elf_section_data (osec)->dynindx;
14807 }
14808 BFD_ASSERT (indx != 0);
14809
14810 /* We are turning this relocation into one
14811 against a section symbol, so subtract out
14812 the output section's address but not the
14813 offset of the input section in the output
14814 section. */
14815 outrel.r_addend -= osec->vma;
14816 }
14817
14818 outrel.r_info = ELF64_R_INFO (indx, r_type);
14819 }
14820 }
14821
14822 sreloc = elf_section_data (input_section)->sreloc;
14823 if (h != NULL
14824 ? h->elf.type == STT_GNU_IFUNC
14825 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14826 sreloc = htab->elf.irelplt;
14827 if (sreloc == NULL)
14828 abort ();
14829
14830 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14831 >= sreloc->size)
14832 abort ();
14833 loc = sreloc->contents;
14834 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14835 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14836
14837 /* If this reloc is against an external symbol, it will
14838 be computed at runtime, so there's no need to do
14839 anything now. However, for the sake of prelink ensure
14840 that the section contents are a known value. */
14841 if (! relocate)
14842 {
14843 unresolved_reloc = FALSE;
14844 /* The value chosen here is quite arbitrary as ld.so
14845 ignores section contents except for the special
14846 case of .opd where the contents might be accessed
14847 before relocation. Choose zero, as that won't
14848 cause reloc overflow. */
14849 relocation = 0;
14850 addend = 0;
14851 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14852 to improve backward compatibility with older
14853 versions of ld. */
14854 if (r_type == R_PPC64_ADDR64)
14855 addend = outrel.r_addend;
14856 /* Adjust pc_relative relocs to have zero in *r_offset. */
14857 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14858 addend = (input_section->output_section->vma
14859 + input_section->output_offset
14860 + rel->r_offset);
14861 }
14862 }
14863 break;
14864
14865 case R_PPC64_COPY:
14866 case R_PPC64_GLOB_DAT:
14867 case R_PPC64_JMP_SLOT:
14868 case R_PPC64_JMP_IREL:
14869 case R_PPC64_RELATIVE:
14870 /* We shouldn't ever see these dynamic relocs in relocatable
14871 files. */
14872 /* Fall through. */
14873
14874 case R_PPC64_PLTGOT16:
14875 case R_PPC64_PLTGOT16_DS:
14876 case R_PPC64_PLTGOT16_HA:
14877 case R_PPC64_PLTGOT16_HI:
14878 case R_PPC64_PLTGOT16_LO:
14879 case R_PPC64_PLTGOT16_LO_DS:
14880 case R_PPC64_PLTREL32:
14881 case R_PPC64_PLTREL64:
14882 /* These ones haven't been implemented yet. */
14883
14884 info->callbacks->einfo
14885 (_("%P: %B: %s is not supported for `%T'\n"),
14886 input_bfd,
14887 ppc64_elf_howto_table[r_type]->name, sym_name);
14888
14889 bfd_set_error (bfd_error_invalid_operation);
14890 ret = FALSE;
14891 goto copy_reloc;
14892 }
14893
14894 /* Multi-instruction sequences that access the TOC can be
14895 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14896 to nop; addi rb,r2,x; */
14897 switch (r_type)
14898 {
14899 default:
14900 break;
14901
14902 case R_PPC64_GOT_TLSLD16_HI:
14903 case R_PPC64_GOT_TLSGD16_HI:
14904 case R_PPC64_GOT_TPREL16_HI:
14905 case R_PPC64_GOT_DTPREL16_HI:
14906 case R_PPC64_GOT16_HI:
14907 case R_PPC64_TOC16_HI:
14908 /* These relocs would only be useful if building up an
14909 offset to later add to r2, perhaps in an indexed
14910 addressing mode instruction. Don't try to optimize.
14911 Unfortunately, the possibility of someone building up an
14912 offset like this or even with the HA relocs, means that
14913 we need to check the high insn when optimizing the low
14914 insn. */
14915 break;
14916
14917 case R_PPC64_GOT_TLSLD16_HA:
14918 case R_PPC64_GOT_TLSGD16_HA:
14919 case R_PPC64_GOT_TPREL16_HA:
14920 case R_PPC64_GOT_DTPREL16_HA:
14921 case R_PPC64_GOT16_HA:
14922 case R_PPC64_TOC16_HA:
14923 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14924 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14925 {
14926 bfd_byte *p = contents + (rel->r_offset & ~3);
14927 bfd_put_32 (input_bfd, NOP, p);
14928 }
14929 break;
14930
14931 case R_PPC64_GOT_TLSLD16_LO:
14932 case R_PPC64_GOT_TLSGD16_LO:
14933 case R_PPC64_GOT_TPREL16_LO_DS:
14934 case R_PPC64_GOT_DTPREL16_LO_DS:
14935 case R_PPC64_GOT16_LO:
14936 case R_PPC64_GOT16_LO_DS:
14937 case R_PPC64_TOC16_LO:
14938 case R_PPC64_TOC16_LO_DS:
14939 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14940 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14941 {
14942 bfd_byte *p = contents + (rel->r_offset & ~3);
14943 insn = bfd_get_32 (input_bfd, p);
14944 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14945 {
14946 /* Transform addic to addi when we change reg. */
14947 insn &= ~((0x3f << 26) | (0x1f << 16));
14948 insn |= (14u << 26) | (2 << 16);
14949 }
14950 else
14951 {
14952 insn &= ~(0x1f << 16);
14953 insn |= 2 << 16;
14954 }
14955 bfd_put_32 (input_bfd, insn, p);
14956 }
14957 break;
14958 }
14959
14960 /* Do any further special processing. */
14961 howto = ppc64_elf_howto_table[(int) r_type];
14962 switch (r_type)
14963 {
14964 default:
14965 break;
14966
14967 case R_PPC64_REL16_HA:
14968 case R_PPC64_REL16DX_HA:
14969 case R_PPC64_ADDR16_HA:
14970 case R_PPC64_ADDR16_HIGHA:
14971 case R_PPC64_ADDR16_HIGHERA:
14972 case R_PPC64_ADDR16_HIGHESTA:
14973 case R_PPC64_TOC16_HA:
14974 case R_PPC64_SECTOFF_HA:
14975 case R_PPC64_TPREL16_HA:
14976 case R_PPC64_TPREL16_HIGHA:
14977 case R_PPC64_TPREL16_HIGHERA:
14978 case R_PPC64_TPREL16_HIGHESTA:
14979 case R_PPC64_DTPREL16_HA:
14980 case R_PPC64_DTPREL16_HIGHA:
14981 case R_PPC64_DTPREL16_HIGHERA:
14982 case R_PPC64_DTPREL16_HIGHESTA:
14983 /* It's just possible that this symbol is a weak symbol
14984 that's not actually defined anywhere. In that case,
14985 'sec' would be NULL, and we should leave the symbol
14986 alone (it will be set to zero elsewhere in the link). */
14987 if (sec == NULL)
14988 break;
14989 /* Fall thru */
14990
14991 case R_PPC64_GOT16_HA:
14992 case R_PPC64_PLTGOT16_HA:
14993 case R_PPC64_PLT16_HA:
14994 case R_PPC64_GOT_TLSGD16_HA:
14995 case R_PPC64_GOT_TLSLD16_HA:
14996 case R_PPC64_GOT_TPREL16_HA:
14997 case R_PPC64_GOT_DTPREL16_HA:
14998 /* Add 0x10000 if sign bit in 0:15 is set.
14999 Bits 0:15 are not used. */
15000 addend += 0x8000;
15001 break;
15002
15003 case R_PPC64_ADDR16_DS:
15004 case R_PPC64_ADDR16_LO_DS:
15005 case R_PPC64_GOT16_DS:
15006 case R_PPC64_GOT16_LO_DS:
15007 case R_PPC64_PLT16_LO_DS:
15008 case R_PPC64_SECTOFF_DS:
15009 case R_PPC64_SECTOFF_LO_DS:
15010 case R_PPC64_TOC16_DS:
15011 case R_PPC64_TOC16_LO_DS:
15012 case R_PPC64_PLTGOT16_DS:
15013 case R_PPC64_PLTGOT16_LO_DS:
15014 case R_PPC64_GOT_TPREL16_DS:
15015 case R_PPC64_GOT_TPREL16_LO_DS:
15016 case R_PPC64_GOT_DTPREL16_DS:
15017 case R_PPC64_GOT_DTPREL16_LO_DS:
15018 case R_PPC64_TPREL16_DS:
15019 case R_PPC64_TPREL16_LO_DS:
15020 case R_PPC64_DTPREL16_DS:
15021 case R_PPC64_DTPREL16_LO_DS:
15022 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15023 mask = 3;
15024 /* If this reloc is against an lq, lxv, or stxv insn, then
15025 the value must be a multiple of 16. This is somewhat of
15026 a hack, but the "correct" way to do this by defining _DQ
15027 forms of all the _DS relocs bloats all reloc switches in
15028 this file. It doesn't make much sense to use these
15029 relocs in data, so testing the insn should be safe. */
15030 if ((insn & (0x3f << 26)) == (56u << 26)
15031 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15032 mask = 15;
15033 relocation += addend;
15034 addend = insn & (mask ^ 3);
15035 if ((relocation & mask) != 0)
15036 {
15037 relocation ^= relocation & mask;
15038 info->callbacks->einfo
15039 (_("%P: %H: error: %s not a multiple of %u\n"),
15040 input_bfd, input_section, rel->r_offset,
15041 howto->name,
15042 mask + 1);
15043 bfd_set_error (bfd_error_bad_value);
15044 ret = FALSE;
15045 goto copy_reloc;
15046 }
15047 break;
15048 }
15049
15050 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15051 because such sections are not SEC_ALLOC and thus ld.so will
15052 not process them. */
15053 if (unresolved_reloc
15054 && !((input_section->flags & SEC_DEBUGGING) != 0
15055 && h->elf.def_dynamic)
15056 && _bfd_elf_section_offset (output_bfd, info, input_section,
15057 rel->r_offset) != (bfd_vma) -1)
15058 {
15059 info->callbacks->einfo
15060 (_("%P: %H: unresolvable %s against `%T'\n"),
15061 input_bfd, input_section, rel->r_offset,
15062 howto->name,
15063 h->elf.root.root.string);
15064 ret = FALSE;
15065 }
15066
15067 /* 16-bit fields in insns mostly have signed values, but a
15068 few insns have 16-bit unsigned values. Really, we should
15069 have different reloc types. */
15070 if (howto->complain_on_overflow != complain_overflow_dont
15071 && howto->dst_mask == 0xffff
15072 && (input_section->flags & SEC_CODE) != 0)
15073 {
15074 enum complain_overflow complain = complain_overflow_signed;
15075
15076 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15077 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15078 complain = complain_overflow_bitfield;
15079 else if (howto->rightshift == 0
15080 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15081 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15082 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15083 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15084 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15085 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15086 complain = complain_overflow_unsigned;
15087 if (howto->complain_on_overflow != complain)
15088 {
15089 alt_howto = *howto;
15090 alt_howto.complain_on_overflow = complain;
15091 howto = &alt_howto;
15092 }
15093 }
15094
15095 if (r_type == R_PPC64_REL16DX_HA)
15096 {
15097 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15098 if (rel->r_offset + 4 > input_section->size)
15099 r = bfd_reloc_outofrange;
15100 else
15101 {
15102 relocation += addend;
15103 relocation -= (rel->r_offset
15104 + input_section->output_offset
15105 + input_section->output_section->vma);
15106 relocation = (bfd_signed_vma) relocation >> 16;
15107 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15108 insn &= ~0x1fffc1;
15109 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15110 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15111 r = bfd_reloc_ok;
15112 if (relocation + 0x8000 > 0xffff)
15113 r = bfd_reloc_overflow;
15114 }
15115 }
15116 else
15117 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15118 rel->r_offset, relocation, addend);
15119
15120 if (r != bfd_reloc_ok)
15121 {
15122 char *more_info = NULL;
15123 const char *reloc_name = howto->name;
15124
15125 if (reloc_dest != DEST_NORMAL)
15126 {
15127 more_info = bfd_malloc (strlen (reloc_name) + 8);
15128 if (more_info != NULL)
15129 {
15130 strcpy (more_info, reloc_name);
15131 strcat (more_info, (reloc_dest == DEST_OPD
15132 ? " (OPD)" : " (stub)"));
15133 reloc_name = more_info;
15134 }
15135 }
15136
15137 if (r == bfd_reloc_overflow)
15138 {
15139 /* On code like "if (foo) foo();" don't report overflow
15140 on a branch to zero when foo is undefined. */
15141 if (!warned
15142 && (reloc_dest == DEST_STUB
15143 || !(h != NULL
15144 && (h->elf.root.type == bfd_link_hash_undefweak
15145 || h->elf.root.type == bfd_link_hash_undefined)
15146 && is_branch_reloc (r_type))))
15147 info->callbacks->reloc_overflow (info, &h->elf.root,
15148 sym_name, reloc_name,
15149 orig_rel.r_addend,
15150 input_bfd, input_section,
15151 rel->r_offset);
15152 }
15153 else
15154 {
15155 info->callbacks->einfo
15156 (_("%P: %H: %s against `%T': error %d\n"),
15157 input_bfd, input_section, rel->r_offset,
15158 reloc_name, sym_name, (int) r);
15159 ret = FALSE;
15160 }
15161 if (more_info != NULL)
15162 free (more_info);
15163 }
15164 copy_reloc:
15165 if (wrel != rel)
15166 *wrel = *rel;
15167 }
15168
15169 if (wrel != rel)
15170 {
15171 Elf_Internal_Shdr *rel_hdr;
15172 size_t deleted = rel - wrel;
15173
15174 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15175 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15176 if (rel_hdr->sh_size == 0)
15177 {
15178 /* It is too late to remove an empty reloc section. Leave
15179 one NONE reloc.
15180 ??? What is wrong with an empty section??? */
15181 rel_hdr->sh_size = rel_hdr->sh_entsize;
15182 deleted -= 1;
15183 }
15184 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15185 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15186 input_section->reloc_count -= deleted;
15187 }
15188
15189 /* If we're emitting relocations, then shortly after this function
15190 returns, reloc offsets and addends for this section will be
15191 adjusted. Worse, reloc symbol indices will be for the output
15192 file rather than the input. Save a copy of the relocs for
15193 opd_entry_value. */
15194 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15195 {
15196 bfd_size_type amt;
15197 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15198 rel = bfd_alloc (input_bfd, amt);
15199 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15200 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15201 if (rel == NULL)
15202 return FALSE;
15203 memcpy (rel, relocs, amt);
15204 }
15205 return ret;
15206 }
15207
15208 /* Adjust the value of any local symbols in opd sections. */
15209
15210 static int
15211 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15212 const char *name ATTRIBUTE_UNUSED,
15213 Elf_Internal_Sym *elfsym,
15214 asection *input_sec,
15215 struct elf_link_hash_entry *h)
15216 {
15217 struct _opd_sec_data *opd;
15218 long adjust;
15219 bfd_vma value;
15220
15221 if (h != NULL)
15222 return 1;
15223
15224 opd = get_opd_info (input_sec);
15225 if (opd == NULL || opd->adjust == NULL)
15226 return 1;
15227
15228 value = elfsym->st_value - input_sec->output_offset;
15229 if (!bfd_link_relocatable (info))
15230 value -= input_sec->output_section->vma;
15231
15232 adjust = opd->adjust[OPD_NDX (value)];
15233 if (adjust == -1)
15234 return 2;
15235
15236 elfsym->st_value += adjust;
15237 return 1;
15238 }
15239
15240 /* Finish up dynamic symbol handling. We set the contents of various
15241 dynamic sections here. */
15242
15243 static bfd_boolean
15244 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15245 struct bfd_link_info *info,
15246 struct elf_link_hash_entry *h,
15247 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15248 {
15249 struct ppc_link_hash_table *htab;
15250 struct plt_entry *ent;
15251 Elf_Internal_Rela rela;
15252 bfd_byte *loc;
15253
15254 htab = ppc_hash_table (info);
15255 if (htab == NULL)
15256 return FALSE;
15257
15258 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15259 if (ent->plt.offset != (bfd_vma) -1)
15260 {
15261 /* This symbol has an entry in the procedure linkage
15262 table. Set it up. */
15263 if (!htab->elf.dynamic_sections_created
15264 || h->dynindx == -1)
15265 {
15266 BFD_ASSERT (h->type == STT_GNU_IFUNC
15267 && h->def_regular
15268 && (h->root.type == bfd_link_hash_defined
15269 || h->root.type == bfd_link_hash_defweak));
15270 rela.r_offset = (htab->elf.iplt->output_section->vma
15271 + htab->elf.iplt->output_offset
15272 + ent->plt.offset);
15273 if (htab->opd_abi)
15274 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15275 else
15276 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15277 rela.r_addend = (h->root.u.def.value
15278 + h->root.u.def.section->output_offset
15279 + h->root.u.def.section->output_section->vma
15280 + ent->addend);
15281 loc = (htab->elf.irelplt->contents
15282 + (htab->elf.irelplt->reloc_count++
15283 * sizeof (Elf64_External_Rela)));
15284 }
15285 else
15286 {
15287 rela.r_offset = (htab->elf.splt->output_section->vma
15288 + htab->elf.splt->output_offset
15289 + ent->plt.offset);
15290 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15291 rela.r_addend = ent->addend;
15292 loc = (htab->elf.srelplt->contents
15293 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15294 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15295 }
15296 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15297
15298 if (!htab->opd_abi)
15299 {
15300 if (!h->def_regular)
15301 {
15302 /* Mark the symbol as undefined, rather than as
15303 defined in glink. Leave the value if there were
15304 any relocations where pointer equality matters
15305 (this is a clue for the dynamic linker, to make
15306 function pointer comparisons work between an
15307 application and shared library), otherwise set it
15308 to zero. */
15309 sym->st_shndx = SHN_UNDEF;
15310 if (!h->pointer_equality_needed)
15311 sym->st_value = 0;
15312 else if (!h->ref_regular_nonweak)
15313 {
15314 /* This breaks function pointer comparisons, but
15315 that is better than breaking tests for a NULL
15316 function pointer. */
15317 sym->st_value = 0;
15318 }
15319 }
15320 }
15321 }
15322
15323 if (h->needs_copy)
15324 {
15325 /* This symbol needs a copy reloc. Set it up. */
15326
15327 if (h->dynindx == -1
15328 || (h->root.type != bfd_link_hash_defined
15329 && h->root.type != bfd_link_hash_defweak)
15330 || htab->relbss == NULL)
15331 abort ();
15332
15333 rela.r_offset = (h->root.u.def.value
15334 + h->root.u.def.section->output_section->vma
15335 + h->root.u.def.section->output_offset);
15336 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15337 rela.r_addend = 0;
15338 loc = htab->relbss->contents;
15339 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15340 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15341 }
15342
15343 return TRUE;
15344 }
15345
15346 /* Used to decide how to sort relocs in an optimal manner for the
15347 dynamic linker, before writing them out. */
15348
15349 static enum elf_reloc_type_class
15350 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15351 const asection *rel_sec,
15352 const Elf_Internal_Rela *rela)
15353 {
15354 enum elf_ppc64_reloc_type r_type;
15355 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15356
15357 if (rel_sec == htab->elf.irelplt)
15358 return reloc_class_ifunc;
15359
15360 r_type = ELF64_R_TYPE (rela->r_info);
15361 switch (r_type)
15362 {
15363 case R_PPC64_RELATIVE:
15364 return reloc_class_relative;
15365 case R_PPC64_JMP_SLOT:
15366 return reloc_class_plt;
15367 case R_PPC64_COPY:
15368 return reloc_class_copy;
15369 default:
15370 return reloc_class_normal;
15371 }
15372 }
15373
15374 /* Finish up the dynamic sections. */
15375
15376 static bfd_boolean
15377 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15378 struct bfd_link_info *info)
15379 {
15380 struct ppc_link_hash_table *htab;
15381 bfd *dynobj;
15382 asection *sdyn;
15383
15384 htab = ppc_hash_table (info);
15385 if (htab == NULL)
15386 return FALSE;
15387
15388 dynobj = htab->elf.dynobj;
15389 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15390
15391 if (htab->elf.dynamic_sections_created)
15392 {
15393 Elf64_External_Dyn *dyncon, *dynconend;
15394
15395 if (sdyn == NULL || htab->elf.sgot == NULL)
15396 abort ();
15397
15398 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15399 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15400 for (; dyncon < dynconend; dyncon++)
15401 {
15402 Elf_Internal_Dyn dyn;
15403 asection *s;
15404
15405 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15406
15407 switch (dyn.d_tag)
15408 {
15409 default:
15410 continue;
15411
15412 case DT_PPC64_GLINK:
15413 s = htab->glink;
15414 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15415 /* We stupidly defined DT_PPC64_GLINK to be the start
15416 of glink rather than the first entry point, which is
15417 what ld.so needs, and now have a bigger stub to
15418 support automatic multiple TOCs. */
15419 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15420 break;
15421
15422 case DT_PPC64_OPD:
15423 s = bfd_get_section_by_name (output_bfd, ".opd");
15424 if (s == NULL)
15425 continue;
15426 dyn.d_un.d_ptr = s->vma;
15427 break;
15428
15429 case DT_PPC64_OPT:
15430 if (htab->do_multi_toc && htab->multi_toc_needed)
15431 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15432 break;
15433
15434 case DT_PPC64_OPDSZ:
15435 s = bfd_get_section_by_name (output_bfd, ".opd");
15436 if (s == NULL)
15437 continue;
15438 dyn.d_un.d_val = s->size;
15439 break;
15440
15441 case DT_PLTGOT:
15442 s = htab->elf.splt;
15443 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15444 break;
15445
15446 case DT_JMPREL:
15447 s = htab->elf.srelplt;
15448 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15449 break;
15450
15451 case DT_PLTRELSZ:
15452 dyn.d_un.d_val = htab->elf.srelplt->size;
15453 break;
15454
15455 case DT_RELASZ:
15456 /* Don't count procedure linkage table relocs in the
15457 overall reloc count. */
15458 s = htab->elf.srelplt;
15459 if (s == NULL)
15460 continue;
15461 dyn.d_un.d_val -= s->size;
15462 break;
15463
15464 case DT_RELA:
15465 /* We may not be using the standard ELF linker script.
15466 If .rela.plt is the first .rela section, we adjust
15467 DT_RELA to not include it. */
15468 s = htab->elf.srelplt;
15469 if (s == NULL)
15470 continue;
15471 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15472 continue;
15473 dyn.d_un.d_ptr += s->size;
15474 break;
15475 }
15476
15477 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15478 }
15479 }
15480
15481 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15482 {
15483 /* Fill in the first entry in the global offset table.
15484 We use it to hold the link-time TOCbase. */
15485 bfd_put_64 (output_bfd,
15486 elf_gp (output_bfd) + TOC_BASE_OFF,
15487 htab->elf.sgot->contents);
15488
15489 /* Set .got entry size. */
15490 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15491 }
15492
15493 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15494 {
15495 /* Set .plt entry size. */
15496 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15497 = PLT_ENTRY_SIZE (htab);
15498 }
15499
15500 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15501 brlt ourselves if emitrelocations. */
15502 if (htab->brlt != NULL
15503 && htab->brlt->reloc_count != 0
15504 && !_bfd_elf_link_output_relocs (output_bfd,
15505 htab->brlt,
15506 elf_section_data (htab->brlt)->rela.hdr,
15507 elf_section_data (htab->brlt)->relocs,
15508 NULL))
15509 return FALSE;
15510
15511 if (htab->glink != NULL
15512 && htab->glink->reloc_count != 0
15513 && !_bfd_elf_link_output_relocs (output_bfd,
15514 htab->glink,
15515 elf_section_data (htab->glink)->rela.hdr,
15516 elf_section_data (htab->glink)->relocs,
15517 NULL))
15518 return FALSE;
15519
15520 if (htab->glink_eh_frame != NULL
15521 && htab->glink_eh_frame->size != 0)
15522 {
15523 bfd_vma val;
15524 bfd_byte *p;
15525 asection *stub_sec;
15526
15527 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15528 for (stub_sec = htab->params->stub_bfd->sections;
15529 stub_sec != NULL;
15530 stub_sec = stub_sec->next)
15531 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15532 {
15533 /* FDE length. */
15534 p += 4;
15535 /* CIE pointer. */
15536 p += 4;
15537 /* Offset to stub section. */
15538 val = (stub_sec->output_section->vma
15539 + stub_sec->output_offset);
15540 val -= (htab->glink_eh_frame->output_section->vma
15541 + htab->glink_eh_frame->output_offset
15542 + (p - htab->glink_eh_frame->contents));
15543 if (val + 0x80000000 > 0xffffffff)
15544 {
15545 info->callbacks->einfo
15546 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15547 stub_sec->name);
15548 return FALSE;
15549 }
15550 bfd_put_32 (dynobj, val, p);
15551 p += 4;
15552 /* stub section size. */
15553 p += 4;
15554 /* Augmentation. */
15555 p += 1;
15556 /* Pad. */
15557 p += 7;
15558 }
15559 if (htab->glink != NULL && htab->glink->size != 0)
15560 {
15561 /* FDE length. */
15562 p += 4;
15563 /* CIE pointer. */
15564 p += 4;
15565 /* Offset to .glink. */
15566 val = (htab->glink->output_section->vma
15567 + htab->glink->output_offset
15568 + 8);
15569 val -= (htab->glink_eh_frame->output_section->vma
15570 + htab->glink_eh_frame->output_offset
15571 + (p - htab->glink_eh_frame->contents));
15572 if (val + 0x80000000 > 0xffffffff)
15573 {
15574 info->callbacks->einfo
15575 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15576 htab->glink->name);
15577 return FALSE;
15578 }
15579 bfd_put_32 (dynobj, val, p);
15580 p += 4;
15581 /* .glink size. */
15582 p += 4;
15583 /* Augmentation. */
15584 p += 1;
15585 /* Ops. */
15586 p += 7;
15587 }
15588
15589 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15590 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15591 htab->glink_eh_frame,
15592 htab->glink_eh_frame->contents))
15593 return FALSE;
15594 }
15595
15596 /* We need to handle writing out multiple GOT sections ourselves,
15597 since we didn't add them to DYNOBJ. We know dynobj is the first
15598 bfd. */
15599 while ((dynobj = dynobj->link.next) != NULL)
15600 {
15601 asection *s;
15602
15603 if (!is_ppc64_elf (dynobj))
15604 continue;
15605
15606 s = ppc64_elf_tdata (dynobj)->got;
15607 if (s != NULL
15608 && s->size != 0
15609 && s->output_section != bfd_abs_section_ptr
15610 && !bfd_set_section_contents (output_bfd, s->output_section,
15611 s->contents, s->output_offset,
15612 s->size))
15613 return FALSE;
15614 s = ppc64_elf_tdata (dynobj)->relgot;
15615 if (s != NULL
15616 && s->size != 0
15617 && s->output_section != bfd_abs_section_ptr
15618 && !bfd_set_section_contents (output_bfd, s->output_section,
15619 s->contents, s->output_offset,
15620 s->size))
15621 return FALSE;
15622 }
15623
15624 return TRUE;
15625 }
15626
15627 #include "elf64-target.h"
15628
15629 /* FreeBSD support */
15630
15631 #undef TARGET_LITTLE_SYM
15632 #undef TARGET_LITTLE_NAME
15633
15634 #undef TARGET_BIG_SYM
15635 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15636 #undef TARGET_BIG_NAME
15637 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15638
15639 #undef ELF_OSABI
15640 #define ELF_OSABI ELFOSABI_FREEBSD
15641
15642 #undef elf64_bed
15643 #define elf64_bed elf64_powerpc_fbsd_bed
15644
15645 #include "elf64-target.h"
15646
GDB Binutils - Deliverables
This page took 0.486468 seconds and 4 git commands to generate.