projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Tidy ppc64_elf_hide_symbol
[binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2016 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_dtrel_excludes_plt 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90
91 #define elf_backend_object_p ppc64_elf_object_p
92 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
93 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
94 #define elf_backend_write_core_note ppc64_elf_write_core_note
95 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
96 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
97 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
98 #define elf_backend_check_directives ppc64_elf_before_check_relocs
99 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
100 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
101 #define elf_backend_check_relocs ppc64_elf_check_relocs
102 #define elf_backend_gc_keep ppc64_elf_gc_keep
103 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
104 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
105 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
106 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
107 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
108 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
109 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
110 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
111 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
112 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
113 #define elf_backend_action_discarded ppc64_elf_action_discarded
114 #define elf_backend_relocate_section ppc64_elf_relocate_section
115 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
116 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
117 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
118 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
119 #define elf_backend_special_sections ppc64_elf_special_sections
120 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
121
122 /* The name of the dynamic interpreter. This is put in the .interp
123 section. */
124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125
126 /* The size in bytes of an entry in the procedure linkage table. */
127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
128
129 /* The initial size of the plt reserved for the dynamic linker. */
130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
131
132 /* Offsets to some stack save slots. */
133 #define STK_LR 16
134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
135 /* This one is dodgy. ELFv2 does not have a linker word, so use the
136 CR save slot. Used only by optimised __tls_get_addr call stub,
137 relying on __tls_get_addr_opt not saving CR.. */
138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
139
140 /* TOC base pointers offset from start of TOC. */
141 #define TOC_BASE_OFF 0x8000
142 /* TOC base alignment. */
143 #define TOC_BASE_ALIGN 256
144
145 /* Offset of tp and dtp pointers from start of TLS block. */
146 #define TP_OFFSET 0x7000
147 #define DTP_OFFSET 0x8000
148
149 /* .plt call stub instructions. The normal stub is like this, but
150 sometimes the .plt entry crosses a 64k boundary and we need to
151 insert an addi to adjust r11. */
152 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
153 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
154 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
155 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
156 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
157 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
158 #define BCTR 0x4e800420 /* bctr */
159
160 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
161 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
162 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
163
164 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
165 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
166 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
167 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
168 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
169 #define BNECTR 0x4ca20420 /* bnectr+ */
170 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
171
172 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
173 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
174 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
175
176 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
177 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
178 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
179
180 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
181 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
182 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
183 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
184 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
185
186 /* glink call stub instructions. We enter with the index in R0. */
187 #define GLINK_CALL_STUB_SIZE (16*4)
188 /* 0: */
189 /* .quad plt0-1f */
190 /* __glink: */
191 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
192 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
193 /* 1: */
194 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
195 /* ld %2,(0b-1b)(%11) */
196 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
197 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
198 /* ld %12,0(%11) */
199 /* ld %2,8(%11) */
200 /* mtctr %12 */
201 /* ld %11,16(%11) */
202 /* bctr */
203 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
204 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
205 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
206 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
207 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
208
209 /* Pad with this. */
210 #define NOP 0x60000000
211
212 /* Some other nops. */
213 #define CROR_151515 0x4def7b82
214 #define CROR_313131 0x4ffffb82
215
216 /* .glink entries for the first 32k functions are two instructions. */
217 #define LI_R0_0 0x38000000 /* li %r0,0 */
218 #define B_DOT 0x48000000 /* b . */
219
220 /* After that, we need two instructions to load the index, followed by
221 a branch. */
222 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
223 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
224
225 /* Instructions used by the save and restore reg functions. */
226 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
227 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
228 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
229 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
230 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
231 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
232 #define LI_R12_0 0x39800000 /* li %r12,0 */
233 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
234 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
235 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
236 #define BLR 0x4e800020 /* blr */
237
238 /* Since .opd is an array of descriptors and each entry will end up
239 with identical R_PPC64_RELATIVE relocs, there is really no need to
240 propagate .opd relocs; The dynamic linker should be taught to
241 relocate .opd without reloc entries. */
242 #ifndef NO_OPD_RELOCS
243 #define NO_OPD_RELOCS 0
244 #endif
245
246 #ifndef ARRAY_SIZE
247 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
248 #endif
249
250 static inline int
251 abiversion (bfd *abfd)
252 {
253 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
254 }
255
256 static inline void
257 set_abiversion (bfd *abfd, int ver)
258 {
259 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
260 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
261 }
262 \f
263 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
264
265 /* Relocation HOWTO's. */
266 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
267
268 static reloc_howto_type ppc64_elf_howto_raw[] = {
269 /* This reloc does nothing. */
270 HOWTO (R_PPC64_NONE, /* type */
271 0, /* rightshift */
272 3, /* size (0 = byte, 1 = short, 2 = long) */
273 0, /* bitsize */
274 FALSE, /* pc_relative */
275 0, /* bitpos */
276 complain_overflow_dont, /* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_PPC64_NONE", /* name */
279 FALSE, /* partial_inplace */
280 0, /* src_mask */
281 0, /* dst_mask */
282 FALSE), /* pcrel_offset */
283
284 /* A standard 32 bit relocation. */
285 HOWTO (R_PPC64_ADDR32, /* type */
286 0, /* rightshift */
287 2, /* size (0 = byte, 1 = short, 2 = long) */
288 32, /* bitsize */
289 FALSE, /* pc_relative */
290 0, /* bitpos */
291 complain_overflow_bitfield, /* complain_on_overflow */
292 bfd_elf_generic_reloc, /* special_function */
293 "R_PPC64_ADDR32", /* name */
294 FALSE, /* partial_inplace */
295 0, /* src_mask */
296 0xffffffff, /* dst_mask */
297 FALSE), /* pcrel_offset */
298
299 /* An absolute 26 bit branch; the lower two bits must be zero.
300 FIXME: we don't check that, we just clear them. */
301 HOWTO (R_PPC64_ADDR24, /* type */
302 0, /* rightshift */
303 2, /* size (0 = byte, 1 = short, 2 = long) */
304 26, /* bitsize */
305 FALSE, /* pc_relative */
306 0, /* bitpos */
307 complain_overflow_bitfield, /* complain_on_overflow */
308 bfd_elf_generic_reloc, /* special_function */
309 "R_PPC64_ADDR24", /* name */
310 FALSE, /* partial_inplace */
311 0, /* src_mask */
312 0x03fffffc, /* dst_mask */
313 FALSE), /* pcrel_offset */
314
315 /* A standard 16 bit relocation. */
316 HOWTO (R_PPC64_ADDR16, /* type */
317 0, /* rightshift */
318 1, /* size (0 = byte, 1 = short, 2 = long) */
319 16, /* bitsize */
320 FALSE, /* pc_relative */
321 0, /* bitpos */
322 complain_overflow_bitfield, /* complain_on_overflow */
323 bfd_elf_generic_reloc, /* special_function */
324 "R_PPC64_ADDR16", /* name */
325 FALSE, /* partial_inplace */
326 0, /* src_mask */
327 0xffff, /* dst_mask */
328 FALSE), /* pcrel_offset */
329
330 /* A 16 bit relocation without overflow. */
331 HOWTO (R_PPC64_ADDR16_LO, /* type */
332 0, /* rightshift */
333 1, /* size (0 = byte, 1 = short, 2 = long) */
334 16, /* bitsize */
335 FALSE, /* pc_relative */
336 0, /* bitpos */
337 complain_overflow_dont,/* complain_on_overflow */
338 bfd_elf_generic_reloc, /* special_function */
339 "R_PPC64_ADDR16_LO", /* name */
340 FALSE, /* partial_inplace */
341 0, /* src_mask */
342 0xffff, /* dst_mask */
343 FALSE), /* pcrel_offset */
344
345 /* Bits 16-31 of an address. */
346 HOWTO (R_PPC64_ADDR16_HI, /* type */
347 16, /* rightshift */
348 1, /* size (0 = byte, 1 = short, 2 = long) */
349 16, /* bitsize */
350 FALSE, /* pc_relative */
351 0, /* bitpos */
352 complain_overflow_signed, /* complain_on_overflow */
353 bfd_elf_generic_reloc, /* special_function */
354 "R_PPC64_ADDR16_HI", /* name */
355 FALSE, /* partial_inplace */
356 0, /* src_mask */
357 0xffff, /* dst_mask */
358 FALSE), /* pcrel_offset */
359
360 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
361 bits, treated as a signed number, is negative. */
362 HOWTO (R_PPC64_ADDR16_HA, /* type */
363 16, /* rightshift */
364 1, /* size (0 = byte, 1 = short, 2 = long) */
365 16, /* bitsize */
366 FALSE, /* pc_relative */
367 0, /* bitpos */
368 complain_overflow_signed, /* complain_on_overflow */
369 ppc64_elf_ha_reloc, /* special_function */
370 "R_PPC64_ADDR16_HA", /* name */
371 FALSE, /* partial_inplace */
372 0, /* src_mask */
373 0xffff, /* dst_mask */
374 FALSE), /* pcrel_offset */
375
376 /* An absolute 16 bit branch; the lower two bits must be zero.
377 FIXME: we don't check that, we just clear them. */
378 HOWTO (R_PPC64_ADDR14, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 16, /* bitsize */
382 FALSE, /* pc_relative */
383 0, /* bitpos */
384 complain_overflow_signed, /* complain_on_overflow */
385 ppc64_elf_branch_reloc, /* special_function */
386 "R_PPC64_ADDR14", /* name */
387 FALSE, /* partial_inplace */
388 0, /* src_mask */
389 0x0000fffc, /* dst_mask */
390 FALSE), /* pcrel_offset */
391
392 /* An absolute 16 bit branch, for which bit 10 should be set to
393 indicate that the branch is expected to be taken. The lower two
394 bits must be zero. */
395 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
399 FALSE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_signed, /* complain_on_overflow */
402 ppc64_elf_brtaken_reloc, /* special_function */
403 "R_PPC64_ADDR14_BRTAKEN",/* name */
404 FALSE, /* partial_inplace */
405 0, /* src_mask */
406 0x0000fffc, /* dst_mask */
407 FALSE), /* pcrel_offset */
408
409 /* An absolute 16 bit branch, for which bit 10 should be set to
410 indicate that the branch is not expected to be taken. The lower
411 two bits must be zero. */
412 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
416 FALSE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_signed, /* complain_on_overflow */
419 ppc64_elf_brtaken_reloc, /* special_function */
420 "R_PPC64_ADDR14_BRNTAKEN",/* name */
421 FALSE, /* partial_inplace */
422 0, /* src_mask */
423 0x0000fffc, /* dst_mask */
424 FALSE), /* pcrel_offset */
425
426 /* A relative 26 bit branch; the lower two bits must be zero. */
427 HOWTO (R_PPC64_REL24, /* type */
428 0, /* rightshift */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
430 26, /* bitsize */
431 TRUE, /* pc_relative */
432 0, /* bitpos */
433 complain_overflow_signed, /* complain_on_overflow */
434 ppc64_elf_branch_reloc, /* special_function */
435 "R_PPC64_REL24", /* name */
436 FALSE, /* partial_inplace */
437 0, /* src_mask */
438 0x03fffffc, /* dst_mask */
439 TRUE), /* pcrel_offset */
440
441 /* A relative 16 bit branch; the lower two bits must be zero. */
442 HOWTO (R_PPC64_REL14, /* type */
443 0, /* rightshift */
444 2, /* size (0 = byte, 1 = short, 2 = long) */
445 16, /* bitsize */
446 TRUE, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_signed, /* complain_on_overflow */
449 ppc64_elf_branch_reloc, /* special_function */
450 "R_PPC64_REL14", /* name */
451 FALSE, /* partial_inplace */
452 0, /* src_mask */
453 0x0000fffc, /* dst_mask */
454 TRUE), /* pcrel_offset */
455
456 /* A relative 16 bit branch. Bit 10 should be set to indicate that
457 the branch is expected to be taken. The lower two bits must be
458 zero. */
459 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
460 0, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 16, /* bitsize */
463 TRUE, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_signed, /* complain_on_overflow */
466 ppc64_elf_brtaken_reloc, /* special_function */
467 "R_PPC64_REL14_BRTAKEN", /* name */
468 FALSE, /* partial_inplace */
469 0, /* src_mask */
470 0x0000fffc, /* dst_mask */
471 TRUE), /* pcrel_offset */
472
473 /* A relative 16 bit branch. Bit 10 should be set to indicate that
474 the branch is not expected to be taken. The lower two bits must
475 be zero. */
476 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
477 0, /* rightshift */
478 2, /* size (0 = byte, 1 = short, 2 = long) */
479 16, /* bitsize */
480 TRUE, /* pc_relative */
481 0, /* bitpos */
482 complain_overflow_signed, /* complain_on_overflow */
483 ppc64_elf_brtaken_reloc, /* special_function */
484 "R_PPC64_REL14_BRNTAKEN",/* name */
485 FALSE, /* partial_inplace */
486 0, /* src_mask */
487 0x0000fffc, /* dst_mask */
488 TRUE), /* pcrel_offset */
489
490 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
491 symbol. */
492 HOWTO (R_PPC64_GOT16, /* type */
493 0, /* rightshift */
494 1, /* size (0 = byte, 1 = short, 2 = long) */
495 16, /* bitsize */
496 FALSE, /* pc_relative */
497 0, /* bitpos */
498 complain_overflow_signed, /* complain_on_overflow */
499 ppc64_elf_unhandled_reloc, /* special_function */
500 "R_PPC64_GOT16", /* name */
501 FALSE, /* partial_inplace */
502 0, /* src_mask */
503 0xffff, /* dst_mask */
504 FALSE), /* pcrel_offset */
505
506 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
507 the symbol. */
508 HOWTO (R_PPC64_GOT16_LO, /* type */
509 0, /* rightshift */
510 1, /* size (0 = byte, 1 = short, 2 = long) */
511 16, /* bitsize */
512 FALSE, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_dont, /* complain_on_overflow */
515 ppc64_elf_unhandled_reloc, /* special_function */
516 "R_PPC64_GOT16_LO", /* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0xffff, /* dst_mask */
520 FALSE), /* pcrel_offset */
521
522 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
523 the symbol. */
524 HOWTO (R_PPC64_GOT16_HI, /* type */
525 16, /* rightshift */
526 1, /* size (0 = byte, 1 = short, 2 = long) */
527 16, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_signed,/* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GOT16_HI", /* name */
533 FALSE, /* partial_inplace */
534 0, /* src_mask */
535 0xffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
539 the symbol. */
540 HOWTO (R_PPC64_GOT16_HA, /* type */
541 16, /* rightshift */
542 1, /* size (0 = byte, 1 = short, 2 = long) */
543 16, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_signed,/* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_GOT16_HA", /* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0xffff, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* This is used only by the dynamic linker. The symbol should exist
555 both in the object being run and in some shared library. The
556 dynamic linker copies the data addressed by the symbol from the
557 shared library into the object, because the object being
558 run has to have the data at some particular address. */
559 HOWTO (R_PPC64_COPY, /* type */
560 0, /* rightshift */
561 0, /* this one is variable size */
562 0, /* bitsize */
563 FALSE, /* pc_relative */
564 0, /* bitpos */
565 complain_overflow_dont, /* complain_on_overflow */
566 ppc64_elf_unhandled_reloc, /* special_function */
567 "R_PPC64_COPY", /* name */
568 FALSE, /* partial_inplace */
569 0, /* src_mask */
570 0, /* dst_mask */
571 FALSE), /* pcrel_offset */
572
573 /* Like R_PPC64_ADDR64, but used when setting global offset table
574 entries. */
575 HOWTO (R_PPC64_GLOB_DAT, /* type */
576 0, /* rightshift */
577 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
578 64, /* bitsize */
579 FALSE, /* pc_relative */
580 0, /* bitpos */
581 complain_overflow_dont, /* complain_on_overflow */
582 ppc64_elf_unhandled_reloc, /* special_function */
583 "R_PPC64_GLOB_DAT", /* name */
584 FALSE, /* partial_inplace */
585 0, /* src_mask */
586 ONES (64), /* dst_mask */
587 FALSE), /* pcrel_offset */
588
589 /* Created by the link editor. Marks a procedure linkage table
590 entry for a symbol. */
591 HOWTO (R_PPC64_JMP_SLOT, /* type */
592 0, /* rightshift */
593 0, /* size (0 = byte, 1 = short, 2 = long) */
594 0, /* bitsize */
595 FALSE, /* pc_relative */
596 0, /* bitpos */
597 complain_overflow_dont, /* complain_on_overflow */
598 ppc64_elf_unhandled_reloc, /* special_function */
599 "R_PPC64_JMP_SLOT", /* name */
600 FALSE, /* partial_inplace */
601 0, /* src_mask */
602 0, /* dst_mask */
603 FALSE), /* pcrel_offset */
604
605 /* Used only by the dynamic linker. When the object is run, this
606 doubleword64 is set to the load address of the object, plus the
607 addend. */
608 HOWTO (R_PPC64_RELATIVE, /* type */
609 0, /* rightshift */
610 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
611 64, /* bitsize */
612 FALSE, /* pc_relative */
613 0, /* bitpos */
614 complain_overflow_dont, /* complain_on_overflow */
615 bfd_elf_generic_reloc, /* special_function */
616 "R_PPC64_RELATIVE", /* name */
617 FALSE, /* partial_inplace */
618 0, /* src_mask */
619 ONES (64), /* dst_mask */
620 FALSE), /* pcrel_offset */
621
622 /* Like R_PPC64_ADDR32, but may be unaligned. */
623 HOWTO (R_PPC64_UADDR32, /* type */
624 0, /* rightshift */
625 2, /* size (0 = byte, 1 = short, 2 = long) */
626 32, /* bitsize */
627 FALSE, /* pc_relative */
628 0, /* bitpos */
629 complain_overflow_bitfield, /* complain_on_overflow */
630 bfd_elf_generic_reloc, /* special_function */
631 "R_PPC64_UADDR32", /* name */
632 FALSE, /* partial_inplace */
633 0, /* src_mask */
634 0xffffffff, /* dst_mask */
635 FALSE), /* pcrel_offset */
636
637 /* Like R_PPC64_ADDR16, but may be unaligned. */
638 HOWTO (R_PPC64_UADDR16, /* type */
639 0, /* rightshift */
640 1, /* size (0 = byte, 1 = short, 2 = long) */
641 16, /* bitsize */
642 FALSE, /* pc_relative */
643 0, /* bitpos */
644 complain_overflow_bitfield, /* complain_on_overflow */
645 bfd_elf_generic_reloc, /* special_function */
646 "R_PPC64_UADDR16", /* name */
647 FALSE, /* partial_inplace */
648 0, /* src_mask */
649 0xffff, /* dst_mask */
650 FALSE), /* pcrel_offset */
651
652 /* 32-bit PC relative. */
653 HOWTO (R_PPC64_REL32, /* type */
654 0, /* rightshift */
655 2, /* size (0 = byte, 1 = short, 2 = long) */
656 32, /* bitsize */
657 TRUE, /* pc_relative */
658 0, /* bitpos */
659 complain_overflow_signed, /* complain_on_overflow */
660 bfd_elf_generic_reloc, /* special_function */
661 "R_PPC64_REL32", /* name */
662 FALSE, /* partial_inplace */
663 0, /* src_mask */
664 0xffffffff, /* dst_mask */
665 TRUE), /* pcrel_offset */
666
667 /* 32-bit relocation to the symbol's procedure linkage table. */
668 HOWTO (R_PPC64_PLT32, /* type */
669 0, /* rightshift */
670 2, /* size (0 = byte, 1 = short, 2 = long) */
671 32, /* bitsize */
672 FALSE, /* pc_relative */
673 0, /* bitpos */
674 complain_overflow_bitfield, /* complain_on_overflow */
675 ppc64_elf_unhandled_reloc, /* special_function */
676 "R_PPC64_PLT32", /* name */
677 FALSE, /* partial_inplace */
678 0, /* src_mask */
679 0xffffffff, /* dst_mask */
680 FALSE), /* pcrel_offset */
681
682 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
683 FIXME: R_PPC64_PLTREL32 not supported. */
684 HOWTO (R_PPC64_PLTREL32, /* type */
685 0, /* rightshift */
686 2, /* size (0 = byte, 1 = short, 2 = long) */
687 32, /* bitsize */
688 TRUE, /* pc_relative */
689 0, /* bitpos */
690 complain_overflow_signed, /* complain_on_overflow */
691 ppc64_elf_unhandled_reloc, /* special_function */
692 "R_PPC64_PLTREL32", /* name */
693 FALSE, /* partial_inplace */
694 0, /* src_mask */
695 0xffffffff, /* dst_mask */
696 TRUE), /* pcrel_offset */
697
698 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
699 the symbol. */
700 HOWTO (R_PPC64_PLT16_LO, /* type */
701 0, /* rightshift */
702 1, /* size (0 = byte, 1 = short, 2 = long) */
703 16, /* bitsize */
704 FALSE, /* pc_relative */
705 0, /* bitpos */
706 complain_overflow_dont, /* complain_on_overflow */
707 ppc64_elf_unhandled_reloc, /* special_function */
708 "R_PPC64_PLT16_LO", /* name */
709 FALSE, /* partial_inplace */
710 0, /* src_mask */
711 0xffff, /* dst_mask */
712 FALSE), /* pcrel_offset */
713
714 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
715 the symbol. */
716 HOWTO (R_PPC64_PLT16_HI, /* type */
717 16, /* rightshift */
718 1, /* size (0 = byte, 1 = short, 2 = long) */
719 16, /* bitsize */
720 FALSE, /* pc_relative */
721 0, /* bitpos */
722 complain_overflow_signed, /* complain_on_overflow */
723 ppc64_elf_unhandled_reloc, /* special_function */
724 "R_PPC64_PLT16_HI", /* name */
725 FALSE, /* partial_inplace */
726 0, /* src_mask */
727 0xffff, /* dst_mask */
728 FALSE), /* pcrel_offset */
729
730 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
731 the symbol. */
732 HOWTO (R_PPC64_PLT16_HA, /* type */
733 16, /* rightshift */
734 1, /* size (0 = byte, 1 = short, 2 = long) */
735 16, /* bitsize */
736 FALSE, /* pc_relative */
737 0, /* bitpos */
738 complain_overflow_signed, /* complain_on_overflow */
739 ppc64_elf_unhandled_reloc, /* special_function */
740 "R_PPC64_PLT16_HA", /* name */
741 FALSE, /* partial_inplace */
742 0, /* src_mask */
743 0xffff, /* dst_mask */
744 FALSE), /* pcrel_offset */
745
746 /* 16-bit section relative relocation. */
747 HOWTO (R_PPC64_SECTOFF, /* type */
748 0, /* rightshift */
749 1, /* size (0 = byte, 1 = short, 2 = long) */
750 16, /* bitsize */
751 FALSE, /* pc_relative */
752 0, /* bitpos */
753 complain_overflow_signed, /* complain_on_overflow */
754 ppc64_elf_sectoff_reloc, /* special_function */
755 "R_PPC64_SECTOFF", /* name */
756 FALSE, /* partial_inplace */
757 0, /* src_mask */
758 0xffff, /* dst_mask */
759 FALSE), /* pcrel_offset */
760
761 /* Like R_PPC64_SECTOFF, but no overflow warning. */
762 HOWTO (R_PPC64_SECTOFF_LO, /* type */
763 0, /* rightshift */
764 1, /* size (0 = byte, 1 = short, 2 = long) */
765 16, /* bitsize */
766 FALSE, /* pc_relative */
767 0, /* bitpos */
768 complain_overflow_dont, /* complain_on_overflow */
769 ppc64_elf_sectoff_reloc, /* special_function */
770 "R_PPC64_SECTOFF_LO", /* name */
771 FALSE, /* partial_inplace */
772 0, /* src_mask */
773 0xffff, /* dst_mask */
774 FALSE), /* pcrel_offset */
775
776 /* 16-bit upper half section relative relocation. */
777 HOWTO (R_PPC64_SECTOFF_HI, /* type */
778 16, /* rightshift */
779 1, /* size (0 = byte, 1 = short, 2 = long) */
780 16, /* bitsize */
781 FALSE, /* pc_relative */
782 0, /* bitpos */
783 complain_overflow_signed, /* complain_on_overflow */
784 ppc64_elf_sectoff_reloc, /* special_function */
785 "R_PPC64_SECTOFF_HI", /* name */
786 FALSE, /* partial_inplace */
787 0, /* src_mask */
788 0xffff, /* dst_mask */
789 FALSE), /* pcrel_offset */
790
791 /* 16-bit upper half adjusted section relative relocation. */
792 HOWTO (R_PPC64_SECTOFF_HA, /* type */
793 16, /* rightshift */
794 1, /* size (0 = byte, 1 = short, 2 = long) */
795 16, /* bitsize */
796 FALSE, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_signed, /* complain_on_overflow */
799 ppc64_elf_sectoff_ha_reloc, /* special_function */
800 "R_PPC64_SECTOFF_HA", /* name */
801 FALSE, /* partial_inplace */
802 0, /* src_mask */
803 0xffff, /* dst_mask */
804 FALSE), /* pcrel_offset */
805
806 /* Like R_PPC64_REL24 without touching the two least significant bits. */
807 HOWTO (R_PPC64_REL30, /* type */
808 2, /* rightshift */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
810 30, /* bitsize */
811 TRUE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_PPC64_REL30", /* name */
816 FALSE, /* partial_inplace */
817 0, /* src_mask */
818 0xfffffffc, /* dst_mask */
819 TRUE), /* pcrel_offset */
820
821 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
822
823 /* A standard 64-bit relocation. */
824 HOWTO (R_PPC64_ADDR64, /* type */
825 0, /* rightshift */
826 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
827 64, /* bitsize */
828 FALSE, /* pc_relative */
829 0, /* bitpos */
830 complain_overflow_dont, /* complain_on_overflow */
831 bfd_elf_generic_reloc, /* special_function */
832 "R_PPC64_ADDR64", /* name */
833 FALSE, /* partial_inplace */
834 0, /* src_mask */
835 ONES (64), /* dst_mask */
836 FALSE), /* pcrel_offset */
837
838 /* The bits 32-47 of an address. */
839 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
840 32, /* rightshift */
841 1, /* size (0 = byte, 1 = short, 2 = long) */
842 16, /* bitsize */
843 FALSE, /* pc_relative */
844 0, /* bitpos */
845 complain_overflow_dont, /* complain_on_overflow */
846 bfd_elf_generic_reloc, /* special_function */
847 "R_PPC64_ADDR16_HIGHER", /* name */
848 FALSE, /* partial_inplace */
849 0, /* src_mask */
850 0xffff, /* dst_mask */
851 FALSE), /* pcrel_offset */
852
853 /* The bits 32-47 of an address, plus 1 if the contents of the low
854 16 bits, treated as a signed number, is negative. */
855 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
856 32, /* rightshift */
857 1, /* size (0 = byte, 1 = short, 2 = long) */
858 16, /* bitsize */
859 FALSE, /* pc_relative */
860 0, /* bitpos */
861 complain_overflow_dont, /* complain_on_overflow */
862 ppc64_elf_ha_reloc, /* special_function */
863 "R_PPC64_ADDR16_HIGHERA", /* name */
864 FALSE, /* partial_inplace */
865 0, /* src_mask */
866 0xffff, /* dst_mask */
867 FALSE), /* pcrel_offset */
868
869 /* The bits 48-63 of an address. */
870 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
871 48, /* rightshift */
872 1, /* size (0 = byte, 1 = short, 2 = long) */
873 16, /* bitsize */
874 FALSE, /* pc_relative */
875 0, /* bitpos */
876 complain_overflow_dont, /* complain_on_overflow */
877 bfd_elf_generic_reloc, /* special_function */
878 "R_PPC64_ADDR16_HIGHEST", /* name */
879 FALSE, /* partial_inplace */
880 0, /* src_mask */
881 0xffff, /* dst_mask */
882 FALSE), /* pcrel_offset */
883
884 /* The bits 48-63 of an address, plus 1 if the contents of the low
885 16 bits, treated as a signed number, is negative. */
886 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
887 48, /* rightshift */
888 1, /* size (0 = byte, 1 = short, 2 = long) */
889 16, /* bitsize */
890 FALSE, /* pc_relative */
891 0, /* bitpos */
892 complain_overflow_dont, /* complain_on_overflow */
893 ppc64_elf_ha_reloc, /* special_function */
894 "R_PPC64_ADDR16_HIGHESTA", /* name */
895 FALSE, /* partial_inplace */
896 0, /* src_mask */
897 0xffff, /* dst_mask */
898 FALSE), /* pcrel_offset */
899
900 /* Like ADDR64, but may be unaligned. */
901 HOWTO (R_PPC64_UADDR64, /* type */
902 0, /* rightshift */
903 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
904 64, /* bitsize */
905 FALSE, /* pc_relative */
906 0, /* bitpos */
907 complain_overflow_dont, /* complain_on_overflow */
908 bfd_elf_generic_reloc, /* special_function */
909 "R_PPC64_UADDR64", /* name */
910 FALSE, /* partial_inplace */
911 0, /* src_mask */
912 ONES (64), /* dst_mask */
913 FALSE), /* pcrel_offset */
914
915 /* 64-bit relative relocation. */
916 HOWTO (R_PPC64_REL64, /* type */
917 0, /* rightshift */
918 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
919 64, /* bitsize */
920 TRUE, /* pc_relative */
921 0, /* bitpos */
922 complain_overflow_dont, /* complain_on_overflow */
923 bfd_elf_generic_reloc, /* special_function */
924 "R_PPC64_REL64", /* name */
925 FALSE, /* partial_inplace */
926 0, /* src_mask */
927 ONES (64), /* dst_mask */
928 TRUE), /* pcrel_offset */
929
930 /* 64-bit relocation to the symbol's procedure linkage table. */
931 HOWTO (R_PPC64_PLT64, /* type */
932 0, /* rightshift */
933 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
934 64, /* bitsize */
935 FALSE, /* pc_relative */
936 0, /* bitpos */
937 complain_overflow_dont, /* complain_on_overflow */
938 ppc64_elf_unhandled_reloc, /* special_function */
939 "R_PPC64_PLT64", /* name */
940 FALSE, /* partial_inplace */
941 0, /* src_mask */
942 ONES (64), /* dst_mask */
943 FALSE), /* pcrel_offset */
944
945 /* 64-bit PC relative relocation to the symbol's procedure linkage
946 table. */
947 /* FIXME: R_PPC64_PLTREL64 not supported. */
948 HOWTO (R_PPC64_PLTREL64, /* type */
949 0, /* rightshift */
950 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
951 64, /* bitsize */
952 TRUE, /* pc_relative */
953 0, /* bitpos */
954 complain_overflow_dont, /* complain_on_overflow */
955 ppc64_elf_unhandled_reloc, /* special_function */
956 "R_PPC64_PLTREL64", /* name */
957 FALSE, /* partial_inplace */
958 0, /* src_mask */
959 ONES (64), /* dst_mask */
960 TRUE), /* pcrel_offset */
961
962 /* 16 bit TOC-relative relocation. */
963
964 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
965 HOWTO (R_PPC64_TOC16, /* type */
966 0, /* rightshift */
967 1, /* size (0 = byte, 1 = short, 2 = long) */
968 16, /* bitsize */
969 FALSE, /* pc_relative */
970 0, /* bitpos */
971 complain_overflow_signed, /* complain_on_overflow */
972 ppc64_elf_toc_reloc, /* special_function */
973 "R_PPC64_TOC16", /* name */
974 FALSE, /* partial_inplace */
975 0, /* src_mask */
976 0xffff, /* dst_mask */
977 FALSE), /* pcrel_offset */
978
979 /* 16 bit TOC-relative relocation without overflow. */
980
981 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
982 HOWTO (R_PPC64_TOC16_LO, /* type */
983 0, /* rightshift */
984 1, /* size (0 = byte, 1 = short, 2 = long) */
985 16, /* bitsize */
986 FALSE, /* pc_relative */
987 0, /* bitpos */
988 complain_overflow_dont, /* complain_on_overflow */
989 ppc64_elf_toc_reloc, /* special_function */
990 "R_PPC64_TOC16_LO", /* name */
991 FALSE, /* partial_inplace */
992 0, /* src_mask */
993 0xffff, /* dst_mask */
994 FALSE), /* pcrel_offset */
995
996 /* 16 bit TOC-relative relocation, high 16 bits. */
997
998 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
999 HOWTO (R_PPC64_TOC16_HI, /* type */
1000 16, /* rightshift */
1001 1, /* size (0 = byte, 1 = short, 2 = long) */
1002 16, /* bitsize */
1003 FALSE, /* pc_relative */
1004 0, /* bitpos */
1005 complain_overflow_signed, /* complain_on_overflow */
1006 ppc64_elf_toc_reloc, /* special_function */
1007 "R_PPC64_TOC16_HI", /* name */
1008 FALSE, /* partial_inplace */
1009 0, /* src_mask */
1010 0xffff, /* dst_mask */
1011 FALSE), /* pcrel_offset */
1012
1013 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1014 contents of the low 16 bits, treated as a signed number, is
1015 negative. */
1016
1017 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1018 HOWTO (R_PPC64_TOC16_HA, /* type */
1019 16, /* rightshift */
1020 1, /* size (0 = byte, 1 = short, 2 = long) */
1021 16, /* bitsize */
1022 FALSE, /* pc_relative */
1023 0, /* bitpos */
1024 complain_overflow_signed, /* complain_on_overflow */
1025 ppc64_elf_toc_ha_reloc, /* special_function */
1026 "R_PPC64_TOC16_HA", /* name */
1027 FALSE, /* partial_inplace */
1028 0, /* src_mask */
1029 0xffff, /* dst_mask */
1030 FALSE), /* pcrel_offset */
1031
1032 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1033
1034 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1035 HOWTO (R_PPC64_TOC, /* type */
1036 0, /* rightshift */
1037 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1038 64, /* bitsize */
1039 FALSE, /* pc_relative */
1040 0, /* bitpos */
1041 complain_overflow_dont, /* complain_on_overflow */
1042 ppc64_elf_toc64_reloc, /* special_function */
1043 "R_PPC64_TOC", /* name */
1044 FALSE, /* partial_inplace */
1045 0, /* src_mask */
1046 ONES (64), /* dst_mask */
1047 FALSE), /* pcrel_offset */
1048
1049 /* Like R_PPC64_GOT16, but also informs the link editor that the
1050 value to relocate may (!) refer to a PLT entry which the link
1051 editor (a) may replace with the symbol value. If the link editor
1052 is unable to fully resolve the symbol, it may (b) create a PLT
1053 entry and store the address to the new PLT entry in the GOT.
1054 This permits lazy resolution of function symbols at run time.
1055 The link editor may also skip all of this and just (c) emit a
1056 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1057 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1058 HOWTO (R_PPC64_PLTGOT16, /* type */
1059 0, /* rightshift */
1060 1, /* size (0 = byte, 1 = short, 2 = long) */
1061 16, /* bitsize */
1062 FALSE, /* pc_relative */
1063 0, /* bitpos */
1064 complain_overflow_signed, /* complain_on_overflow */
1065 ppc64_elf_unhandled_reloc, /* special_function */
1066 "R_PPC64_PLTGOT16", /* name */
1067 FALSE, /* partial_inplace */
1068 0, /* src_mask */
1069 0xffff, /* dst_mask */
1070 FALSE), /* pcrel_offset */
1071
1072 /* Like R_PPC64_PLTGOT16, but without overflow. */
1073 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1074 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1075 0, /* rightshift */
1076 1, /* size (0 = byte, 1 = short, 2 = long) */
1077 16, /* bitsize */
1078 FALSE, /* pc_relative */
1079 0, /* bitpos */
1080 complain_overflow_dont, /* complain_on_overflow */
1081 ppc64_elf_unhandled_reloc, /* special_function */
1082 "R_PPC64_PLTGOT16_LO", /* name */
1083 FALSE, /* partial_inplace */
1084 0, /* src_mask */
1085 0xffff, /* dst_mask */
1086 FALSE), /* pcrel_offset */
1087
1088 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1089 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1090 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1091 16, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_PLTGOT16_HI", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xffff, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1105 1 if the contents of the low 16 bits, treated as a signed number,
1106 is negative. */
1107 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1108 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1109 16, /* rightshift */
1110 1, /* size (0 = byte, 1 = short, 2 = long) */
1111 16, /* bitsize */
1112 FALSE, /* pc_relative */
1113 0, /* bitpos */
1114 complain_overflow_signed, /* complain_on_overflow */
1115 ppc64_elf_unhandled_reloc, /* special_function */
1116 "R_PPC64_PLTGOT16_HA", /* name */
1117 FALSE, /* partial_inplace */
1118 0, /* src_mask */
1119 0xffff, /* dst_mask */
1120 FALSE), /* pcrel_offset */
1121
1122 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1123 HOWTO (R_PPC64_ADDR16_DS, /* type */
1124 0, /* rightshift */
1125 1, /* size (0 = byte, 1 = short, 2 = long) */
1126 16, /* bitsize */
1127 FALSE, /* pc_relative */
1128 0, /* bitpos */
1129 complain_overflow_signed, /* complain_on_overflow */
1130 bfd_elf_generic_reloc, /* special_function */
1131 "R_PPC64_ADDR16_DS", /* name */
1132 FALSE, /* partial_inplace */
1133 0, /* src_mask */
1134 0xfffc, /* dst_mask */
1135 FALSE), /* pcrel_offset */
1136
1137 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1138 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1139 0, /* rightshift */
1140 1, /* size (0 = byte, 1 = short, 2 = long) */
1141 16, /* bitsize */
1142 FALSE, /* pc_relative */
1143 0, /* bitpos */
1144 complain_overflow_dont,/* complain_on_overflow */
1145 bfd_elf_generic_reloc, /* special_function */
1146 "R_PPC64_ADDR16_LO_DS",/* name */
1147 FALSE, /* partial_inplace */
1148 0, /* src_mask */
1149 0xfffc, /* dst_mask */
1150 FALSE), /* pcrel_offset */
1151
1152 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1153 HOWTO (R_PPC64_GOT16_DS, /* type */
1154 0, /* rightshift */
1155 1, /* size (0 = byte, 1 = short, 2 = long) */
1156 16, /* bitsize */
1157 FALSE, /* pc_relative */
1158 0, /* bitpos */
1159 complain_overflow_signed, /* complain_on_overflow */
1160 ppc64_elf_unhandled_reloc, /* special_function */
1161 "R_PPC64_GOT16_DS", /* name */
1162 FALSE, /* partial_inplace */
1163 0, /* src_mask */
1164 0xfffc, /* dst_mask */
1165 FALSE), /* pcrel_offset */
1166
1167 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1168 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1169 0, /* rightshift */
1170 1, /* size (0 = byte, 1 = short, 2 = long) */
1171 16, /* bitsize */
1172 FALSE, /* pc_relative */
1173 0, /* bitpos */
1174 complain_overflow_dont, /* complain_on_overflow */
1175 ppc64_elf_unhandled_reloc, /* special_function */
1176 "R_PPC64_GOT16_LO_DS", /* name */
1177 FALSE, /* partial_inplace */
1178 0, /* src_mask */
1179 0xfffc, /* dst_mask */
1180 FALSE), /* pcrel_offset */
1181
1182 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1183 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1184 0, /* rightshift */
1185 1, /* size (0 = byte, 1 = short, 2 = long) */
1186 16, /* bitsize */
1187 FALSE, /* pc_relative */
1188 0, /* bitpos */
1189 complain_overflow_dont, /* complain_on_overflow */
1190 ppc64_elf_unhandled_reloc, /* special_function */
1191 "R_PPC64_PLT16_LO_DS", /* name */
1192 FALSE, /* partial_inplace */
1193 0, /* src_mask */
1194 0xfffc, /* dst_mask */
1195 FALSE), /* pcrel_offset */
1196
1197 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1198 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1199 0, /* rightshift */
1200 1, /* size (0 = byte, 1 = short, 2 = long) */
1201 16, /* bitsize */
1202 FALSE, /* pc_relative */
1203 0, /* bitpos */
1204 complain_overflow_signed, /* complain_on_overflow */
1205 ppc64_elf_sectoff_reloc, /* special_function */
1206 "R_PPC64_SECTOFF_DS", /* name */
1207 FALSE, /* partial_inplace */
1208 0, /* src_mask */
1209 0xfffc, /* dst_mask */
1210 FALSE), /* pcrel_offset */
1211
1212 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1213 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1214 0, /* rightshift */
1215 1, /* size (0 = byte, 1 = short, 2 = long) */
1216 16, /* bitsize */
1217 FALSE, /* pc_relative */
1218 0, /* bitpos */
1219 complain_overflow_dont, /* complain_on_overflow */
1220 ppc64_elf_sectoff_reloc, /* special_function */
1221 "R_PPC64_SECTOFF_LO_DS",/* name */
1222 FALSE, /* partial_inplace */
1223 0, /* src_mask */
1224 0xfffc, /* dst_mask */
1225 FALSE), /* pcrel_offset */
1226
1227 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1228 HOWTO (R_PPC64_TOC16_DS, /* type */
1229 0, /* rightshift */
1230 1, /* size (0 = byte, 1 = short, 2 = long) */
1231 16, /* bitsize */
1232 FALSE, /* pc_relative */
1233 0, /* bitpos */
1234 complain_overflow_signed, /* complain_on_overflow */
1235 ppc64_elf_toc_reloc, /* special_function */
1236 "R_PPC64_TOC16_DS", /* name */
1237 FALSE, /* partial_inplace */
1238 0, /* src_mask */
1239 0xfffc, /* dst_mask */
1240 FALSE), /* pcrel_offset */
1241
1242 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1243 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1244 0, /* rightshift */
1245 1, /* size (0 = byte, 1 = short, 2 = long) */
1246 16, /* bitsize */
1247 FALSE, /* pc_relative */
1248 0, /* bitpos */
1249 complain_overflow_dont, /* complain_on_overflow */
1250 ppc64_elf_toc_reloc, /* special_function */
1251 "R_PPC64_TOC16_LO_DS", /* name */
1252 FALSE, /* partial_inplace */
1253 0, /* src_mask */
1254 0xfffc, /* dst_mask */
1255 FALSE), /* pcrel_offset */
1256
1257 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1258 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1259 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1260 0, /* rightshift */
1261 1, /* size (0 = byte, 1 = short, 2 = long) */
1262 16, /* bitsize */
1263 FALSE, /* pc_relative */
1264 0, /* bitpos */
1265 complain_overflow_signed, /* complain_on_overflow */
1266 ppc64_elf_unhandled_reloc, /* special_function */
1267 "R_PPC64_PLTGOT16_DS", /* name */
1268 FALSE, /* partial_inplace */
1269 0, /* src_mask */
1270 0xfffc, /* dst_mask */
1271 FALSE), /* pcrel_offset */
1272
1273 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1274 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1275 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1276 0, /* rightshift */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 16, /* bitsize */
1279 FALSE, /* pc_relative */
1280 0, /* bitpos */
1281 complain_overflow_dont, /* complain_on_overflow */
1282 ppc64_elf_unhandled_reloc, /* special_function */
1283 "R_PPC64_PLTGOT16_LO_DS",/* name */
1284 FALSE, /* partial_inplace */
1285 0, /* src_mask */
1286 0xfffc, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1288
1289 /* Marker relocs for TLS. */
1290 HOWTO (R_PPC64_TLS,
1291 0, /* rightshift */
1292 2, /* size (0 = byte, 1 = short, 2 = long) */
1293 32, /* bitsize */
1294 FALSE, /* pc_relative */
1295 0, /* bitpos */
1296 complain_overflow_dont, /* complain_on_overflow */
1297 bfd_elf_generic_reloc, /* special_function */
1298 "R_PPC64_TLS", /* name */
1299 FALSE, /* partial_inplace */
1300 0, /* src_mask */
1301 0, /* dst_mask */
1302 FALSE), /* pcrel_offset */
1303
1304 HOWTO (R_PPC64_TLSGD,
1305 0, /* rightshift */
1306 2, /* size (0 = byte, 1 = short, 2 = long) */
1307 32, /* bitsize */
1308 FALSE, /* pc_relative */
1309 0, /* bitpos */
1310 complain_overflow_dont, /* complain_on_overflow */
1311 bfd_elf_generic_reloc, /* special_function */
1312 "R_PPC64_TLSGD", /* name */
1313 FALSE, /* partial_inplace */
1314 0, /* src_mask */
1315 0, /* dst_mask */
1316 FALSE), /* pcrel_offset */
1317
1318 HOWTO (R_PPC64_TLSLD,
1319 0, /* rightshift */
1320 2, /* size (0 = byte, 1 = short, 2 = long) */
1321 32, /* bitsize */
1322 FALSE, /* pc_relative */
1323 0, /* bitpos */
1324 complain_overflow_dont, /* complain_on_overflow */
1325 bfd_elf_generic_reloc, /* special_function */
1326 "R_PPC64_TLSLD", /* name */
1327 FALSE, /* partial_inplace */
1328 0, /* src_mask */
1329 0, /* dst_mask */
1330 FALSE), /* pcrel_offset */
1331
1332 HOWTO (R_PPC64_TOCSAVE,
1333 0, /* rightshift */
1334 2, /* size (0 = byte, 1 = short, 2 = long) */
1335 32, /* bitsize */
1336 FALSE, /* pc_relative */
1337 0, /* bitpos */
1338 complain_overflow_dont, /* complain_on_overflow */
1339 bfd_elf_generic_reloc, /* special_function */
1340 "R_PPC64_TOCSAVE", /* name */
1341 FALSE, /* partial_inplace */
1342 0, /* src_mask */
1343 0, /* dst_mask */
1344 FALSE), /* pcrel_offset */
1345
1346 /* Computes the load module index of the load module that contains the
1347 definition of its TLS sym. */
1348 HOWTO (R_PPC64_DTPMOD64,
1349 0, /* rightshift */
1350 4, /* size (0 = byte, 1 = short, 2 = long) */
1351 64, /* bitsize */
1352 FALSE, /* pc_relative */
1353 0, /* bitpos */
1354 complain_overflow_dont, /* complain_on_overflow */
1355 ppc64_elf_unhandled_reloc, /* special_function */
1356 "R_PPC64_DTPMOD64", /* name */
1357 FALSE, /* partial_inplace */
1358 0, /* src_mask */
1359 ONES (64), /* dst_mask */
1360 FALSE), /* pcrel_offset */
1361
1362 /* Computes a dtv-relative displacement, the difference between the value
1363 of sym+add and the base address of the thread-local storage block that
1364 contains the definition of sym, minus 0x8000. */
1365 HOWTO (R_PPC64_DTPREL64,
1366 0, /* rightshift */
1367 4, /* size (0 = byte, 1 = short, 2 = long) */
1368 64, /* bitsize */
1369 FALSE, /* pc_relative */
1370 0, /* bitpos */
1371 complain_overflow_dont, /* complain_on_overflow */
1372 ppc64_elf_unhandled_reloc, /* special_function */
1373 "R_PPC64_DTPREL64", /* name */
1374 FALSE, /* partial_inplace */
1375 0, /* src_mask */
1376 ONES (64), /* dst_mask */
1377 FALSE), /* pcrel_offset */
1378
1379 /* A 16 bit dtprel reloc. */
1380 HOWTO (R_PPC64_DTPREL16,
1381 0, /* rightshift */
1382 1, /* size (0 = byte, 1 = short, 2 = long) */
1383 16, /* bitsize */
1384 FALSE, /* pc_relative */
1385 0, /* bitpos */
1386 complain_overflow_signed, /* complain_on_overflow */
1387 ppc64_elf_unhandled_reloc, /* special_function */
1388 "R_PPC64_DTPREL16", /* name */
1389 FALSE, /* partial_inplace */
1390 0, /* src_mask */
1391 0xffff, /* dst_mask */
1392 FALSE), /* pcrel_offset */
1393
1394 /* Like DTPREL16, but no overflow. */
1395 HOWTO (R_PPC64_DTPREL16_LO,
1396 0, /* rightshift */
1397 1, /* size (0 = byte, 1 = short, 2 = long) */
1398 16, /* bitsize */
1399 FALSE, /* pc_relative */
1400 0, /* bitpos */
1401 complain_overflow_dont, /* complain_on_overflow */
1402 ppc64_elf_unhandled_reloc, /* special_function */
1403 "R_PPC64_DTPREL16_LO", /* name */
1404 FALSE, /* partial_inplace */
1405 0, /* src_mask */
1406 0xffff, /* dst_mask */
1407 FALSE), /* pcrel_offset */
1408
1409 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1410 HOWTO (R_PPC64_DTPREL16_HI,
1411 16, /* rightshift */
1412 1, /* size (0 = byte, 1 = short, 2 = long) */
1413 16, /* bitsize */
1414 FALSE, /* pc_relative */
1415 0, /* bitpos */
1416 complain_overflow_signed, /* complain_on_overflow */
1417 ppc64_elf_unhandled_reloc, /* special_function */
1418 "R_PPC64_DTPREL16_HI", /* name */
1419 FALSE, /* partial_inplace */
1420 0, /* src_mask */
1421 0xffff, /* dst_mask */
1422 FALSE), /* pcrel_offset */
1423
1424 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1425 HOWTO (R_PPC64_DTPREL16_HA,
1426 16, /* rightshift */
1427 1, /* size (0 = byte, 1 = short, 2 = long) */
1428 16, /* bitsize */
1429 FALSE, /* pc_relative */
1430 0, /* bitpos */
1431 complain_overflow_signed, /* complain_on_overflow */
1432 ppc64_elf_unhandled_reloc, /* special_function */
1433 "R_PPC64_DTPREL16_HA", /* name */
1434 FALSE, /* partial_inplace */
1435 0, /* src_mask */
1436 0xffff, /* dst_mask */
1437 FALSE), /* pcrel_offset */
1438
1439 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1440 HOWTO (R_PPC64_DTPREL16_HIGHER,
1441 32, /* rightshift */
1442 1, /* size (0 = byte, 1 = short, 2 = long) */
1443 16, /* bitsize */
1444 FALSE, /* pc_relative */
1445 0, /* bitpos */
1446 complain_overflow_dont, /* complain_on_overflow */
1447 ppc64_elf_unhandled_reloc, /* special_function */
1448 "R_PPC64_DTPREL16_HIGHER", /* name */
1449 FALSE, /* partial_inplace */
1450 0, /* src_mask */
1451 0xffff, /* dst_mask */
1452 FALSE), /* pcrel_offset */
1453
1454 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1455 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1456 32, /* rightshift */
1457 1, /* size (0 = byte, 1 = short, 2 = long) */
1458 16, /* bitsize */
1459 FALSE, /* pc_relative */
1460 0, /* bitpos */
1461 complain_overflow_dont, /* complain_on_overflow */
1462 ppc64_elf_unhandled_reloc, /* special_function */
1463 "R_PPC64_DTPREL16_HIGHERA", /* name */
1464 FALSE, /* partial_inplace */
1465 0, /* src_mask */
1466 0xffff, /* dst_mask */
1467 FALSE), /* pcrel_offset */
1468
1469 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1470 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1471 48, /* rightshift */
1472 1, /* size (0 = byte, 1 = short, 2 = long) */
1473 16, /* bitsize */
1474 FALSE, /* pc_relative */
1475 0, /* bitpos */
1476 complain_overflow_dont, /* complain_on_overflow */
1477 ppc64_elf_unhandled_reloc, /* special_function */
1478 "R_PPC64_DTPREL16_HIGHEST", /* name */
1479 FALSE, /* partial_inplace */
1480 0, /* src_mask */
1481 0xffff, /* dst_mask */
1482 FALSE), /* pcrel_offset */
1483
1484 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1485 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1486 48, /* rightshift */
1487 1, /* size (0 = byte, 1 = short, 2 = long) */
1488 16, /* bitsize */
1489 FALSE, /* pc_relative */
1490 0, /* bitpos */
1491 complain_overflow_dont, /* complain_on_overflow */
1492 ppc64_elf_unhandled_reloc, /* special_function */
1493 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1494 FALSE, /* partial_inplace */
1495 0, /* src_mask */
1496 0xffff, /* dst_mask */
1497 FALSE), /* pcrel_offset */
1498
1499 /* Like DTPREL16, but for insns with a DS field. */
1500 HOWTO (R_PPC64_DTPREL16_DS,
1501 0, /* rightshift */
1502 1, /* size (0 = byte, 1 = short, 2 = long) */
1503 16, /* bitsize */
1504 FALSE, /* pc_relative */
1505 0, /* bitpos */
1506 complain_overflow_signed, /* complain_on_overflow */
1507 ppc64_elf_unhandled_reloc, /* special_function */
1508 "R_PPC64_DTPREL16_DS", /* name */
1509 FALSE, /* partial_inplace */
1510 0, /* src_mask */
1511 0xfffc, /* dst_mask */
1512 FALSE), /* pcrel_offset */
1513
1514 /* Like DTPREL16_DS, but no overflow. */
1515 HOWTO (R_PPC64_DTPREL16_LO_DS,
1516 0, /* rightshift */
1517 1, /* size (0 = byte, 1 = short, 2 = long) */
1518 16, /* bitsize */
1519 FALSE, /* pc_relative */
1520 0, /* bitpos */
1521 complain_overflow_dont, /* complain_on_overflow */
1522 ppc64_elf_unhandled_reloc, /* special_function */
1523 "R_PPC64_DTPREL16_LO_DS", /* name */
1524 FALSE, /* partial_inplace */
1525 0, /* src_mask */
1526 0xfffc, /* dst_mask */
1527 FALSE), /* pcrel_offset */
1528
1529 /* Computes a tp-relative displacement, the difference between the value of
1530 sym+add and the value of the thread pointer (r13). */
1531 HOWTO (R_PPC64_TPREL64,
1532 0, /* rightshift */
1533 4, /* size (0 = byte, 1 = short, 2 = long) */
1534 64, /* bitsize */
1535 FALSE, /* pc_relative */
1536 0, /* bitpos */
1537 complain_overflow_dont, /* complain_on_overflow */
1538 ppc64_elf_unhandled_reloc, /* special_function */
1539 "R_PPC64_TPREL64", /* name */
1540 FALSE, /* partial_inplace */
1541 0, /* src_mask */
1542 ONES (64), /* dst_mask */
1543 FALSE), /* pcrel_offset */
1544
1545 /* A 16 bit tprel reloc. */
1546 HOWTO (R_PPC64_TPREL16,
1547 0, /* rightshift */
1548 1, /* size (0 = byte, 1 = short, 2 = long) */
1549 16, /* bitsize */
1550 FALSE, /* pc_relative */
1551 0, /* bitpos */
1552 complain_overflow_signed, /* complain_on_overflow */
1553 ppc64_elf_unhandled_reloc, /* special_function */
1554 "R_PPC64_TPREL16", /* name */
1555 FALSE, /* partial_inplace */
1556 0, /* src_mask */
1557 0xffff, /* dst_mask */
1558 FALSE), /* pcrel_offset */
1559
1560 /* Like TPREL16, but no overflow. */
1561 HOWTO (R_PPC64_TPREL16_LO,
1562 0, /* rightshift */
1563 1, /* size (0 = byte, 1 = short, 2 = long) */
1564 16, /* bitsize */
1565 FALSE, /* pc_relative */
1566 0, /* bitpos */
1567 complain_overflow_dont, /* complain_on_overflow */
1568 ppc64_elf_unhandled_reloc, /* special_function */
1569 "R_PPC64_TPREL16_LO", /* name */
1570 FALSE, /* partial_inplace */
1571 0, /* src_mask */
1572 0xffff, /* dst_mask */
1573 FALSE), /* pcrel_offset */
1574
1575 /* Like TPREL16_LO, but next higher group of 16 bits. */
1576 HOWTO (R_PPC64_TPREL16_HI,
1577 16, /* rightshift */
1578 1, /* size (0 = byte, 1 = short, 2 = long) */
1579 16, /* bitsize */
1580 FALSE, /* pc_relative */
1581 0, /* bitpos */
1582 complain_overflow_signed, /* complain_on_overflow */
1583 ppc64_elf_unhandled_reloc, /* special_function */
1584 "R_PPC64_TPREL16_HI", /* name */
1585 FALSE, /* partial_inplace */
1586 0, /* src_mask */
1587 0xffff, /* dst_mask */
1588 FALSE), /* pcrel_offset */
1589
1590 /* Like TPREL16_HI, but adjust for low 16 bits. */
1591 HOWTO (R_PPC64_TPREL16_HA,
1592 16, /* rightshift */
1593 1, /* size (0 = byte, 1 = short, 2 = long) */
1594 16, /* bitsize */
1595 FALSE, /* pc_relative */
1596 0, /* bitpos */
1597 complain_overflow_signed, /* complain_on_overflow */
1598 ppc64_elf_unhandled_reloc, /* special_function */
1599 "R_PPC64_TPREL16_HA", /* name */
1600 FALSE, /* partial_inplace */
1601 0, /* src_mask */
1602 0xffff, /* dst_mask */
1603 FALSE), /* pcrel_offset */
1604
1605 /* Like TPREL16_HI, but next higher group of 16 bits. */
1606 HOWTO (R_PPC64_TPREL16_HIGHER,
1607 32, /* rightshift */
1608 1, /* size (0 = byte, 1 = short, 2 = long) */
1609 16, /* bitsize */
1610 FALSE, /* pc_relative */
1611 0, /* bitpos */
1612 complain_overflow_dont, /* complain_on_overflow */
1613 ppc64_elf_unhandled_reloc, /* special_function */
1614 "R_PPC64_TPREL16_HIGHER", /* name */
1615 FALSE, /* partial_inplace */
1616 0, /* src_mask */
1617 0xffff, /* dst_mask */
1618 FALSE), /* pcrel_offset */
1619
1620 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1621 HOWTO (R_PPC64_TPREL16_HIGHERA,
1622 32, /* rightshift */
1623 1, /* size (0 = byte, 1 = short, 2 = long) */
1624 16, /* bitsize */
1625 FALSE, /* pc_relative */
1626 0, /* bitpos */
1627 complain_overflow_dont, /* complain_on_overflow */
1628 ppc64_elf_unhandled_reloc, /* special_function */
1629 "R_PPC64_TPREL16_HIGHERA", /* name */
1630 FALSE, /* partial_inplace */
1631 0, /* src_mask */
1632 0xffff, /* dst_mask */
1633 FALSE), /* pcrel_offset */
1634
1635 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1636 HOWTO (R_PPC64_TPREL16_HIGHEST,
1637 48, /* rightshift */
1638 1, /* size (0 = byte, 1 = short, 2 = long) */
1639 16, /* bitsize */
1640 FALSE, /* pc_relative */
1641 0, /* bitpos */
1642 complain_overflow_dont, /* complain_on_overflow */
1643 ppc64_elf_unhandled_reloc, /* special_function */
1644 "R_PPC64_TPREL16_HIGHEST", /* name */
1645 FALSE, /* partial_inplace */
1646 0, /* src_mask */
1647 0xffff, /* dst_mask */
1648 FALSE), /* pcrel_offset */
1649
1650 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1651 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1652 48, /* rightshift */
1653 1, /* size (0 = byte, 1 = short, 2 = long) */
1654 16, /* bitsize */
1655 FALSE, /* pc_relative */
1656 0, /* bitpos */
1657 complain_overflow_dont, /* complain_on_overflow */
1658 ppc64_elf_unhandled_reloc, /* special_function */
1659 "R_PPC64_TPREL16_HIGHESTA", /* name */
1660 FALSE, /* partial_inplace */
1661 0, /* src_mask */
1662 0xffff, /* dst_mask */
1663 FALSE), /* pcrel_offset */
1664
1665 /* Like TPREL16, but for insns with a DS field. */
1666 HOWTO (R_PPC64_TPREL16_DS,
1667 0, /* rightshift */
1668 1, /* size (0 = byte, 1 = short, 2 = long) */
1669 16, /* bitsize */
1670 FALSE, /* pc_relative */
1671 0, /* bitpos */
1672 complain_overflow_signed, /* complain_on_overflow */
1673 ppc64_elf_unhandled_reloc, /* special_function */
1674 "R_PPC64_TPREL16_DS", /* name */
1675 FALSE, /* partial_inplace */
1676 0, /* src_mask */
1677 0xfffc, /* dst_mask */
1678 FALSE), /* pcrel_offset */
1679
1680 /* Like TPREL16_DS, but no overflow. */
1681 HOWTO (R_PPC64_TPREL16_LO_DS,
1682 0, /* rightshift */
1683 1, /* size (0 = byte, 1 = short, 2 = long) */
1684 16, /* bitsize */
1685 FALSE, /* pc_relative */
1686 0, /* bitpos */
1687 complain_overflow_dont, /* complain_on_overflow */
1688 ppc64_elf_unhandled_reloc, /* special_function */
1689 "R_PPC64_TPREL16_LO_DS", /* name */
1690 FALSE, /* partial_inplace */
1691 0, /* src_mask */
1692 0xfffc, /* dst_mask */
1693 FALSE), /* pcrel_offset */
1694
1695 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1696 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1697 to the first entry relative to the TOC base (r2). */
1698 HOWTO (R_PPC64_GOT_TLSGD16,
1699 0, /* rightshift */
1700 1, /* size (0 = byte, 1 = short, 2 = long) */
1701 16, /* bitsize */
1702 FALSE, /* pc_relative */
1703 0, /* bitpos */
1704 complain_overflow_signed, /* complain_on_overflow */
1705 ppc64_elf_unhandled_reloc, /* special_function */
1706 "R_PPC64_GOT_TLSGD16", /* name */
1707 FALSE, /* partial_inplace */
1708 0, /* src_mask */
1709 0xffff, /* dst_mask */
1710 FALSE), /* pcrel_offset */
1711
1712 /* Like GOT_TLSGD16, but no overflow. */
1713 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1714 0, /* rightshift */
1715 1, /* size (0 = byte, 1 = short, 2 = long) */
1716 16, /* bitsize */
1717 FALSE, /* pc_relative */
1718 0, /* bitpos */
1719 complain_overflow_dont, /* complain_on_overflow */
1720 ppc64_elf_unhandled_reloc, /* special_function */
1721 "R_PPC64_GOT_TLSGD16_LO", /* name */
1722 FALSE, /* partial_inplace */
1723 0, /* src_mask */
1724 0xffff, /* dst_mask */
1725 FALSE), /* pcrel_offset */
1726
1727 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1728 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1729 16, /* rightshift */
1730 1, /* size (0 = byte, 1 = short, 2 = long) */
1731 16, /* bitsize */
1732 FALSE, /* pc_relative */
1733 0, /* bitpos */
1734 complain_overflow_signed, /* complain_on_overflow */
1735 ppc64_elf_unhandled_reloc, /* special_function */
1736 "R_PPC64_GOT_TLSGD16_HI", /* name */
1737 FALSE, /* partial_inplace */
1738 0, /* src_mask */
1739 0xffff, /* dst_mask */
1740 FALSE), /* pcrel_offset */
1741
1742 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1743 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1744 16, /* rightshift */
1745 1, /* size (0 = byte, 1 = short, 2 = long) */
1746 16, /* bitsize */
1747 FALSE, /* pc_relative */
1748 0, /* bitpos */
1749 complain_overflow_signed, /* complain_on_overflow */
1750 ppc64_elf_unhandled_reloc, /* special_function */
1751 "R_PPC64_GOT_TLSGD16_HA", /* name */
1752 FALSE, /* partial_inplace */
1753 0, /* src_mask */
1754 0xffff, /* dst_mask */
1755 FALSE), /* pcrel_offset */
1756
1757 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1758 with values (sym+add)@dtpmod and zero, and computes the offset to the
1759 first entry relative to the TOC base (r2). */
1760 HOWTO (R_PPC64_GOT_TLSLD16,
1761 0, /* rightshift */
1762 1, /* size (0 = byte, 1 = short, 2 = long) */
1763 16, /* bitsize */
1764 FALSE, /* pc_relative */
1765 0, /* bitpos */
1766 complain_overflow_signed, /* complain_on_overflow */
1767 ppc64_elf_unhandled_reloc, /* special_function */
1768 "R_PPC64_GOT_TLSLD16", /* name */
1769 FALSE, /* partial_inplace */
1770 0, /* src_mask */
1771 0xffff, /* dst_mask */
1772 FALSE), /* pcrel_offset */
1773
1774 /* Like GOT_TLSLD16, but no overflow. */
1775 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1776 0, /* rightshift */
1777 1, /* size (0 = byte, 1 = short, 2 = long) */
1778 16, /* bitsize */
1779 FALSE, /* pc_relative */
1780 0, /* bitpos */
1781 complain_overflow_dont, /* complain_on_overflow */
1782 ppc64_elf_unhandled_reloc, /* special_function */
1783 "R_PPC64_GOT_TLSLD16_LO", /* name */
1784 FALSE, /* partial_inplace */
1785 0, /* src_mask */
1786 0xffff, /* dst_mask */
1787 FALSE), /* pcrel_offset */
1788
1789 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1790 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1791 16, /* rightshift */
1792 1, /* size (0 = byte, 1 = short, 2 = long) */
1793 16, /* bitsize */
1794 FALSE, /* pc_relative */
1795 0, /* bitpos */
1796 complain_overflow_signed, /* complain_on_overflow */
1797 ppc64_elf_unhandled_reloc, /* special_function */
1798 "R_PPC64_GOT_TLSLD16_HI", /* name */
1799 FALSE, /* partial_inplace */
1800 0, /* src_mask */
1801 0xffff, /* dst_mask */
1802 FALSE), /* pcrel_offset */
1803
1804 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1805 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1806 16, /* rightshift */
1807 1, /* size (0 = byte, 1 = short, 2 = long) */
1808 16, /* bitsize */
1809 FALSE, /* pc_relative */
1810 0, /* bitpos */
1811 complain_overflow_signed, /* complain_on_overflow */
1812 ppc64_elf_unhandled_reloc, /* special_function */
1813 "R_PPC64_GOT_TLSLD16_HA", /* name */
1814 FALSE, /* partial_inplace */
1815 0, /* src_mask */
1816 0xffff, /* dst_mask */
1817 FALSE), /* pcrel_offset */
1818
1819 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1820 the offset to the entry relative to the TOC base (r2). */
1821 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1822 0, /* rightshift */
1823 1, /* size (0 = byte, 1 = short, 2 = long) */
1824 16, /* bitsize */
1825 FALSE, /* pc_relative */
1826 0, /* bitpos */
1827 complain_overflow_signed, /* complain_on_overflow */
1828 ppc64_elf_unhandled_reloc, /* special_function */
1829 "R_PPC64_GOT_DTPREL16_DS", /* name */
1830 FALSE, /* partial_inplace */
1831 0, /* src_mask */
1832 0xfffc, /* dst_mask */
1833 FALSE), /* pcrel_offset */
1834
1835 /* Like GOT_DTPREL16_DS, but no overflow. */
1836 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1837 0, /* rightshift */
1838 1, /* size (0 = byte, 1 = short, 2 = long) */
1839 16, /* bitsize */
1840 FALSE, /* pc_relative */
1841 0, /* bitpos */
1842 complain_overflow_dont, /* complain_on_overflow */
1843 ppc64_elf_unhandled_reloc, /* special_function */
1844 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1845 FALSE, /* partial_inplace */
1846 0, /* src_mask */
1847 0xfffc, /* dst_mask */
1848 FALSE), /* pcrel_offset */
1849
1850 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1851 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1852 16, /* rightshift */
1853 1, /* size (0 = byte, 1 = short, 2 = long) */
1854 16, /* bitsize */
1855 FALSE, /* pc_relative */
1856 0, /* bitpos */
1857 complain_overflow_signed, /* complain_on_overflow */
1858 ppc64_elf_unhandled_reloc, /* special_function */
1859 "R_PPC64_GOT_DTPREL16_HI", /* name */
1860 FALSE, /* partial_inplace */
1861 0, /* src_mask */
1862 0xffff, /* dst_mask */
1863 FALSE), /* pcrel_offset */
1864
1865 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1866 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1867 16, /* rightshift */
1868 1, /* size (0 = byte, 1 = short, 2 = long) */
1869 16, /* bitsize */
1870 FALSE, /* pc_relative */
1871 0, /* bitpos */
1872 complain_overflow_signed, /* complain_on_overflow */
1873 ppc64_elf_unhandled_reloc, /* special_function */
1874 "R_PPC64_GOT_DTPREL16_HA", /* name */
1875 FALSE, /* partial_inplace */
1876 0, /* src_mask */
1877 0xffff, /* dst_mask */
1878 FALSE), /* pcrel_offset */
1879
1880 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1881 offset to the entry relative to the TOC base (r2). */
1882 HOWTO (R_PPC64_GOT_TPREL16_DS,
1883 0, /* rightshift */
1884 1, /* size (0 = byte, 1 = short, 2 = long) */
1885 16, /* bitsize */
1886 FALSE, /* pc_relative */
1887 0, /* bitpos */
1888 complain_overflow_signed, /* complain_on_overflow */
1889 ppc64_elf_unhandled_reloc, /* special_function */
1890 "R_PPC64_GOT_TPREL16_DS", /* name */
1891 FALSE, /* partial_inplace */
1892 0, /* src_mask */
1893 0xfffc, /* dst_mask */
1894 FALSE), /* pcrel_offset */
1895
1896 /* Like GOT_TPREL16_DS, but no overflow. */
1897 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1898 0, /* rightshift */
1899 1, /* size (0 = byte, 1 = short, 2 = long) */
1900 16, /* bitsize */
1901 FALSE, /* pc_relative */
1902 0, /* bitpos */
1903 complain_overflow_dont, /* complain_on_overflow */
1904 ppc64_elf_unhandled_reloc, /* special_function */
1905 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1906 FALSE, /* partial_inplace */
1907 0, /* src_mask */
1908 0xfffc, /* dst_mask */
1909 FALSE), /* pcrel_offset */
1910
1911 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1912 HOWTO (R_PPC64_GOT_TPREL16_HI,
1913 16, /* rightshift */
1914 1, /* size (0 = byte, 1 = short, 2 = long) */
1915 16, /* bitsize */
1916 FALSE, /* pc_relative */
1917 0, /* bitpos */
1918 complain_overflow_signed, /* complain_on_overflow */
1919 ppc64_elf_unhandled_reloc, /* special_function */
1920 "R_PPC64_GOT_TPREL16_HI", /* name */
1921 FALSE, /* partial_inplace */
1922 0, /* src_mask */
1923 0xffff, /* dst_mask */
1924 FALSE), /* pcrel_offset */
1925
1926 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1927 HOWTO (R_PPC64_GOT_TPREL16_HA,
1928 16, /* rightshift */
1929 1, /* size (0 = byte, 1 = short, 2 = long) */
1930 16, /* bitsize */
1931 FALSE, /* pc_relative */
1932 0, /* bitpos */
1933 complain_overflow_signed, /* complain_on_overflow */
1934 ppc64_elf_unhandled_reloc, /* special_function */
1935 "R_PPC64_GOT_TPREL16_HA", /* name */
1936 FALSE, /* partial_inplace */
1937 0, /* src_mask */
1938 0xffff, /* dst_mask */
1939 FALSE), /* pcrel_offset */
1940
1941 HOWTO (R_PPC64_JMP_IREL, /* type */
1942 0, /* rightshift */
1943 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1944 0, /* bitsize */
1945 FALSE, /* pc_relative */
1946 0, /* bitpos */
1947 complain_overflow_dont, /* complain_on_overflow */
1948 ppc64_elf_unhandled_reloc, /* special_function */
1949 "R_PPC64_JMP_IREL", /* name */
1950 FALSE, /* partial_inplace */
1951 0, /* src_mask */
1952 0, /* dst_mask */
1953 FALSE), /* pcrel_offset */
1954
1955 HOWTO (R_PPC64_IRELATIVE, /* type */
1956 0, /* rightshift */
1957 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1958 64, /* bitsize */
1959 FALSE, /* pc_relative */
1960 0, /* bitpos */
1961 complain_overflow_dont, /* complain_on_overflow */
1962 bfd_elf_generic_reloc, /* special_function */
1963 "R_PPC64_IRELATIVE", /* name */
1964 FALSE, /* partial_inplace */
1965 0, /* src_mask */
1966 ONES (64), /* dst_mask */
1967 FALSE), /* pcrel_offset */
1968
1969 /* A 16 bit relative relocation. */
1970 HOWTO (R_PPC64_REL16, /* type */
1971 0, /* rightshift */
1972 1, /* size (0 = byte, 1 = short, 2 = long) */
1973 16, /* bitsize */
1974 TRUE, /* pc_relative */
1975 0, /* bitpos */
1976 complain_overflow_signed, /* complain_on_overflow */
1977 bfd_elf_generic_reloc, /* special_function */
1978 "R_PPC64_REL16", /* name */
1979 FALSE, /* partial_inplace */
1980 0, /* src_mask */
1981 0xffff, /* dst_mask */
1982 TRUE), /* pcrel_offset */
1983
1984 /* A 16 bit relative relocation without overflow. */
1985 HOWTO (R_PPC64_REL16_LO, /* type */
1986 0, /* rightshift */
1987 1, /* size (0 = byte, 1 = short, 2 = long) */
1988 16, /* bitsize */
1989 TRUE, /* pc_relative */
1990 0, /* bitpos */
1991 complain_overflow_dont,/* complain_on_overflow */
1992 bfd_elf_generic_reloc, /* special_function */
1993 "R_PPC64_REL16_LO", /* name */
1994 FALSE, /* partial_inplace */
1995 0, /* src_mask */
1996 0xffff, /* dst_mask */
1997 TRUE), /* pcrel_offset */
1998
1999 /* The high order 16 bits of a relative address. */
2000 HOWTO (R_PPC64_REL16_HI, /* type */
2001 16, /* rightshift */
2002 1, /* size (0 = byte, 1 = short, 2 = long) */
2003 16, /* bitsize */
2004 TRUE, /* pc_relative */
2005 0, /* bitpos */
2006 complain_overflow_signed, /* complain_on_overflow */
2007 bfd_elf_generic_reloc, /* special_function */
2008 "R_PPC64_REL16_HI", /* name */
2009 FALSE, /* partial_inplace */
2010 0, /* src_mask */
2011 0xffff, /* dst_mask */
2012 TRUE), /* pcrel_offset */
2013
2014 /* The high order 16 bits of a relative address, plus 1 if the contents of
2015 the low 16 bits, treated as a signed number, is negative. */
2016 HOWTO (R_PPC64_REL16_HA, /* type */
2017 16, /* rightshift */
2018 1, /* size (0 = byte, 1 = short, 2 = long) */
2019 16, /* bitsize */
2020 TRUE, /* pc_relative */
2021 0, /* bitpos */
2022 complain_overflow_signed, /* complain_on_overflow */
2023 ppc64_elf_ha_reloc, /* special_function */
2024 "R_PPC64_REL16_HA", /* name */
2025 FALSE, /* partial_inplace */
2026 0, /* src_mask */
2027 0xffff, /* dst_mask */
2028 TRUE), /* pcrel_offset */
2029
2030 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2031 HOWTO (R_PPC64_REL16DX_HA, /* type */
2032 16, /* rightshift */
2033 2, /* size (0 = byte, 1 = short, 2 = long) */
2034 16, /* bitsize */
2035 TRUE, /* pc_relative */
2036 0, /* bitpos */
2037 complain_overflow_signed, /* complain_on_overflow */
2038 ppc64_elf_ha_reloc, /* special_function */
2039 "R_PPC64_REL16DX_HA", /* name */
2040 FALSE, /* partial_inplace */
2041 0, /* src_mask */
2042 0x1fffc1, /* dst_mask */
2043 TRUE), /* pcrel_offset */
2044
2045 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2046 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2047 16, /* rightshift */
2048 1, /* size (0 = byte, 1 = short, 2 = long) */
2049 16, /* bitsize */
2050 FALSE, /* pc_relative */
2051 0, /* bitpos */
2052 complain_overflow_dont, /* complain_on_overflow */
2053 bfd_elf_generic_reloc, /* special_function */
2054 "R_PPC64_ADDR16_HIGH", /* name */
2055 FALSE, /* partial_inplace */
2056 0, /* src_mask */
2057 0xffff, /* dst_mask */
2058 FALSE), /* pcrel_offset */
2059
2060 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2061 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2062 16, /* rightshift */
2063 1, /* size (0 = byte, 1 = short, 2 = long) */
2064 16, /* bitsize */
2065 FALSE, /* pc_relative */
2066 0, /* bitpos */
2067 complain_overflow_dont, /* complain_on_overflow */
2068 ppc64_elf_ha_reloc, /* special_function */
2069 "R_PPC64_ADDR16_HIGHA", /* name */
2070 FALSE, /* partial_inplace */
2071 0, /* src_mask */
2072 0xffff, /* dst_mask */
2073 FALSE), /* pcrel_offset */
2074
2075 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2076 HOWTO (R_PPC64_DTPREL16_HIGH,
2077 16, /* rightshift */
2078 1, /* size (0 = byte, 1 = short, 2 = long) */
2079 16, /* bitsize */
2080 FALSE, /* pc_relative */
2081 0, /* bitpos */
2082 complain_overflow_dont, /* complain_on_overflow */
2083 ppc64_elf_unhandled_reloc, /* special_function */
2084 "R_PPC64_DTPREL16_HIGH", /* name */
2085 FALSE, /* partial_inplace */
2086 0, /* src_mask */
2087 0xffff, /* dst_mask */
2088 FALSE), /* pcrel_offset */
2089
2090 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2091 HOWTO (R_PPC64_DTPREL16_HIGHA,
2092 16, /* rightshift */
2093 1, /* size (0 = byte, 1 = short, 2 = long) */
2094 16, /* bitsize */
2095 FALSE, /* pc_relative */
2096 0, /* bitpos */
2097 complain_overflow_dont, /* complain_on_overflow */
2098 ppc64_elf_unhandled_reloc, /* special_function */
2099 "R_PPC64_DTPREL16_HIGHA", /* name */
2100 FALSE, /* partial_inplace */
2101 0, /* src_mask */
2102 0xffff, /* dst_mask */
2103 FALSE), /* pcrel_offset */
2104
2105 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2106 HOWTO (R_PPC64_TPREL16_HIGH,
2107 16, /* rightshift */
2108 1, /* size (0 = byte, 1 = short, 2 = long) */
2109 16, /* bitsize */
2110 FALSE, /* pc_relative */
2111 0, /* bitpos */
2112 complain_overflow_dont, /* complain_on_overflow */
2113 ppc64_elf_unhandled_reloc, /* special_function */
2114 "R_PPC64_TPREL16_HIGH", /* name */
2115 FALSE, /* partial_inplace */
2116 0, /* src_mask */
2117 0xffff, /* dst_mask */
2118 FALSE), /* pcrel_offset */
2119
2120 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2121 HOWTO (R_PPC64_TPREL16_HIGHA,
2122 16, /* rightshift */
2123 1, /* size (0 = byte, 1 = short, 2 = long) */
2124 16, /* bitsize */
2125 FALSE, /* pc_relative */
2126 0, /* bitpos */
2127 complain_overflow_dont, /* complain_on_overflow */
2128 ppc64_elf_unhandled_reloc, /* special_function */
2129 "R_PPC64_TPREL16_HIGHA", /* name */
2130 FALSE, /* partial_inplace */
2131 0, /* src_mask */
2132 0xffff, /* dst_mask */
2133 FALSE), /* pcrel_offset */
2134
2135 /* Marker reloc on ELFv2 large-model function entry. */
2136 HOWTO (R_PPC64_ENTRY,
2137 0, /* rightshift */
2138 2, /* size (0 = byte, 1 = short, 2 = long) */
2139 32, /* bitsize */
2140 FALSE, /* pc_relative */
2141 0, /* bitpos */
2142 complain_overflow_dont, /* complain_on_overflow */
2143 bfd_elf_generic_reloc, /* special_function */
2144 "R_PPC64_ENTRY", /* name */
2145 FALSE, /* partial_inplace */
2146 0, /* src_mask */
2147 0, /* dst_mask */
2148 FALSE), /* pcrel_offset */
2149
2150 /* Like ADDR64, but use local entry point of function. */
2151 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2152 0, /* rightshift */
2153 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2154 64, /* bitsize */
2155 FALSE, /* pc_relative */
2156 0, /* bitpos */
2157 complain_overflow_dont, /* complain_on_overflow */
2158 bfd_elf_generic_reloc, /* special_function */
2159 "R_PPC64_ADDR64_LOCAL", /* name */
2160 FALSE, /* partial_inplace */
2161 0, /* src_mask */
2162 ONES (64), /* dst_mask */
2163 FALSE), /* pcrel_offset */
2164
2165 /* GNU extension to record C++ vtable hierarchy. */
2166 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2167 0, /* rightshift */
2168 0, /* size (0 = byte, 1 = short, 2 = long) */
2169 0, /* bitsize */
2170 FALSE, /* pc_relative */
2171 0, /* bitpos */
2172 complain_overflow_dont, /* complain_on_overflow */
2173 NULL, /* special_function */
2174 "R_PPC64_GNU_VTINHERIT", /* name */
2175 FALSE, /* partial_inplace */
2176 0, /* src_mask */
2177 0, /* dst_mask */
2178 FALSE), /* pcrel_offset */
2179
2180 /* GNU extension to record C++ vtable member usage. */
2181 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2182 0, /* rightshift */
2183 0, /* size (0 = byte, 1 = short, 2 = long) */
2184 0, /* bitsize */
2185 FALSE, /* pc_relative */
2186 0, /* bitpos */
2187 complain_overflow_dont, /* complain_on_overflow */
2188 NULL, /* special_function */
2189 "R_PPC64_GNU_VTENTRY", /* name */
2190 FALSE, /* partial_inplace */
2191 0, /* src_mask */
2192 0, /* dst_mask */
2193 FALSE), /* pcrel_offset */
2194 };
2195
2196 \f
2197 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2198 be done. */
2199
2200 static void
2201 ppc_howto_init (void)
2202 {
2203 unsigned int i, type;
2204
2205 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2206 {
2207 type = ppc64_elf_howto_raw[i].type;
2208 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2209 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2210 }
2211 }
2212
2213 static reloc_howto_type *
2214 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2215 bfd_reloc_code_real_type code)
2216 {
2217 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2218
2219 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2220 /* Initialize howto table if needed. */
2221 ppc_howto_init ();
2222
2223 switch (code)
2224 {
2225 default:
2226 return NULL;
2227
2228 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2229 break;
2230 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2231 break;
2232 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2233 break;
2234 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2235 break;
2236 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2237 break;
2238 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2239 break;
2240 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2241 break;
2242 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2243 break;
2244 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2245 break;
2246 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2247 break;
2248 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2249 break;
2250 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2251 break;
2252 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2253 break;
2254 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2255 break;
2256 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2257 break;
2258 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2259 break;
2260 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2261 break;
2262 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2263 break;
2264 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2265 break;
2266 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2267 break;
2268 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2269 break;
2270 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2271 break;
2272 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2273 break;
2274 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2275 break;
2276 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2277 break;
2278 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2279 break;
2280 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2281 break;
2282 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2283 break;
2284 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2285 break;
2286 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2287 break;
2288 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2289 break;
2290 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2291 break;
2292 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2293 break;
2294 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2295 break;
2296 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2297 break;
2298 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2299 break;
2300 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2301 break;
2302 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2303 break;
2304 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2305 break;
2306 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2307 break;
2308 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2309 break;
2310 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2311 break;
2312 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2313 break;
2314 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2315 break;
2316 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2317 break;
2318 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2319 break;
2320 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2321 break;
2322 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2323 break;
2324 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2325 break;
2326 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2327 break;
2328 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2329 break;
2330 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2331 break;
2332 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2333 break;
2334 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2335 break;
2336 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2337 break;
2338 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2339 break;
2340 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2341 break;
2342 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2343 break;
2344 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2345 break;
2346 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2347 break;
2348 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2349 break;
2350 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2351 break;
2352 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2353 break;
2354 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2355 break;
2356 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2357 break;
2358 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2359 break;
2360 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2361 break;
2362 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2363 break;
2364 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2365 break;
2366 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2367 break;
2368 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2369 break;
2370 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2371 break;
2372 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2373 break;
2374 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2375 break;
2376 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2377 break;
2378 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2379 break;
2380 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2381 break;
2382 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2383 break;
2384 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2385 break;
2386 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2387 break;
2388 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2389 break;
2390 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2391 break;
2392 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2393 break;
2394 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2395 break;
2396 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2397 break;
2398 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2399 break;
2400 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2401 break;
2402 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2403 break;
2404 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2405 break;
2406 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2407 break;
2408 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2409 break;
2410 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2411 break;
2412 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2413 break;
2414 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2415 break;
2416 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2417 break;
2418 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2419 break;
2420 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2421 break;
2422 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2423 break;
2424 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2425 break;
2426 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2427 break;
2428 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2429 break;
2430 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2431 break;
2432 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2433 break;
2434 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2435 break;
2436 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2437 break;
2438 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2439 break;
2440 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2441 break;
2442 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2443 break;
2444 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2445 break;
2446 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2447 break;
2448 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2449 break;
2450 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2451 break;
2452 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2453 break;
2454 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2455 break;
2456 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2457 break;
2458 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2459 break;
2460 }
2461
2462 return ppc64_elf_howto_table[r];
2463 };
2464
2465 static reloc_howto_type *
2466 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2467 const char *r_name)
2468 {
2469 unsigned int i;
2470
2471 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2472 if (ppc64_elf_howto_raw[i].name != NULL
2473 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2474 return &ppc64_elf_howto_raw[i];
2475
2476 return NULL;
2477 }
2478
2479 /* Set the howto pointer for a PowerPC ELF reloc. */
2480
2481 static void
2482 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2483 Elf_Internal_Rela *dst)
2484 {
2485 unsigned int type;
2486
2487 /* Initialize howto table if needed. */
2488 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2489 ppc_howto_init ();
2490
2491 type = ELF64_R_TYPE (dst->r_info);
2492 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2493 {
2494 /* xgettext:c-format */
2495 _bfd_error_handler (_("%B: invalid relocation type %d"),
2496 abfd, (int) type);
2497 type = R_PPC64_NONE;
2498 }
2499 cache_ptr->howto = ppc64_elf_howto_table[type];
2500 }
2501
2502 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2503
2504 static bfd_reloc_status_type
2505 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2506 void *data, asection *input_section,
2507 bfd *output_bfd, char **error_message)
2508 {
2509 enum elf_ppc64_reloc_type r_type;
2510 long insn;
2511 bfd_size_type octets;
2512 bfd_vma value;
2513
2514 /* If this is a relocatable link (output_bfd test tells us), just
2515 call the generic function. Any adjustment will be done at final
2516 link time. */
2517 if (output_bfd != NULL)
2518 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2519 input_section, output_bfd, error_message);
2520
2521 /* Adjust the addend for sign extension of the low 16 bits.
2522 We won't actually be using the low 16 bits, so trashing them
2523 doesn't matter. */
2524 reloc_entry->addend += 0x8000;
2525 r_type = reloc_entry->howto->type;
2526 if (r_type != R_PPC64_REL16DX_HA)
2527 return bfd_reloc_continue;
2528
2529 value = 0;
2530 if (!bfd_is_com_section (symbol->section))
2531 value = symbol->value;
2532 value += (reloc_entry->addend
2533 + symbol->section->output_offset
2534 + symbol->section->output_section->vma);
2535 value -= (reloc_entry->address
2536 + input_section->output_offset
2537 + input_section->output_section->vma);
2538 value = (bfd_signed_vma) value >> 16;
2539
2540 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2541 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2542 insn &= ~0x1fffc1;
2543 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2544 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2545 if (value + 0x8000 > 0xffff)
2546 return bfd_reloc_overflow;
2547 return bfd_reloc_ok;
2548 }
2549
2550 static bfd_reloc_status_type
2551 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2552 void *data, asection *input_section,
2553 bfd *output_bfd, char **error_message)
2554 {
2555 if (output_bfd != NULL)
2556 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2557 input_section, output_bfd, error_message);
2558
2559 if (strcmp (symbol->section->name, ".opd") == 0
2560 && (symbol->section->owner->flags & DYNAMIC) == 0)
2561 {
2562 bfd_vma dest = opd_entry_value (symbol->section,
2563 symbol->value + reloc_entry->addend,
2564 NULL, NULL, FALSE);
2565 if (dest != (bfd_vma) -1)
2566 reloc_entry->addend = dest - (symbol->value
2567 + symbol->section->output_section->vma
2568 + symbol->section->output_offset);
2569 }
2570 else
2571 {
2572 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2573
2574 if (symbol->section->owner != abfd
2575 && symbol->section->owner != NULL
2576 && abiversion (symbol->section->owner) >= 2)
2577 {
2578 unsigned int i;
2579
2580 for (i = 0; i < symbol->section->owner->symcount; ++i)
2581 {
2582 asymbol *symdef = symbol->section->owner->outsymbols[i];
2583
2584 if (strcmp (symdef->name, symbol->name) == 0)
2585 {
2586 elfsym = (elf_symbol_type *) symdef;
2587 break;
2588 }
2589 }
2590 }
2591 reloc_entry->addend
2592 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2593 }
2594 return bfd_reloc_continue;
2595 }
2596
2597 static bfd_reloc_status_type
2598 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2599 void *data, asection *input_section,
2600 bfd *output_bfd, char **error_message)
2601 {
2602 long insn;
2603 enum elf_ppc64_reloc_type r_type;
2604 bfd_size_type octets;
2605 /* Assume 'at' branch hints. */
2606 bfd_boolean is_isa_v2 = TRUE;
2607
2608 /* If this is a relocatable link (output_bfd test tells us), just
2609 call the generic function. Any adjustment will be done at final
2610 link time. */
2611 if (output_bfd != NULL)
2612 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613 input_section, output_bfd, error_message);
2614
2615 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2616 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2617 insn &= ~(0x01 << 21);
2618 r_type = reloc_entry->howto->type;
2619 if (r_type == R_PPC64_ADDR14_BRTAKEN
2620 || r_type == R_PPC64_REL14_BRTAKEN)
2621 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2622
2623 if (is_isa_v2)
2624 {
2625 /* Set 'a' bit. This is 0b00010 in BO field for branch
2626 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2627 for branch on CTR insns (BO == 1a00t or 1a01t). */
2628 if ((insn & (0x14 << 21)) == (0x04 << 21))
2629 insn |= 0x02 << 21;
2630 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2631 insn |= 0x08 << 21;
2632 else
2633 goto out;
2634 }
2635 else
2636 {
2637 bfd_vma target = 0;
2638 bfd_vma from;
2639
2640 if (!bfd_is_com_section (symbol->section))
2641 target = symbol->value;
2642 target += symbol->section->output_section->vma;
2643 target += symbol->section->output_offset;
2644 target += reloc_entry->addend;
2645
2646 from = (reloc_entry->address
2647 + input_section->output_offset
2648 + input_section->output_section->vma);
2649
2650 /* Invert 'y' bit if not the default. */
2651 if ((bfd_signed_vma) (target - from) < 0)
2652 insn ^= 0x01 << 21;
2653 }
2654 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2655 out:
2656 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2657 input_section, output_bfd, error_message);
2658 }
2659
2660 static bfd_reloc_status_type
2661 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2662 void *data, asection *input_section,
2663 bfd *output_bfd, char **error_message)
2664 {
2665 /* If this is a relocatable link (output_bfd test tells us), just
2666 call the generic function. Any adjustment will be done at final
2667 link time. */
2668 if (output_bfd != NULL)
2669 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2670 input_section, output_bfd, error_message);
2671
2672 /* Subtract the symbol section base address. */
2673 reloc_entry->addend -= symbol->section->output_section->vma;
2674 return bfd_reloc_continue;
2675 }
2676
2677 static bfd_reloc_status_type
2678 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2679 void *data, asection *input_section,
2680 bfd *output_bfd, char **error_message)
2681 {
2682 /* If this is a relocatable link (output_bfd test tells us), just
2683 call the generic function. Any adjustment will be done at final
2684 link time. */
2685 if (output_bfd != NULL)
2686 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2687 input_section, output_bfd, error_message);
2688
2689 /* Subtract the symbol section base address. */
2690 reloc_entry->addend -= symbol->section->output_section->vma;
2691
2692 /* Adjust the addend for sign extension of the low 16 bits. */
2693 reloc_entry->addend += 0x8000;
2694 return bfd_reloc_continue;
2695 }
2696
2697 static bfd_reloc_status_type
2698 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699 void *data, asection *input_section,
2700 bfd *output_bfd, char **error_message)
2701 {
2702 bfd_vma TOCstart;
2703
2704 /* If this is a relocatable link (output_bfd test tells us), just
2705 call the generic function. Any adjustment will be done at final
2706 link time. */
2707 if (output_bfd != NULL)
2708 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2709 input_section, output_bfd, error_message);
2710
2711 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2712 if (TOCstart == 0)
2713 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2714
2715 /* Subtract the TOC base address. */
2716 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2717 return bfd_reloc_continue;
2718 }
2719
2720 static bfd_reloc_status_type
2721 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2722 void *data, asection *input_section,
2723 bfd *output_bfd, char **error_message)
2724 {
2725 bfd_vma TOCstart;
2726
2727 /* If this is a relocatable link (output_bfd test tells us), just
2728 call the generic function. Any adjustment will be done at final
2729 link time. */
2730 if (output_bfd != NULL)
2731 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2732 input_section, output_bfd, error_message);
2733
2734 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2735 if (TOCstart == 0)
2736 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2737
2738 /* Subtract the TOC base address. */
2739 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2740
2741 /* Adjust the addend for sign extension of the low 16 bits. */
2742 reloc_entry->addend += 0x8000;
2743 return bfd_reloc_continue;
2744 }
2745
2746 static bfd_reloc_status_type
2747 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2748 void *data, asection *input_section,
2749 bfd *output_bfd, char **error_message)
2750 {
2751 bfd_vma TOCstart;
2752 bfd_size_type octets;
2753
2754 /* If this is a relocatable link (output_bfd test tells us), just
2755 call the generic function. Any adjustment will be done at final
2756 link time. */
2757 if (output_bfd != NULL)
2758 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2759 input_section, output_bfd, error_message);
2760
2761 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2762 if (TOCstart == 0)
2763 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2764
2765 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2766 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2767 return bfd_reloc_ok;
2768 }
2769
2770 static bfd_reloc_status_type
2771 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2772 void *data, asection *input_section,
2773 bfd *output_bfd, char **error_message)
2774 {
2775 /* If this is a relocatable link (output_bfd test tells us), just
2776 call the generic function. Any adjustment will be done at final
2777 link time. */
2778 if (output_bfd != NULL)
2779 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2780 input_section, output_bfd, error_message);
2781
2782 if (error_message != NULL)
2783 {
2784 static char buf[60];
2785 sprintf (buf, "generic linker can't handle %s",
2786 reloc_entry->howto->name);
2787 *error_message = buf;
2788 }
2789 return bfd_reloc_dangerous;
2790 }
2791
2792 /* Track GOT entries needed for a given symbol. We might need more
2793 than one got entry per symbol. */
2794 struct got_entry
2795 {
2796 struct got_entry *next;
2797
2798 /* The symbol addend that we'll be placing in the GOT. */
2799 bfd_vma addend;
2800
2801 /* Unlike other ELF targets, we use separate GOT entries for the same
2802 symbol referenced from different input files. This is to support
2803 automatic multiple TOC/GOT sections, where the TOC base can vary
2804 from one input file to another. After partitioning into TOC groups
2805 we merge entries within the group.
2806
2807 Point to the BFD owning this GOT entry. */
2808 bfd *owner;
2809
2810 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2811 TLS_TPREL or TLS_DTPREL for tls entries. */
2812 unsigned char tls_type;
2813
2814 /* Non-zero if got.ent points to real entry. */
2815 unsigned char is_indirect;
2816
2817 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2818 union
2819 {
2820 bfd_signed_vma refcount;
2821 bfd_vma offset;
2822 struct got_entry *ent;
2823 } got;
2824 };
2825
2826 /* The same for PLT. */
2827 struct plt_entry
2828 {
2829 struct plt_entry *next;
2830
2831 bfd_vma addend;
2832
2833 union
2834 {
2835 bfd_signed_vma refcount;
2836 bfd_vma offset;
2837 } plt;
2838 };
2839
2840 struct ppc64_elf_obj_tdata
2841 {
2842 struct elf_obj_tdata elf;
2843
2844 /* Shortcuts to dynamic linker sections. */
2845 asection *got;
2846 asection *relgot;
2847
2848 /* Used during garbage collection. We attach global symbols defined
2849 on removed .opd entries to this section so that the sym is removed. */
2850 asection *deleted_section;
2851
2852 /* TLS local dynamic got entry handling. Support for multiple GOT
2853 sections means we potentially need one of these for each input bfd. */
2854 struct got_entry tlsld_got;
2855
2856 union {
2857 /* A copy of relocs before they are modified for --emit-relocs. */
2858 Elf_Internal_Rela *relocs;
2859
2860 /* Section contents. */
2861 bfd_byte *contents;
2862 } opd;
2863
2864 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2865 the reloc to be in the range -32768 to 32767. */
2866 unsigned int has_small_toc_reloc : 1;
2867
2868 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2869 instruction not one we handle. */
2870 unsigned int unexpected_toc_insn : 1;
2871 };
2872
2873 #define ppc64_elf_tdata(bfd) \
2874 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2875
2876 #define ppc64_tlsld_got(bfd) \
2877 (&ppc64_elf_tdata (bfd)->tlsld_got)
2878
2879 #define is_ppc64_elf(bfd) \
2880 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2881 && elf_object_id (bfd) == PPC64_ELF_DATA)
2882
2883 /* Override the generic function because we store some extras. */
2884
2885 static bfd_boolean
2886 ppc64_elf_mkobject (bfd *abfd)
2887 {
2888 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2889 PPC64_ELF_DATA);
2890 }
2891
2892 /* Fix bad default arch selected for a 64 bit input bfd when the
2893 default is 32 bit. Also select arch based on apuinfo. */
2894
2895 static bfd_boolean
2896 ppc64_elf_object_p (bfd *abfd)
2897 {
2898 if (!abfd->arch_info->the_default)
2899 return TRUE;
2900
2901 if (abfd->arch_info->bits_per_word == 32)
2902 {
2903 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2904
2905 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2906 {
2907 /* Relies on arch after 32 bit default being 64 bit default. */
2908 abfd->arch_info = abfd->arch_info->next;
2909 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2910 }
2911 }
2912 return _bfd_elf_ppc_set_arch (abfd);
2913 }
2914
2915 /* Support for core dump NOTE sections. */
2916
2917 static bfd_boolean
2918 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2919 {
2920 size_t offset, size;
2921
2922 if (note->descsz != 504)
2923 return FALSE;
2924
2925 /* pr_cursig */
2926 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2927
2928 /* pr_pid */
2929 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2930
2931 /* pr_reg */
2932 offset = 112;
2933 size = 384;
2934
2935 /* Make a ".reg/999" section. */
2936 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2937 size, note->descpos + offset);
2938 }
2939
2940 static bfd_boolean
2941 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2942 {
2943 if (note->descsz != 136)
2944 return FALSE;
2945
2946 elf_tdata (abfd)->core->pid
2947 = bfd_get_32 (abfd, note->descdata + 24);
2948 elf_tdata (abfd)->core->program
2949 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2950 elf_tdata (abfd)->core->command
2951 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2952
2953 return TRUE;
2954 }
2955
2956 static char *
2957 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2958 ...)
2959 {
2960 switch (note_type)
2961 {
2962 default:
2963 return NULL;
2964
2965 case NT_PRPSINFO:
2966 {
2967 char data[136];
2968 va_list ap;
2969
2970 va_start (ap, note_type);
2971 memset (data, 0, sizeof (data));
2972 strncpy (data + 40, va_arg (ap, const char *), 16);
2973 strncpy (data + 56, va_arg (ap, const char *), 80);
2974 va_end (ap);
2975 return elfcore_write_note (abfd, buf, bufsiz,
2976 "CORE", note_type, data, sizeof (data));
2977 }
2978
2979 case NT_PRSTATUS:
2980 {
2981 char data[504];
2982 va_list ap;
2983 long pid;
2984 int cursig;
2985 const void *greg;
2986
2987 va_start (ap, note_type);
2988 memset (data, 0, 112);
2989 pid = va_arg (ap, long);
2990 bfd_put_32 (abfd, pid, data + 32);
2991 cursig = va_arg (ap, int);
2992 bfd_put_16 (abfd, cursig, data + 12);
2993 greg = va_arg (ap, const void *);
2994 memcpy (data + 112, greg, 384);
2995 memset (data + 496, 0, 8);
2996 va_end (ap);
2997 return elfcore_write_note (abfd, buf, bufsiz,
2998 "CORE", note_type, data, sizeof (data));
2999 }
3000 }
3001 }
3002
3003 /* Add extra PPC sections. */
3004
3005 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3006 {
3007 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3008 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3009 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3011 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3012 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3013 { NULL, 0, 0, 0, 0 }
3014 };
3015
3016 enum _ppc64_sec_type {
3017 sec_normal = 0,
3018 sec_opd = 1,
3019 sec_toc = 2
3020 };
3021
3022 struct _ppc64_elf_section_data
3023 {
3024 struct bfd_elf_section_data elf;
3025
3026 union
3027 {
3028 /* An array with one entry for each opd function descriptor,
3029 and some spares since opd entries may be either 16 or 24 bytes. */
3030 #define OPD_NDX(OFF) ((OFF) >> 4)
3031 struct _opd_sec_data
3032 {
3033 /* Points to the function code section for local opd entries. */
3034 asection **func_sec;
3035
3036 /* After editing .opd, adjust references to opd local syms. */
3037 long *adjust;
3038 } opd;
3039
3040 /* An array for toc sections, indexed by offset/8. */
3041 struct _toc_sec_data
3042 {
3043 /* Specifies the relocation symbol index used at a given toc offset. */
3044 unsigned *symndx;
3045
3046 /* And the relocation addend. */
3047 bfd_vma *add;
3048 } toc;
3049 } u;
3050
3051 enum _ppc64_sec_type sec_type:2;
3052
3053 /* Flag set when small branches are detected. Used to
3054 select suitable defaults for the stub group size. */
3055 unsigned int has_14bit_branch:1;
3056 };
3057
3058 #define ppc64_elf_section_data(sec) \
3059 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3060
3061 static bfd_boolean
3062 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3063 {
3064 if (!sec->used_by_bfd)
3065 {
3066 struct _ppc64_elf_section_data *sdata;
3067 bfd_size_type amt = sizeof (*sdata);
3068
3069 sdata = bfd_zalloc (abfd, amt);
3070 if (sdata == NULL)
3071 return FALSE;
3072 sec->used_by_bfd = sdata;
3073 }
3074
3075 return _bfd_elf_new_section_hook (abfd, sec);
3076 }
3077
3078 static struct _opd_sec_data *
3079 get_opd_info (asection * sec)
3080 {
3081 if (sec != NULL
3082 && ppc64_elf_section_data (sec) != NULL
3083 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3084 return &ppc64_elf_section_data (sec)->u.opd;
3085 return NULL;
3086 }
3087 \f
3088 /* Parameters for the qsort hook. */
3089 static bfd_boolean synthetic_relocatable;
3090 static asection *synthetic_opd;
3091
3092 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3093
3094 static int
3095 compare_symbols (const void *ap, const void *bp)
3096 {
3097 const asymbol *a = * (const asymbol **) ap;
3098 const asymbol *b = * (const asymbol **) bp;
3099
3100 /* Section symbols first. */
3101 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3102 return -1;
3103 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3104 return 1;
3105
3106 /* then .opd symbols. */
3107 if (synthetic_opd != NULL)
3108 {
3109 if (strcmp (a->section->name, ".opd") == 0
3110 && strcmp (b->section->name, ".opd") != 0)
3111 return -1;
3112 if (strcmp (a->section->name, ".opd") != 0
3113 && strcmp (b->section->name, ".opd") == 0)
3114 return 1;
3115 }
3116
3117 /* then other code symbols. */
3118 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119 == (SEC_CODE | SEC_ALLOC)
3120 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3121 != (SEC_CODE | SEC_ALLOC))
3122 return -1;
3123
3124 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125 != (SEC_CODE | SEC_ALLOC)
3126 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3127 == (SEC_CODE | SEC_ALLOC))
3128 return 1;
3129
3130 if (synthetic_relocatable)
3131 {
3132 if (a->section->id < b->section->id)
3133 return -1;
3134
3135 if (a->section->id > b->section->id)
3136 return 1;
3137 }
3138
3139 if (a->value + a->section->vma < b->value + b->section->vma)
3140 return -1;
3141
3142 if (a->value + a->section->vma > b->value + b->section->vma)
3143 return 1;
3144
3145 /* For syms with the same value, prefer strong dynamic global function
3146 syms over other syms. */
3147 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3148 return -1;
3149
3150 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3151 return 1;
3152
3153 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3154 return -1;
3155
3156 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3157 return 1;
3158
3159 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3160 return -1;
3161
3162 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3163 return 1;
3164
3165 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3166 return -1;
3167
3168 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3169 return 1;
3170
3171 return 0;
3172 }
3173
3174 /* Search SYMS for a symbol of the given VALUE. */
3175
3176 static asymbol *
3177 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3178 {
3179 long mid;
3180
3181 if (id == (unsigned) -1)
3182 {
3183 while (lo < hi)
3184 {
3185 mid = (lo + hi) >> 1;
3186 if (syms[mid]->value + syms[mid]->section->vma < value)
3187 lo = mid + 1;
3188 else if (syms[mid]->value + syms[mid]->section->vma > value)
3189 hi = mid;
3190 else
3191 return syms[mid];
3192 }
3193 }
3194 else
3195 {
3196 while (lo < hi)
3197 {
3198 mid = (lo + hi) >> 1;
3199 if (syms[mid]->section->id < id)
3200 lo = mid + 1;
3201 else if (syms[mid]->section->id > id)
3202 hi = mid;
3203 else if (syms[mid]->value < value)
3204 lo = mid + 1;
3205 else if (syms[mid]->value > value)
3206 hi = mid;
3207 else
3208 return syms[mid];
3209 }
3210 }
3211 return NULL;
3212 }
3213
3214 static bfd_boolean
3215 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3216 {
3217 bfd_vma vma = *(bfd_vma *) ptr;
3218 return ((section->flags & SEC_ALLOC) != 0
3219 && section->vma <= vma
3220 && vma < section->vma + section->size);
3221 }
3222
3223 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3224 entry syms. Also generate @plt symbols for the glink branch table.
3225 Returns count of synthetic symbols in RET or -1 on error. */
3226
3227 static long
3228 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3229 long static_count, asymbol **static_syms,
3230 long dyn_count, asymbol **dyn_syms,
3231 asymbol **ret)
3232 {
3233 asymbol *s;
3234 long i;
3235 long count;
3236 char *names;
3237 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3238 asection *opd = NULL;
3239 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3240 asymbol **syms;
3241 int abi = abiversion (abfd);
3242
3243 *ret = NULL;
3244
3245 if (abi < 2)
3246 {
3247 opd = bfd_get_section_by_name (abfd, ".opd");
3248 if (opd == NULL && abi == 1)
3249 return 0;
3250 }
3251
3252 symcount = static_count;
3253 if (!relocatable)
3254 symcount += dyn_count;
3255 if (symcount == 0)
3256 return 0;
3257
3258 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3259 if (syms == NULL)
3260 return -1;
3261
3262 if (!relocatable && static_count != 0 && dyn_count != 0)
3263 {
3264 /* Use both symbol tables. */
3265 memcpy (syms, static_syms, static_count * sizeof (*syms));
3266 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3267 }
3268 else if (!relocatable && static_count == 0)
3269 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3270 else
3271 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3272
3273 synthetic_relocatable = relocatable;
3274 synthetic_opd = opd;
3275 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3276
3277 if (!relocatable && symcount > 1)
3278 {
3279 long j;
3280 /* Trim duplicate syms, since we may have merged the normal and
3281 dynamic symbols. Actually, we only care about syms that have
3282 different values, so trim any with the same value. */
3283 for (i = 1, j = 1; i < symcount; ++i)
3284 if (syms[i - 1]->value + syms[i - 1]->section->vma
3285 != syms[i]->value + syms[i]->section->vma)
3286 syms[j++] = syms[i];
3287 symcount = j;
3288 }
3289
3290 i = 0;
3291 /* Note that here and in compare_symbols we can't compare opd and
3292 sym->section directly. With separate debug info files, the
3293 symbols will be extracted from the debug file while abfd passed
3294 to this function is the real binary. */
3295 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3296 ++i;
3297 codesecsym = i;
3298
3299 for (; i < symcount; ++i)
3300 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3301 != (SEC_CODE | SEC_ALLOC))
3302 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3303 break;
3304 codesecsymend = i;
3305
3306 for (; i < symcount; ++i)
3307 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3308 break;
3309 secsymend = i;
3310
3311 if (opd != NULL)
3312 for (; i < symcount; ++i)
3313 if (strcmp (syms[i]->section->name, ".opd") != 0)
3314 break;
3315 opdsymend = i;
3316
3317 for (; i < symcount; ++i)
3318 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3319 != (SEC_CODE | SEC_ALLOC))
3320 break;
3321 symcount = i;
3322
3323 count = 0;
3324
3325 if (relocatable)
3326 {
3327 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3328 arelent *r;
3329 size_t size;
3330 long relcount;
3331
3332 if (opdsymend == secsymend)
3333 goto done;
3334
3335 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3336 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3337 if (relcount == 0)
3338 goto done;
3339
3340 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3341 {
3342 count = -1;
3343 goto done;
3344 }
3345
3346 size = 0;
3347 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3348 {
3349 asymbol *sym;
3350
3351 while (r < opd->relocation + relcount
3352 && r->address < syms[i]->value + opd->vma)
3353 ++r;
3354
3355 if (r == opd->relocation + relcount)
3356 break;
3357
3358 if (r->address != syms[i]->value + opd->vma)
3359 continue;
3360
3361 if (r->howto->type != R_PPC64_ADDR64)
3362 continue;
3363
3364 sym = *r->sym_ptr_ptr;
3365 if (!sym_exists_at (syms, opdsymend, symcount,
3366 sym->section->id, sym->value + r->addend))
3367 {
3368 ++count;
3369 size += sizeof (asymbol);
3370 size += strlen (syms[i]->name) + 2;
3371 }
3372 }
3373
3374 if (size == 0)
3375 goto done;
3376 s = *ret = bfd_malloc (size);
3377 if (s == NULL)
3378 {
3379 count = -1;
3380 goto done;
3381 }
3382
3383 names = (char *) (s + count);
3384
3385 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3386 {
3387 asymbol *sym;
3388
3389 while (r < opd->relocation + relcount
3390 && r->address < syms[i]->value + opd->vma)
3391 ++r;
3392
3393 if (r == opd->relocation + relcount)
3394 break;
3395
3396 if (r->address != syms[i]->value + opd->vma)
3397 continue;
3398
3399 if (r->howto->type != R_PPC64_ADDR64)
3400 continue;
3401
3402 sym = *r->sym_ptr_ptr;
3403 if (!sym_exists_at (syms, opdsymend, symcount,
3404 sym->section->id, sym->value + r->addend))
3405 {
3406 size_t len;
3407
3408 *s = *syms[i];
3409 s->flags |= BSF_SYNTHETIC;
3410 s->section = sym->section;
3411 s->value = sym->value + r->addend;
3412 s->name = names;
3413 *names++ = '.';
3414 len = strlen (syms[i]->name);
3415 memcpy (names, syms[i]->name, len + 1);
3416 names += len + 1;
3417 /* Have udata.p point back to the original symbol this
3418 synthetic symbol was derived from. */
3419 s->udata.p = syms[i];
3420 s++;
3421 }
3422 }
3423 }
3424 else
3425 {
3426 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3427 bfd_byte *contents = NULL;
3428 size_t size;
3429 long plt_count = 0;
3430 bfd_vma glink_vma = 0, resolv_vma = 0;
3431 asection *dynamic, *glink = NULL, *relplt = NULL;
3432 arelent *p;
3433
3434 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3435 {
3436 free_contents_and_exit_err:
3437 count = -1;
3438 free_contents_and_exit:
3439 if (contents)
3440 free (contents);
3441 goto done;
3442 }
3443
3444 size = 0;
3445 for (i = secsymend; i < opdsymend; ++i)
3446 {
3447 bfd_vma ent;
3448
3449 /* Ignore bogus symbols. */
3450 if (syms[i]->value > opd->size - 8)
3451 continue;
3452
3453 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3454 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3455 {
3456 ++count;
3457 size += sizeof (asymbol);
3458 size += strlen (syms[i]->name) + 2;
3459 }
3460 }
3461
3462 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3463 if (dyn_count != 0
3464 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3465 {
3466 bfd_byte *dynbuf, *extdyn, *extdynend;
3467 size_t extdynsize;
3468 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3469
3470 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3471 goto free_contents_and_exit_err;
3472
3473 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3474 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3475
3476 extdyn = dynbuf;
3477 extdynend = extdyn + dynamic->size;
3478 for (; extdyn < extdynend; extdyn += extdynsize)
3479 {
3480 Elf_Internal_Dyn dyn;
3481 (*swap_dyn_in) (abfd, extdyn, &dyn);
3482
3483 if (dyn.d_tag == DT_NULL)
3484 break;
3485
3486 if (dyn.d_tag == DT_PPC64_GLINK)
3487 {
3488 /* The first glink stub starts at offset 32; see
3489 comment in ppc64_elf_finish_dynamic_sections. */
3490 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3491 /* The .glink section usually does not survive the final
3492 link; search for the section (usually .text) where the
3493 glink stubs now reside. */
3494 glink = bfd_sections_find_if (abfd, section_covers_vma,
3495 &glink_vma);
3496 break;
3497 }
3498 }
3499
3500 free (dynbuf);
3501 }
3502
3503 if (glink != NULL)
3504 {
3505 /* Determine __glink trampoline by reading the relative branch
3506 from the first glink stub. */
3507 bfd_byte buf[4];
3508 unsigned int off = 0;
3509
3510 while (bfd_get_section_contents (abfd, glink, buf,
3511 glink_vma + off - glink->vma, 4))
3512 {
3513 unsigned int insn = bfd_get_32 (abfd, buf);
3514 insn ^= B_DOT;
3515 if ((insn & ~0x3fffffc) == 0)
3516 {
3517 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3518 break;
3519 }
3520 off += 4;
3521 if (off > 4)
3522 break;
3523 }
3524
3525 if (resolv_vma)
3526 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3527
3528 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3529 if (relplt != NULL)
3530 {
3531 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3532 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3533 goto free_contents_and_exit_err;
3534
3535 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3536 size += plt_count * sizeof (asymbol);
3537
3538 p = relplt->relocation;
3539 for (i = 0; i < plt_count; i++, p++)
3540 {
3541 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3542 if (p->addend != 0)
3543 size += sizeof ("+0x") - 1 + 16;
3544 }
3545 }
3546 }
3547
3548 if (size == 0)
3549 goto free_contents_and_exit;
3550 s = *ret = bfd_malloc (size);
3551 if (s == NULL)
3552 goto free_contents_and_exit_err;
3553
3554 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3555
3556 for (i = secsymend; i < opdsymend; ++i)
3557 {
3558 bfd_vma ent;
3559
3560 if (syms[i]->value > opd->size - 8)
3561 continue;
3562
3563 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3564 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3565 {
3566 long lo, hi;
3567 size_t len;
3568 asection *sec = abfd->sections;
3569
3570 *s = *syms[i];
3571 lo = codesecsym;
3572 hi = codesecsymend;
3573 while (lo < hi)
3574 {
3575 long mid = (lo + hi) >> 1;
3576 if (syms[mid]->section->vma < ent)
3577 lo = mid + 1;
3578 else if (syms[mid]->section->vma > ent)
3579 hi = mid;
3580 else
3581 {
3582 sec = syms[mid]->section;
3583 break;
3584 }
3585 }
3586
3587 if (lo >= hi && lo > codesecsym)
3588 sec = syms[lo - 1]->section;
3589
3590 for (; sec != NULL; sec = sec->next)
3591 {
3592 if (sec->vma > ent)
3593 break;
3594 /* SEC_LOAD may not be set if SEC is from a separate debug
3595 info file. */
3596 if ((sec->flags & SEC_ALLOC) == 0)
3597 break;
3598 if ((sec->flags & SEC_CODE) != 0)
3599 s->section = sec;
3600 }
3601 s->flags |= BSF_SYNTHETIC;
3602 s->value = ent - s->section->vma;
3603 s->name = names;
3604 *names++ = '.';
3605 len = strlen (syms[i]->name);
3606 memcpy (names, syms[i]->name, len + 1);
3607 names += len + 1;
3608 /* Have udata.p point back to the original symbol this
3609 synthetic symbol was derived from. */
3610 s->udata.p = syms[i];
3611 s++;
3612 }
3613 }
3614 free (contents);
3615
3616 if (glink != NULL && relplt != NULL)
3617 {
3618 if (resolv_vma)
3619 {
3620 /* Add a symbol for the main glink trampoline. */
3621 memset (s, 0, sizeof *s);
3622 s->the_bfd = abfd;
3623 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3624 s->section = glink;
3625 s->value = resolv_vma - glink->vma;
3626 s->name = names;
3627 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3628 names += sizeof ("__glink_PLTresolve");
3629 s++;
3630 count++;
3631 }
3632
3633 /* FIXME: It would be very much nicer to put sym@plt on the
3634 stub rather than on the glink branch table entry. The
3635 objdump disassembler would then use a sensible symbol
3636 name on plt calls. The difficulty in doing so is
3637 a) finding the stubs, and,
3638 b) matching stubs against plt entries, and,
3639 c) there can be multiple stubs for a given plt entry.
3640
3641 Solving (a) could be done by code scanning, but older
3642 ppc64 binaries used different stubs to current code.
3643 (b) is the tricky one since you need to known the toc
3644 pointer for at least one function that uses a pic stub to
3645 be able to calculate the plt address referenced.
3646 (c) means gdb would need to set multiple breakpoints (or
3647 find the glink branch itself) when setting breakpoints
3648 for pending shared library loads. */
3649 p = relplt->relocation;
3650 for (i = 0; i < plt_count; i++, p++)
3651 {
3652 size_t len;
3653
3654 *s = **p->sym_ptr_ptr;
3655 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3656 we are defining a symbol, ensure one of them is set. */
3657 if ((s->flags & BSF_LOCAL) == 0)
3658 s->flags |= BSF_GLOBAL;
3659 s->flags |= BSF_SYNTHETIC;
3660 s->section = glink;
3661 s->value = glink_vma - glink->vma;
3662 s->name = names;
3663 s->udata.p = NULL;
3664 len = strlen ((*p->sym_ptr_ptr)->name);
3665 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3666 names += len;
3667 if (p->addend != 0)
3668 {
3669 memcpy (names, "+0x", sizeof ("+0x") - 1);
3670 names += sizeof ("+0x") - 1;
3671 bfd_sprintf_vma (abfd, names, p->addend);
3672 names += strlen (names);
3673 }
3674 memcpy (names, "@plt", sizeof ("@plt"));
3675 names += sizeof ("@plt");
3676 s++;
3677 if (abi < 2)
3678 {
3679 glink_vma += 8;
3680 if (i >= 0x8000)
3681 glink_vma += 4;
3682 }
3683 else
3684 glink_vma += 4;
3685 }
3686 count += plt_count;
3687 }
3688 }
3689
3690 done:
3691 free (syms);
3692 return count;
3693 }
3694 \f
3695 /* The following functions are specific to the ELF linker, while
3696 functions above are used generally. Those named ppc64_elf_* are
3697 called by the main ELF linker code. They appear in this file more
3698 or less in the order in which they are called. eg.
3699 ppc64_elf_check_relocs is called early in the link process,
3700 ppc64_elf_finish_dynamic_sections is one of the last functions
3701 called.
3702
3703 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3704 functions have both a function code symbol and a function descriptor
3705 symbol. A call to foo in a relocatable object file looks like:
3706
3707 . .text
3708 . x:
3709 . bl .foo
3710 . nop
3711
3712 The function definition in another object file might be:
3713
3714 . .section .opd
3715 . foo: .quad .foo
3716 . .quad .TOC.@tocbase
3717 . .quad 0
3718 .
3719 . .text
3720 . .foo: blr
3721
3722 When the linker resolves the call during a static link, the branch
3723 unsurprisingly just goes to .foo and the .opd information is unused.
3724 If the function definition is in a shared library, things are a little
3725 different: The call goes via a plt call stub, the opd information gets
3726 copied to the plt, and the linker patches the nop.
3727
3728 . x:
3729 . bl .foo_stub
3730 . ld 2,40(1)
3731 .
3732 .
3733 . .foo_stub:
3734 . std 2,40(1) # in practice, the call stub
3735 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3736 . addi 11,11,Lfoo@toc@l # this is the general idea
3737 . ld 12,0(11)
3738 . ld 2,8(11)
3739 . mtctr 12
3740 . ld 11,16(11)
3741 . bctr
3742 .
3743 . .section .plt
3744 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3745
3746 The "reloc ()" notation is supposed to indicate that the linker emits
3747 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3748 copying.
3749
3750 What are the difficulties here? Well, firstly, the relocations
3751 examined by the linker in check_relocs are against the function code
3752 sym .foo, while the dynamic relocation in the plt is emitted against
3753 the function descriptor symbol, foo. Somewhere along the line, we need
3754 to carefully copy dynamic link information from one symbol to the other.
3755 Secondly, the generic part of the elf linker will make .foo a dynamic
3756 symbol as is normal for most other backends. We need foo dynamic
3757 instead, at least for an application final link. However, when
3758 creating a shared library containing foo, we need to have both symbols
3759 dynamic so that references to .foo are satisfied during the early
3760 stages of linking. Otherwise the linker might decide to pull in a
3761 definition from some other object, eg. a static library.
3762
3763 Update: As of August 2004, we support a new convention. Function
3764 calls may use the function descriptor symbol, ie. "bl foo". This
3765 behaves exactly as "bl .foo". */
3766
3767 /* Of those relocs that might be copied as dynamic relocs, this function
3768 selects those that must be copied when linking a shared library,
3769 even when the symbol is local. */
3770
3771 static int
3772 must_be_dyn_reloc (struct bfd_link_info *info,
3773 enum elf_ppc64_reloc_type r_type)
3774 {
3775 switch (r_type)
3776 {
3777 default:
3778 return 1;
3779
3780 case R_PPC64_REL32:
3781 case R_PPC64_REL64:
3782 case R_PPC64_REL30:
3783 return 0;
3784
3785 case R_PPC64_TPREL16:
3786 case R_PPC64_TPREL16_LO:
3787 case R_PPC64_TPREL16_HI:
3788 case R_PPC64_TPREL16_HA:
3789 case R_PPC64_TPREL16_DS:
3790 case R_PPC64_TPREL16_LO_DS:
3791 case R_PPC64_TPREL16_HIGH:
3792 case R_PPC64_TPREL16_HIGHA:
3793 case R_PPC64_TPREL16_HIGHER:
3794 case R_PPC64_TPREL16_HIGHERA:
3795 case R_PPC64_TPREL16_HIGHEST:
3796 case R_PPC64_TPREL16_HIGHESTA:
3797 case R_PPC64_TPREL64:
3798 return !bfd_link_executable (info);
3799 }
3800 }
3801
3802 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3803 copying dynamic variables from a shared lib into an app's dynbss
3804 section, and instead use a dynamic relocation to point into the
3805 shared lib. With code that gcc generates, it's vital that this be
3806 enabled; In the PowerPC64 ABI, the address of a function is actually
3807 the address of a function descriptor, which resides in the .opd
3808 section. gcc uses the descriptor directly rather than going via the
3809 GOT as some other ABI's do, which means that initialized function
3810 pointers must reference the descriptor. Thus, a function pointer
3811 initialized to the address of a function in a shared library will
3812 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3813 redefines the function descriptor symbol to point to the copy. This
3814 presents a problem as a plt entry for that function is also
3815 initialized from the function descriptor symbol and the copy reloc
3816 may not be initialized first. */
3817 #define ELIMINATE_COPY_RELOCS 1
3818
3819 /* Section name for stubs is the associated section name plus this
3820 string. */
3821 #define STUB_SUFFIX ".stub"
3822
3823 /* Linker stubs.
3824 ppc_stub_long_branch:
3825 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3826 destination, but a 24 bit branch in a stub section will reach.
3827 . b dest
3828
3829 ppc_stub_plt_branch:
3830 Similar to the above, but a 24 bit branch in the stub section won't
3831 reach its destination.
3832 . addis %r11,%r2,xxx@toc@ha
3833 . ld %r12,xxx@toc@l(%r11)
3834 . mtctr %r12
3835 . bctr
3836
3837 ppc_stub_plt_call:
3838 Used to call a function in a shared library. If it so happens that
3839 the plt entry referenced crosses a 64k boundary, then an extra
3840 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3841 . std %r2,40(%r1)
3842 . addis %r11,%r2,xxx@toc@ha
3843 . ld %r12,xxx+0@toc@l(%r11)
3844 . mtctr %r12
3845 . ld %r2,xxx+8@toc@l(%r11)
3846 . ld %r11,xxx+16@toc@l(%r11)
3847 . bctr
3848
3849 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3850 code to adjust the value and save r2 to support multiple toc sections.
3851 A ppc_stub_long_branch with an r2 offset looks like:
3852 . std %r2,40(%r1)
3853 . addis %r2,%r2,off@ha
3854 . addi %r2,%r2,off@l
3855 . b dest
3856
3857 A ppc_stub_plt_branch with an r2 offset looks like:
3858 . std %r2,40(%r1)
3859 . addis %r11,%r2,xxx@toc@ha
3860 . ld %r12,xxx@toc@l(%r11)
3861 . addis %r2,%r2,off@ha
3862 . addi %r2,%r2,off@l
3863 . mtctr %r12
3864 . bctr
3865
3866 In cases where the "addis" instruction would add zero, the "addis" is
3867 omitted and following instructions modified slightly in some cases.
3868 */
3869
3870 enum ppc_stub_type {
3871 ppc_stub_none,
3872 ppc_stub_long_branch,
3873 ppc_stub_long_branch_r2off,
3874 ppc_stub_plt_branch,
3875 ppc_stub_plt_branch_r2off,
3876 ppc_stub_plt_call,
3877 ppc_stub_plt_call_r2save,
3878 ppc_stub_global_entry,
3879 ppc_stub_save_res
3880 };
3881
3882 /* Information on stub grouping. */
3883 struct map_stub
3884 {
3885 /* The stub section. */
3886 asection *stub_sec;
3887 /* This is the section to which stubs in the group will be attached. */
3888 asection *link_sec;
3889 /* Next group. */
3890 struct map_stub *next;
3891 /* Whether to emit a copy of register save/restore functions in this
3892 group. */
3893 int needs_save_res;
3894 };
3895
3896 struct ppc_stub_hash_entry {
3897
3898 /* Base hash table entry structure. */
3899 struct bfd_hash_entry root;
3900
3901 enum ppc_stub_type stub_type;
3902
3903 /* Group information. */
3904 struct map_stub *group;
3905
3906 /* Offset within stub_sec of the beginning of this stub. */
3907 bfd_vma stub_offset;
3908
3909 /* Given the symbol's value and its section we can determine its final
3910 value when building the stubs (so the stub knows where to jump. */
3911 bfd_vma target_value;
3912 asection *target_section;
3913
3914 /* The symbol table entry, if any, that this was derived from. */
3915 struct ppc_link_hash_entry *h;
3916 struct plt_entry *plt_ent;
3917
3918 /* Symbol st_other. */
3919 unsigned char other;
3920 };
3921
3922 struct ppc_branch_hash_entry {
3923
3924 /* Base hash table entry structure. */
3925 struct bfd_hash_entry root;
3926
3927 /* Offset within branch lookup table. */
3928 unsigned int offset;
3929
3930 /* Generation marker. */
3931 unsigned int iter;
3932 };
3933
3934 /* Used to track dynamic relocations for local symbols. */
3935 struct ppc_dyn_relocs
3936 {
3937 struct ppc_dyn_relocs *next;
3938
3939 /* The input section of the reloc. */
3940 asection *sec;
3941
3942 /* Total number of relocs copied for the input section. */
3943 unsigned int count : 31;
3944
3945 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3946 unsigned int ifunc : 1;
3947 };
3948
3949 struct ppc_link_hash_entry
3950 {
3951 struct elf_link_hash_entry elf;
3952
3953 union {
3954 /* A pointer to the most recently used stub hash entry against this
3955 symbol. */
3956 struct ppc_stub_hash_entry *stub_cache;
3957
3958 /* A pointer to the next symbol starting with a '.' */
3959 struct ppc_link_hash_entry *next_dot_sym;
3960 } u;
3961
3962 /* Track dynamic relocs copied for this symbol. */
3963 struct elf_dyn_relocs *dyn_relocs;
3964
3965 /* Chain of aliases referring to a weakdef. */
3966 struct ppc_link_hash_entry *weakref;
3967
3968 /* Link between function code and descriptor symbols. */
3969 struct ppc_link_hash_entry *oh;
3970
3971 /* Flag function code and descriptor symbols. */
3972 unsigned int is_func:1;
3973 unsigned int is_func_descriptor:1;
3974 unsigned int fake:1;
3975
3976 /* Whether global opd/toc sym has been adjusted or not.
3977 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3978 should be set for all globals defined in any opd/toc section. */
3979 unsigned int adjust_done:1;
3980
3981 /* Set if we twiddled this symbol to weak at some stage. */
3982 unsigned int was_undefined:1;
3983
3984 /* Set if this is an out-of-line register save/restore function,
3985 with non-standard calling convention. */
3986 unsigned int save_res:1;
3987
3988 /* Contexts in which symbol is used in the GOT (or TOC).
3989 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3990 corresponding relocs are encountered during check_relocs.
3991 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3992 indicate the corresponding GOT entry type is not needed.
3993 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3994 a TPREL one. We use a separate flag rather than setting TPREL
3995 just for convenience in distinguishing the two cases. */
3996 #define TLS_GD 1 /* GD reloc. */
3997 #define TLS_LD 2 /* LD reloc. */
3998 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3999 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
4000 #define TLS_TLS 16 /* Any TLS reloc. */
4001 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4002 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4003 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4004 unsigned char tls_mask;
4005 };
4006
4007 /* ppc64 ELF linker hash table. */
4008
4009 struct ppc_link_hash_table
4010 {
4011 struct elf_link_hash_table elf;
4012
4013 /* The stub hash table. */
4014 struct bfd_hash_table stub_hash_table;
4015
4016 /* Another hash table for plt_branch stubs. */
4017 struct bfd_hash_table branch_hash_table;
4018
4019 /* Hash table for function prologue tocsave. */
4020 htab_t tocsave_htab;
4021
4022 /* Various options and other info passed from the linker. */
4023 struct ppc64_elf_params *params;
4024
4025 /* The size of sec_info below. */
4026 unsigned int sec_info_arr_size;
4027
4028 /* Per-section array of extra section info. Done this way rather
4029 than as part of ppc64_elf_section_data so we have the info for
4030 non-ppc64 sections. */
4031 struct
4032 {
4033 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4034 bfd_vma toc_off;
4035
4036 union
4037 {
4038 /* The section group that this section belongs to. */
4039 struct map_stub *group;
4040 /* A temp section list pointer. */
4041 asection *list;
4042 } u;
4043 } *sec_info;
4044
4045 /* Linked list of groups. */
4046 struct map_stub *group;
4047
4048 /* Temp used when calculating TOC pointers. */
4049 bfd_vma toc_curr;
4050 bfd *toc_bfd;
4051 asection *toc_first_sec;
4052
4053 /* Used when adding symbols. */
4054 struct ppc_link_hash_entry *dot_syms;
4055
4056 /* Shortcuts to get to dynamic linker sections. */
4057 asection *dynbss;
4058 asection *relbss;
4059 asection *glink;
4060 asection *sfpr;
4061 asection *brlt;
4062 asection *relbrlt;
4063 asection *glink_eh_frame;
4064
4065 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4066 struct ppc_link_hash_entry *tls_get_addr;
4067 struct ppc_link_hash_entry *tls_get_addr_fd;
4068
4069 /* The size of reliplt used by got entry relocs. */
4070 bfd_size_type got_reli_size;
4071
4072 /* Statistics. */
4073 unsigned long stub_count[ppc_stub_global_entry];
4074
4075 /* Number of stubs against global syms. */
4076 unsigned long stub_globals;
4077
4078 /* Set if we're linking code with function descriptors. */
4079 unsigned int opd_abi:1;
4080
4081 /* Support for multiple toc sections. */
4082 unsigned int do_multi_toc:1;
4083 unsigned int multi_toc_needed:1;
4084 unsigned int second_toc_pass:1;
4085 unsigned int do_toc_opt:1;
4086
4087 /* Set on error. */
4088 unsigned int stub_error:1;
4089
4090 /* Temp used by ppc64_elf_before_check_relocs. */
4091 unsigned int twiddled_syms:1;
4092
4093 /* Incremented every time we size stubs. */
4094 unsigned int stub_iteration;
4095
4096 /* Small local sym cache. */
4097 struct sym_cache sym_cache;
4098 };
4099
4100 /* Rename some of the generic section flags to better document how they
4101 are used here. */
4102
4103 /* Nonzero if this section has TLS related relocations. */
4104 #define has_tls_reloc sec_flg0
4105
4106 /* Nonzero if this section has a call to __tls_get_addr. */
4107 #define has_tls_get_addr_call sec_flg1
4108
4109 /* Nonzero if this section has any toc or got relocs. */
4110 #define has_toc_reloc sec_flg2
4111
4112 /* Nonzero if this section has a call to another section that uses
4113 the toc or got. */
4114 #define makes_toc_func_call sec_flg3
4115
4116 /* Recursion protection when determining above flag. */
4117 #define call_check_in_progress sec_flg4
4118 #define call_check_done sec_flg5
4119
4120 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4121
4122 #define ppc_hash_table(p) \
4123 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4124 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4125
4126 #define ppc_stub_hash_lookup(table, string, create, copy) \
4127 ((struct ppc_stub_hash_entry *) \
4128 bfd_hash_lookup ((table), (string), (create), (copy)))
4129
4130 #define ppc_branch_hash_lookup(table, string, create, copy) \
4131 ((struct ppc_branch_hash_entry *) \
4132 bfd_hash_lookup ((table), (string), (create), (copy)))
4133
4134 /* Create an entry in the stub hash table. */
4135
4136 static struct bfd_hash_entry *
4137 stub_hash_newfunc (struct bfd_hash_entry *entry,
4138 struct bfd_hash_table *table,
4139 const char *string)
4140 {
4141 /* Allocate the structure if it has not already been allocated by a
4142 subclass. */
4143 if (entry == NULL)
4144 {
4145 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4146 if (entry == NULL)
4147 return entry;
4148 }
4149
4150 /* Call the allocation method of the superclass. */
4151 entry = bfd_hash_newfunc (entry, table, string);
4152 if (entry != NULL)
4153 {
4154 struct ppc_stub_hash_entry *eh;
4155
4156 /* Initialize the local fields. */
4157 eh = (struct ppc_stub_hash_entry *) entry;
4158 eh->stub_type = ppc_stub_none;
4159 eh->group = NULL;
4160 eh->stub_offset = 0;
4161 eh->target_value = 0;
4162 eh->target_section = NULL;
4163 eh->h = NULL;
4164 eh->plt_ent = NULL;
4165 eh->other = 0;
4166 }
4167
4168 return entry;
4169 }
4170
4171 /* Create an entry in the branch hash table. */
4172
4173 static struct bfd_hash_entry *
4174 branch_hash_newfunc (struct bfd_hash_entry *entry,
4175 struct bfd_hash_table *table,
4176 const char *string)
4177 {
4178 /* Allocate the structure if it has not already been allocated by a
4179 subclass. */
4180 if (entry == NULL)
4181 {
4182 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4183 if (entry == NULL)
4184 return entry;
4185 }
4186
4187 /* Call the allocation method of the superclass. */
4188 entry = bfd_hash_newfunc (entry, table, string);
4189 if (entry != NULL)
4190 {
4191 struct ppc_branch_hash_entry *eh;
4192
4193 /* Initialize the local fields. */
4194 eh = (struct ppc_branch_hash_entry *) entry;
4195 eh->offset = 0;
4196 eh->iter = 0;
4197 }
4198
4199 return entry;
4200 }
4201
4202 /* Create an entry in a ppc64 ELF linker hash table. */
4203
4204 static struct bfd_hash_entry *
4205 link_hash_newfunc (struct bfd_hash_entry *entry,
4206 struct bfd_hash_table *table,
4207 const char *string)
4208 {
4209 /* Allocate the structure if it has not already been allocated by a
4210 subclass. */
4211 if (entry == NULL)
4212 {
4213 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4214 if (entry == NULL)
4215 return entry;
4216 }
4217
4218 /* Call the allocation method of the superclass. */
4219 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4220 if (entry != NULL)
4221 {
4222 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4223
4224 memset (&eh->u.stub_cache, 0,
4225 (sizeof (struct ppc_link_hash_entry)
4226 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4227
4228 /* When making function calls, old ABI code references function entry
4229 points (dot symbols), while new ABI code references the function
4230 descriptor symbol. We need to make any combination of reference and
4231 definition work together, without breaking archive linking.
4232
4233 For a defined function "foo" and an undefined call to "bar":
4234 An old object defines "foo" and ".foo", references ".bar" (possibly
4235 "bar" too).
4236 A new object defines "foo" and references "bar".
4237
4238 A new object thus has no problem with its undefined symbols being
4239 satisfied by definitions in an old object. On the other hand, the
4240 old object won't have ".bar" satisfied by a new object.
4241
4242 Keep a list of newly added dot-symbols. */
4243
4244 if (string[0] == '.')
4245 {
4246 struct ppc_link_hash_table *htab;
4247
4248 htab = (struct ppc_link_hash_table *) table;
4249 eh->u.next_dot_sym = htab->dot_syms;
4250 htab->dot_syms = eh;
4251 }
4252 }
4253
4254 return entry;
4255 }
4256
4257 struct tocsave_entry {
4258 asection *sec;
4259 bfd_vma offset;
4260 };
4261
4262 static hashval_t
4263 tocsave_htab_hash (const void *p)
4264 {
4265 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4266 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4267 }
4268
4269 static int
4270 tocsave_htab_eq (const void *p1, const void *p2)
4271 {
4272 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4273 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4274 return e1->sec == e2->sec && e1->offset == e2->offset;
4275 }
4276
4277 /* Destroy a ppc64 ELF linker hash table. */
4278
4279 static void
4280 ppc64_elf_link_hash_table_free (bfd *obfd)
4281 {
4282 struct ppc_link_hash_table *htab;
4283
4284 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4285 if (htab->tocsave_htab)
4286 htab_delete (htab->tocsave_htab);
4287 bfd_hash_table_free (&htab->branch_hash_table);
4288 bfd_hash_table_free (&htab->stub_hash_table);
4289 _bfd_elf_link_hash_table_free (obfd);
4290 }
4291
4292 /* Create a ppc64 ELF linker hash table. */
4293
4294 static struct bfd_link_hash_table *
4295 ppc64_elf_link_hash_table_create (bfd *abfd)
4296 {
4297 struct ppc_link_hash_table *htab;
4298 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4299
4300 htab = bfd_zmalloc (amt);
4301 if (htab == NULL)
4302 return NULL;
4303
4304 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4305 sizeof (struct ppc_link_hash_entry),
4306 PPC64_ELF_DATA))
4307 {
4308 free (htab);
4309 return NULL;
4310 }
4311
4312 /* Init the stub hash table too. */
4313 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4314 sizeof (struct ppc_stub_hash_entry)))
4315 {
4316 _bfd_elf_link_hash_table_free (abfd);
4317 return NULL;
4318 }
4319
4320 /* And the branch hash table. */
4321 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4322 sizeof (struct ppc_branch_hash_entry)))
4323 {
4324 bfd_hash_table_free (&htab->stub_hash_table);
4325 _bfd_elf_link_hash_table_free (abfd);
4326 return NULL;
4327 }
4328
4329 htab->tocsave_htab = htab_try_create (1024,
4330 tocsave_htab_hash,
4331 tocsave_htab_eq,
4332 NULL);
4333 if (htab->tocsave_htab == NULL)
4334 {
4335 ppc64_elf_link_hash_table_free (abfd);
4336 return NULL;
4337 }
4338 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4339
4340 /* Initializing two fields of the union is just cosmetic. We really
4341 only care about glist, but when compiled on a 32-bit host the
4342 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4343 debugger inspection of these fields look nicer. */
4344 htab->elf.init_got_refcount.refcount = 0;
4345 htab->elf.init_got_refcount.glist = NULL;
4346 htab->elf.init_plt_refcount.refcount = 0;
4347 htab->elf.init_plt_refcount.glist = NULL;
4348 htab->elf.init_got_offset.offset = 0;
4349 htab->elf.init_got_offset.glist = NULL;
4350 htab->elf.init_plt_offset.offset = 0;
4351 htab->elf.init_plt_offset.glist = NULL;
4352
4353 return &htab->elf.root;
4354 }
4355
4356 /* Create sections for linker generated code. */
4357
4358 static bfd_boolean
4359 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4360 {
4361 struct ppc_link_hash_table *htab;
4362 flagword flags;
4363
4364 htab = ppc_hash_table (info);
4365
4366 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4367 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4368 if (htab->params->save_restore_funcs)
4369 {
4370 /* Create .sfpr for code to save and restore fp regs. */
4371 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4372 flags);
4373 if (htab->sfpr == NULL
4374 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4375 return FALSE;
4376 }
4377
4378 if (bfd_link_relocatable (info))
4379 return TRUE;
4380
4381 /* Create .glink for lazy dynamic linking support. */
4382 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4383 flags);
4384 if (htab->glink == NULL
4385 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4386 return FALSE;
4387
4388 if (!info->no_ld_generated_unwind_info)
4389 {
4390 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4391 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4392 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4393 ".eh_frame",
4394 flags);
4395 if (htab->glink_eh_frame == NULL
4396 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4397 return FALSE;
4398 }
4399
4400 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4401 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4402 if (htab->elf.iplt == NULL
4403 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4404 return FALSE;
4405
4406 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4407 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4408 htab->elf.irelplt
4409 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4410 if (htab->elf.irelplt == NULL
4411 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4412 return FALSE;
4413
4414 /* Create branch lookup table for plt_branch stubs. */
4415 flags = (SEC_ALLOC | SEC_LOAD
4416 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4417 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4418 flags);
4419 if (htab->brlt == NULL
4420 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4421 return FALSE;
4422
4423 if (!bfd_link_pic (info))
4424 return TRUE;
4425
4426 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4427 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4428 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4429 ".rela.branch_lt",
4430 flags);
4431 if (htab->relbrlt == NULL
4432 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4433 return FALSE;
4434
4435 return TRUE;
4436 }
4437
4438 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4439
4440 bfd_boolean
4441 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4442 struct ppc64_elf_params *params)
4443 {
4444 struct ppc_link_hash_table *htab;
4445
4446 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4447
4448 /* Always hook our dynamic sections into the first bfd, which is the
4449 linker created stub bfd. This ensures that the GOT header is at
4450 the start of the output TOC section. */
4451 htab = ppc_hash_table (info);
4452 htab->elf.dynobj = params->stub_bfd;
4453 htab->params = params;
4454
4455 return create_linkage_sections (htab->elf.dynobj, info);
4456 }
4457
4458 /* Build a name for an entry in the stub hash table. */
4459
4460 static char *
4461 ppc_stub_name (const asection *input_section,
4462 const asection *sym_sec,
4463 const struct ppc_link_hash_entry *h,
4464 const Elf_Internal_Rela *rel)
4465 {
4466 char *stub_name;
4467 ssize_t len;
4468
4469 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4470 offsets from a sym as a branch target? In fact, we could
4471 probably assume the addend is always zero. */
4472 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4473
4474 if (h)
4475 {
4476 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4477 stub_name = bfd_malloc (len);
4478 if (stub_name == NULL)
4479 return stub_name;
4480
4481 len = sprintf (stub_name, "%08x.%s+%x",
4482 input_section->id & 0xffffffff,
4483 h->elf.root.root.string,
4484 (int) rel->r_addend & 0xffffffff);
4485 }
4486 else
4487 {
4488 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4489 stub_name = bfd_malloc (len);
4490 if (stub_name == NULL)
4491 return stub_name;
4492
4493 len = sprintf (stub_name, "%08x.%x:%x+%x",
4494 input_section->id & 0xffffffff,
4495 sym_sec->id & 0xffffffff,
4496 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4497 (int) rel->r_addend & 0xffffffff);
4498 }
4499 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4500 stub_name[len - 2] = 0;
4501 return stub_name;
4502 }
4503
4504 /* Look up an entry in the stub hash. Stub entries are cached because
4505 creating the stub name takes a bit of time. */
4506
4507 static struct ppc_stub_hash_entry *
4508 ppc_get_stub_entry (const asection *input_section,
4509 const asection *sym_sec,
4510 struct ppc_link_hash_entry *h,
4511 const Elf_Internal_Rela *rel,
4512 struct ppc_link_hash_table *htab)
4513 {
4514 struct ppc_stub_hash_entry *stub_entry;
4515 struct map_stub *group;
4516
4517 /* If this input section is part of a group of sections sharing one
4518 stub section, then use the id of the first section in the group.
4519 Stub names need to include a section id, as there may well be
4520 more than one stub used to reach say, printf, and we need to
4521 distinguish between them. */
4522 group = htab->sec_info[input_section->id].u.group;
4523 if (group == NULL)
4524 return NULL;
4525
4526 if (h != NULL && h->u.stub_cache != NULL
4527 && h->u.stub_cache->h == h
4528 && h->u.stub_cache->group == group)
4529 {
4530 stub_entry = h->u.stub_cache;
4531 }
4532 else
4533 {
4534 char *stub_name;
4535
4536 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4537 if (stub_name == NULL)
4538 return NULL;
4539
4540 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4541 stub_name, FALSE, FALSE);
4542 if (h != NULL)
4543 h->u.stub_cache = stub_entry;
4544
4545 free (stub_name);
4546 }
4547
4548 return stub_entry;
4549 }
4550
4551 /* Add a new stub entry to the stub hash. Not all fields of the new
4552 stub entry are initialised. */
4553
4554 static struct ppc_stub_hash_entry *
4555 ppc_add_stub (const char *stub_name,
4556 asection *section,
4557 struct bfd_link_info *info)
4558 {
4559 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4560 struct map_stub *group;
4561 asection *link_sec;
4562 asection *stub_sec;
4563 struct ppc_stub_hash_entry *stub_entry;
4564
4565 group = htab->sec_info[section->id].u.group;
4566 link_sec = group->link_sec;
4567 stub_sec = group->stub_sec;
4568 if (stub_sec == NULL)
4569 {
4570 size_t namelen;
4571 bfd_size_type len;
4572 char *s_name;
4573
4574 namelen = strlen (link_sec->name);
4575 len = namelen + sizeof (STUB_SUFFIX);
4576 s_name = bfd_alloc (htab->params->stub_bfd, len);
4577 if (s_name == NULL)
4578 return NULL;
4579
4580 memcpy (s_name, link_sec->name, namelen);
4581 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4582 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4583 if (stub_sec == NULL)
4584 return NULL;
4585 group->stub_sec = stub_sec;
4586 }
4587
4588 /* Enter this entry into the linker stub hash table. */
4589 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4590 TRUE, FALSE);
4591 if (stub_entry == NULL)
4592 {
4593 /* xgettext:c-format */
4594 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4595 section->owner, stub_name);
4596 return NULL;
4597 }
4598
4599 stub_entry->group = group;
4600 stub_entry->stub_offset = 0;
4601 return stub_entry;
4602 }
4603
4604 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4605 not already done. */
4606
4607 static bfd_boolean
4608 create_got_section (bfd *abfd, struct bfd_link_info *info)
4609 {
4610 asection *got, *relgot;
4611 flagword flags;
4612 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4613
4614 if (!is_ppc64_elf (abfd))
4615 return FALSE;
4616 if (htab == NULL)
4617 return FALSE;
4618
4619 if (!htab->elf.sgot
4620 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4621 return FALSE;
4622
4623 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4624 | SEC_LINKER_CREATED);
4625
4626 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4627 if (!got
4628 || !bfd_set_section_alignment (abfd, got, 3))
4629 return FALSE;
4630
4631 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4632 flags | SEC_READONLY);
4633 if (!relgot
4634 || ! bfd_set_section_alignment (abfd, relgot, 3))
4635 return FALSE;
4636
4637 ppc64_elf_tdata (abfd)->got = got;
4638 ppc64_elf_tdata (abfd)->relgot = relgot;
4639 return TRUE;
4640 }
4641
4642 /* Create the dynamic sections, and set up shortcuts. */
4643
4644 static bfd_boolean
4645 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4646 {
4647 struct ppc_link_hash_table *htab;
4648
4649 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4650 return FALSE;
4651
4652 htab = ppc_hash_table (info);
4653 if (htab == NULL)
4654 return FALSE;
4655
4656 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4657 if (!bfd_link_pic (info))
4658 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4659
4660 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4661 || (!bfd_link_pic (info) && !htab->relbss))
4662 abort ();
4663
4664 return TRUE;
4665 }
4666
4667 /* Follow indirect and warning symbol links. */
4668
4669 static inline struct bfd_link_hash_entry *
4670 follow_link (struct bfd_link_hash_entry *h)
4671 {
4672 while (h->type == bfd_link_hash_indirect
4673 || h->type == bfd_link_hash_warning)
4674 h = h->u.i.link;
4675 return h;
4676 }
4677
4678 static inline struct elf_link_hash_entry *
4679 elf_follow_link (struct elf_link_hash_entry *h)
4680 {
4681 return (struct elf_link_hash_entry *) follow_link (&h->root);
4682 }
4683
4684 static inline struct ppc_link_hash_entry *
4685 ppc_follow_link (struct ppc_link_hash_entry *h)
4686 {
4687 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4688 }
4689
4690 /* Merge PLT info on FROM with that on TO. */
4691
4692 static void
4693 move_plt_plist (struct ppc_link_hash_entry *from,
4694 struct ppc_link_hash_entry *to)
4695 {
4696 if (from->elf.plt.plist != NULL)
4697 {
4698 if (to->elf.plt.plist != NULL)
4699 {
4700 struct plt_entry **entp;
4701 struct plt_entry *ent;
4702
4703 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4704 {
4705 struct plt_entry *dent;
4706
4707 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4708 if (dent->addend == ent->addend)
4709 {
4710 dent->plt.refcount += ent->plt.refcount;
4711 *entp = ent->next;
4712 break;
4713 }
4714 if (dent == NULL)
4715 entp = &ent->next;
4716 }
4717 *entp = to->elf.plt.plist;
4718 }
4719
4720 to->elf.plt.plist = from->elf.plt.plist;
4721 from->elf.plt.plist = NULL;
4722 }
4723 }
4724
4725 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4726
4727 static void
4728 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4729 struct elf_link_hash_entry *dir,
4730 struct elf_link_hash_entry *ind)
4731 {
4732 struct ppc_link_hash_entry *edir, *eind;
4733
4734 edir = (struct ppc_link_hash_entry *) dir;
4735 eind = (struct ppc_link_hash_entry *) ind;
4736
4737 edir->is_func |= eind->is_func;
4738 edir->is_func_descriptor |= eind->is_func_descriptor;
4739 edir->tls_mask |= eind->tls_mask;
4740 if (eind->oh != NULL)
4741 edir->oh = ppc_follow_link (eind->oh);
4742
4743 if (edir->elf.versioned != versioned_hidden)
4744 {
4745 /* If called to transfer flags for a weakdef during processing
4746 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4747 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4748 if (!(ELIMINATE_COPY_RELOCS
4749 && eind->elf.root.type != bfd_link_hash_indirect
4750 && edir->elf.dynamic_adjusted))
4751 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4752
4753 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4754 edir->elf.ref_regular |= eind->elf.ref_regular;
4755 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4756 edir->elf.needs_plt |= eind->elf.needs_plt;
4757 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4758 }
4759
4760 /* If we were called to copy over info for a weak sym, don't copy
4761 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4762 in order to simplify readonly_dynrelocs and save a field in the
4763 symbol hash entry, but that means dyn_relocs can't be used in any
4764 tests about a specific symbol, or affect other symbol flags which
4765 are then tested.
4766 Chain weakdefs so we can get from the weakdef back to an alias.
4767 The list is circular so that we don't need to use u.weakdef as
4768 well as this list to look at all aliases. */
4769 if (eind->elf.root.type != bfd_link_hash_indirect)
4770 {
4771 struct ppc_link_hash_entry *cur, *add, *next;
4772
4773 add = eind;
4774 do
4775 {
4776 cur = edir->weakref;
4777 if (cur != NULL)
4778 {
4779 do
4780 {
4781 /* We can be called twice for the same symbols.
4782 Don't make multiple loops. */
4783 if (cur == add)
4784 return;
4785 cur = cur->weakref;
4786 } while (cur != edir);
4787 }
4788 next = add->weakref;
4789 if (cur != add)
4790 {
4791 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4792 edir->weakref = add;
4793 }
4794 add = next;
4795 } while (add != NULL && add != eind);
4796 return;
4797 }
4798
4799 /* Copy over any dynamic relocs we may have on the indirect sym. */
4800 if (eind->dyn_relocs != NULL)
4801 {
4802 if (edir->dyn_relocs != NULL)
4803 {
4804 struct elf_dyn_relocs **pp;
4805 struct elf_dyn_relocs *p;
4806
4807 /* Add reloc counts against the indirect sym to the direct sym
4808 list. Merge any entries against the same section. */
4809 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4810 {
4811 struct elf_dyn_relocs *q;
4812
4813 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4814 if (q->sec == p->sec)
4815 {
4816 q->pc_count += p->pc_count;
4817 q->count += p->count;
4818 *pp = p->next;
4819 break;
4820 }
4821 if (q == NULL)
4822 pp = &p->next;
4823 }
4824 *pp = edir->dyn_relocs;
4825 }
4826
4827 edir->dyn_relocs = eind->dyn_relocs;
4828 eind->dyn_relocs = NULL;
4829 }
4830
4831 /* Copy over got entries that we may have already seen to the
4832 symbol which just became indirect. */
4833 if (eind->elf.got.glist != NULL)
4834 {
4835 if (edir->elf.got.glist != NULL)
4836 {
4837 struct got_entry **entp;
4838 struct got_entry *ent;
4839
4840 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4841 {
4842 struct got_entry *dent;
4843
4844 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4845 if (dent->addend == ent->addend
4846 && dent->owner == ent->owner
4847 && dent->tls_type == ent->tls_type)
4848 {
4849 dent->got.refcount += ent->got.refcount;
4850 *entp = ent->next;
4851 break;
4852 }
4853 if (dent == NULL)
4854 entp = &ent->next;
4855 }
4856 *entp = edir->elf.got.glist;
4857 }
4858
4859 edir->elf.got.glist = eind->elf.got.glist;
4860 eind->elf.got.glist = NULL;
4861 }
4862
4863 /* And plt entries. */
4864 move_plt_plist (eind, edir);
4865
4866 if (eind->elf.dynindx != -1)
4867 {
4868 if (edir->elf.dynindx != -1)
4869 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4870 edir->elf.dynstr_index);
4871 edir->elf.dynindx = eind->elf.dynindx;
4872 edir->elf.dynstr_index = eind->elf.dynstr_index;
4873 eind->elf.dynindx = -1;
4874 eind->elf.dynstr_index = 0;
4875 }
4876 }
4877
4878 /* Find the function descriptor hash entry from the given function code
4879 hash entry FH. Link the entries via their OH fields. */
4880
4881 static struct ppc_link_hash_entry *
4882 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4883 {
4884 struct ppc_link_hash_entry *fdh = fh->oh;
4885
4886 if (fdh == NULL)
4887 {
4888 const char *fd_name = fh->elf.root.root.string + 1;
4889
4890 fdh = (struct ppc_link_hash_entry *)
4891 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4892 if (fdh == NULL)
4893 return fdh;
4894
4895 fdh->is_func_descriptor = 1;
4896 fdh->oh = fh;
4897 fh->is_func = 1;
4898 fh->oh = fdh;
4899 }
4900
4901 return ppc_follow_link (fdh);
4902 }
4903
4904 /* Make a fake function descriptor sym for the code sym FH. */
4905
4906 static struct ppc_link_hash_entry *
4907 make_fdh (struct bfd_link_info *info,
4908 struct ppc_link_hash_entry *fh)
4909 {
4910 bfd *abfd;
4911 asymbol *newsym;
4912 struct bfd_link_hash_entry *bh;
4913 struct ppc_link_hash_entry *fdh;
4914
4915 abfd = fh->elf.root.u.undef.abfd;
4916 newsym = bfd_make_empty_symbol (abfd);
4917 newsym->name = fh->elf.root.root.string + 1;
4918 newsym->section = bfd_und_section_ptr;
4919 newsym->value = 0;
4920 newsym->flags = BSF_WEAK;
4921
4922 bh = NULL;
4923 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4924 newsym->flags, newsym->section,
4925 newsym->value, NULL, FALSE, FALSE,
4926 &bh))
4927 return NULL;
4928
4929 fdh = (struct ppc_link_hash_entry *) bh;
4930 fdh->elf.non_elf = 0;
4931 fdh->fake = 1;
4932 fdh->is_func_descriptor = 1;
4933 fdh->oh = fh;
4934 fh->is_func = 1;
4935 fh->oh = fdh;
4936 return fdh;
4937 }
4938
4939 /* Fix function descriptor symbols defined in .opd sections to be
4940 function type. */
4941
4942 static bfd_boolean
4943 ppc64_elf_add_symbol_hook (bfd *ibfd,
4944 struct bfd_link_info *info,
4945 Elf_Internal_Sym *isym,
4946 const char **name,
4947 flagword *flags ATTRIBUTE_UNUSED,
4948 asection **sec,
4949 bfd_vma *value)
4950 {
4951 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4952 && (ibfd->flags & DYNAMIC) == 0
4953 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4954 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4955
4956 if (*sec != NULL
4957 && strcmp ((*sec)->name, ".opd") == 0)
4958 {
4959 asection *code_sec;
4960
4961 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4962 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4963 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4964
4965 /* If the symbol is a function defined in .opd, and the function
4966 code is in a discarded group, let it appear to be undefined. */
4967 if (!bfd_link_relocatable (info)
4968 && (*sec)->reloc_count != 0
4969 && opd_entry_value (*sec, *value, &code_sec, NULL,
4970 FALSE) != (bfd_vma) -1
4971 && discarded_section (code_sec))
4972 {
4973 *sec = bfd_und_section_ptr;
4974 isym->st_shndx = SHN_UNDEF;
4975 }
4976 }
4977 else if (*sec != NULL
4978 && strcmp ((*sec)->name, ".toc") == 0
4979 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4980 {
4981 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4982 if (htab != NULL)
4983 htab->params->object_in_toc = 1;
4984 }
4985
4986 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4987 {
4988 if (abiversion (ibfd) == 0)
4989 set_abiversion (ibfd, 2);
4990 else if (abiversion (ibfd) == 1)
4991 {
4992 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4993 " for ABI version 1\n"), name);
4994 bfd_set_error (bfd_error_bad_value);
4995 return FALSE;
4996 }
4997 }
4998
4999 return TRUE;
5000 }
5001
5002 /* Merge non-visibility st_other attributes: local entry point. */
5003
5004 static void
5005 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5006 const Elf_Internal_Sym *isym,
5007 bfd_boolean definition,
5008 bfd_boolean dynamic)
5009 {
5010 if (definition && !dynamic)
5011 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5012 | ELF_ST_VISIBILITY (h->other));
5013 }
5014
5015 /* This function makes an old ABI object reference to ".bar" cause the
5016 inclusion of a new ABI object archive that defines "bar".
5017 NAME is a symbol defined in an archive. Return a symbol in the hash
5018 table that might be satisfied by the archive symbols. */
5019
5020 static struct elf_link_hash_entry *
5021 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5022 struct bfd_link_info *info,
5023 const char *name)
5024 {
5025 struct elf_link_hash_entry *h;
5026 char *dot_name;
5027 size_t len;
5028
5029 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5030 if (h != NULL
5031 /* Don't return this sym if it is a fake function descriptor
5032 created by add_symbol_adjust. */
5033 && !(h->root.type == bfd_link_hash_undefweak
5034 && ((struct ppc_link_hash_entry *) h)->fake))
5035 return h;
5036
5037 if (name[0] == '.')
5038 return h;
5039
5040 len = strlen (name);
5041 dot_name = bfd_alloc (abfd, len + 2);
5042 if (dot_name == NULL)
5043 return (struct elf_link_hash_entry *) 0 - 1;
5044 dot_name[0] = '.';
5045 memcpy (dot_name + 1, name, len + 1);
5046 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5047 bfd_release (abfd, dot_name);
5048 return h;
5049 }
5050
5051 /* This function satisfies all old ABI object references to ".bar" if a
5052 new ABI object defines "bar". Well, at least, undefined dot symbols
5053 are made weak. This stops later archive searches from including an
5054 object if we already have a function descriptor definition. It also
5055 prevents the linker complaining about undefined symbols.
5056 We also check and correct mismatched symbol visibility here. The
5057 most restrictive visibility of the function descriptor and the
5058 function entry symbol is used. */
5059
5060 static bfd_boolean
5061 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5062 {
5063 struct ppc_link_hash_table *htab;
5064 struct ppc_link_hash_entry *fdh;
5065
5066 if (eh->elf.root.type == bfd_link_hash_warning)
5067 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5068
5069 if (eh->elf.root.type == bfd_link_hash_indirect)
5070 return TRUE;
5071
5072 if (eh->elf.root.root.string[0] != '.')
5073 abort ();
5074
5075 htab = ppc_hash_table (info);
5076 if (htab == NULL)
5077 return FALSE;
5078
5079 fdh = lookup_fdh (eh, htab);
5080 if (fdh == NULL)
5081 {
5082 if (!bfd_link_relocatable (info)
5083 && (eh->elf.root.type == bfd_link_hash_undefined
5084 || eh->elf.root.type == bfd_link_hash_undefweak)
5085 && eh->elf.ref_regular)
5086 {
5087 /* Make an undefweak function descriptor sym, which is enough to
5088 pull in an --as-needed shared lib, but won't cause link
5089 errors. Archives are handled elsewhere. */
5090 fdh = make_fdh (info, eh);
5091 if (fdh == NULL)
5092 return FALSE;
5093 fdh->elf.ref_regular = 1;
5094 }
5095 }
5096 else
5097 {
5098 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5099 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5100 if (entry_vis < descr_vis)
5101 fdh->elf.other += entry_vis - descr_vis;
5102 else if (entry_vis > descr_vis)
5103 eh->elf.other += descr_vis - entry_vis;
5104
5105 if ((fdh->elf.root.type == bfd_link_hash_defined
5106 || fdh->elf.root.type == bfd_link_hash_defweak)
5107 && eh->elf.root.type == bfd_link_hash_undefined)
5108 {
5109 eh->elf.root.type = bfd_link_hash_undefweak;
5110 eh->was_undefined = 1;
5111 htab->twiddled_syms = 1;
5112 }
5113 }
5114
5115 return TRUE;
5116 }
5117
5118 /* Set up opd section info and abiversion for IBFD, and process list
5119 of dot-symbols we made in link_hash_newfunc. */
5120
5121 static bfd_boolean
5122 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5123 {
5124 struct ppc_link_hash_table *htab;
5125 struct ppc_link_hash_entry **p, *eh;
5126 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5127
5128 if (opd != NULL && opd->size != 0)
5129 {
5130 if (abiversion (ibfd) == 0)
5131 set_abiversion (ibfd, 1);
5132 else if (abiversion (ibfd) >= 2)
5133 {
5134 /* xgettext:c-format */
5135 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5136 " version %d\n"),
5137 ibfd, abiversion (ibfd));
5138 bfd_set_error (bfd_error_bad_value);
5139 return FALSE;
5140 }
5141
5142 if ((ibfd->flags & DYNAMIC) == 0
5143 && (opd->flags & SEC_RELOC) != 0
5144 && opd->reloc_count != 0
5145 && !bfd_is_abs_section (opd->output_section))
5146 {
5147 /* Garbage collection needs some extra help with .opd sections.
5148 We don't want to necessarily keep everything referenced by
5149 relocs in .opd, as that would keep all functions. Instead,
5150 if we reference an .opd symbol (a function descriptor), we
5151 want to keep the function code symbol's section. This is
5152 easy for global symbols, but for local syms we need to keep
5153 information about the associated function section. */
5154 bfd_size_type amt;
5155 asection **opd_sym_map;
5156
5157 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5158 opd_sym_map = bfd_zalloc (ibfd, amt);
5159 if (opd_sym_map == NULL)
5160 return FALSE;
5161 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5162 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5163 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5164 }
5165 }
5166
5167 if (!is_ppc64_elf (info->output_bfd))
5168 return TRUE;
5169 htab = ppc_hash_table (info);
5170 if (htab == NULL)
5171 return FALSE;
5172
5173 /* For input files without an explicit abiversion in e_flags
5174 we should have flagged any with symbol st_other bits set
5175 as ELFv1 and above flagged those with .opd as ELFv2.
5176 Set the output abiversion if not yet set, and for any input
5177 still ambiguous, take its abiversion from the output.
5178 Differences in ABI are reported later. */
5179 if (abiversion (info->output_bfd) == 0)
5180 set_abiversion (info->output_bfd, abiversion (ibfd));
5181 else if (abiversion (ibfd) == 0)
5182 set_abiversion (ibfd, abiversion (info->output_bfd));
5183
5184 p = &htab->dot_syms;
5185 while ((eh = *p) != NULL)
5186 {
5187 *p = NULL;
5188 if (&eh->elf == htab->elf.hgot)
5189 ;
5190 else if (htab->elf.hgot == NULL
5191 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5192 htab->elf.hgot = &eh->elf;
5193 else if (!add_symbol_adjust (eh, info))
5194 return FALSE;
5195 p = &eh->u.next_dot_sym;
5196 }
5197
5198 /* We need to fix the undefs list for any syms we have twiddled to
5199 undefweak. */
5200 if (htab->twiddled_syms)
5201 {
5202 bfd_link_repair_undef_list (&htab->elf.root);
5203 htab->twiddled_syms = 0;
5204 }
5205 return TRUE;
5206 }
5207
5208 /* Undo hash table changes when an --as-needed input file is determined
5209 not to be needed. */
5210
5211 static bfd_boolean
5212 ppc64_elf_notice_as_needed (bfd *ibfd,
5213 struct bfd_link_info *info,
5214 enum notice_asneeded_action act)
5215 {
5216 if (act == notice_not_needed)
5217 {
5218 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5219
5220 if (htab == NULL)
5221 return FALSE;
5222
5223 htab->dot_syms = NULL;
5224 }
5225 return _bfd_elf_notice_as_needed (ibfd, info, act);
5226 }
5227
5228 /* If --just-symbols against a final linked binary, then assume we need
5229 toc adjusting stubs when calling functions defined there. */
5230
5231 static void
5232 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5233 {
5234 if ((sec->flags & SEC_CODE) != 0
5235 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5236 && is_ppc64_elf (sec->owner))
5237 {
5238 if (abiversion (sec->owner) >= 2
5239 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5240 sec->has_toc_reloc = 1;
5241 }
5242 _bfd_elf_link_just_syms (sec, info);
5243 }
5244
5245 static struct plt_entry **
5246 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5247 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5248 {
5249 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5250 struct plt_entry **local_plt;
5251 unsigned char *local_got_tls_masks;
5252
5253 if (local_got_ents == NULL)
5254 {
5255 bfd_size_type size = symtab_hdr->sh_info;
5256
5257 size *= (sizeof (*local_got_ents)
5258 + sizeof (*local_plt)
5259 + sizeof (*local_got_tls_masks));
5260 local_got_ents = bfd_zalloc (abfd, size);
5261 if (local_got_ents == NULL)
5262 return NULL;
5263 elf_local_got_ents (abfd) = local_got_ents;
5264 }
5265
5266 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5267 {
5268 struct got_entry *ent;
5269
5270 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5271 if (ent->addend == r_addend
5272 && ent->owner == abfd
5273 && ent->tls_type == tls_type)
5274 break;
5275 if (ent == NULL)
5276 {
5277 bfd_size_type amt = sizeof (*ent);
5278 ent = bfd_alloc (abfd, amt);
5279 if (ent == NULL)
5280 return FALSE;
5281 ent->next = local_got_ents[r_symndx];
5282 ent->addend = r_addend;
5283 ent->owner = abfd;
5284 ent->tls_type = tls_type;
5285 ent->is_indirect = FALSE;
5286 ent->got.refcount = 0;
5287 local_got_ents[r_symndx] = ent;
5288 }
5289 ent->got.refcount += 1;
5290 }
5291
5292 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5293 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5294 local_got_tls_masks[r_symndx] |= tls_type;
5295
5296 return local_plt + r_symndx;
5297 }
5298
5299 static bfd_boolean
5300 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5301 {
5302 struct plt_entry *ent;
5303
5304 for (ent = *plist; ent != NULL; ent = ent->next)
5305 if (ent->addend == addend)
5306 break;
5307 if (ent == NULL)
5308 {
5309 bfd_size_type amt = sizeof (*ent);
5310 ent = bfd_alloc (abfd, amt);
5311 if (ent == NULL)
5312 return FALSE;
5313 ent->next = *plist;
5314 ent->addend = addend;
5315 ent->plt.refcount = 0;
5316 *plist = ent;
5317 }
5318 ent->plt.refcount += 1;
5319 return TRUE;
5320 }
5321
5322 static bfd_boolean
5323 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5324 {
5325 return (r_type == R_PPC64_REL24
5326 || r_type == R_PPC64_REL14
5327 || r_type == R_PPC64_REL14_BRTAKEN
5328 || r_type == R_PPC64_REL14_BRNTAKEN
5329 || r_type == R_PPC64_ADDR24
5330 || r_type == R_PPC64_ADDR14
5331 || r_type == R_PPC64_ADDR14_BRTAKEN
5332 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5333 }
5334
5335 /* Look through the relocs for a section during the first phase, and
5336 calculate needed space in the global offset table, procedure
5337 linkage table, and dynamic reloc sections. */
5338
5339 static bfd_boolean
5340 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5341 asection *sec, const Elf_Internal_Rela *relocs)
5342 {
5343 struct ppc_link_hash_table *htab;
5344 Elf_Internal_Shdr *symtab_hdr;
5345 struct elf_link_hash_entry **sym_hashes;
5346 const Elf_Internal_Rela *rel;
5347 const Elf_Internal_Rela *rel_end;
5348 asection *sreloc;
5349 asection **opd_sym_map;
5350 struct elf_link_hash_entry *tga, *dottga;
5351
5352 if (bfd_link_relocatable (info))
5353 return TRUE;
5354
5355 /* Don't do anything special with non-loaded, non-alloced sections.
5356 In particular, any relocs in such sections should not affect GOT
5357 and PLT reference counting (ie. we don't allow them to create GOT
5358 or PLT entries), there's no possibility or desire to optimize TLS
5359 relocs, and there's not much point in propagating relocs to shared
5360 libs that the dynamic linker won't relocate. */
5361 if ((sec->flags & SEC_ALLOC) == 0)
5362 return TRUE;
5363
5364 BFD_ASSERT (is_ppc64_elf (abfd));
5365
5366 htab = ppc_hash_table (info);
5367 if (htab == NULL)
5368 return FALSE;
5369
5370 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5371 FALSE, FALSE, TRUE);
5372 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5373 FALSE, FALSE, TRUE);
5374 symtab_hdr = &elf_symtab_hdr (abfd);
5375 sym_hashes = elf_sym_hashes (abfd);
5376 sreloc = NULL;
5377 opd_sym_map = NULL;
5378 if (ppc64_elf_section_data (sec) != NULL
5379 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5380 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5381
5382 rel_end = relocs + sec->reloc_count;
5383 for (rel = relocs; rel < rel_end; rel++)
5384 {
5385 unsigned long r_symndx;
5386 struct elf_link_hash_entry *h;
5387 enum elf_ppc64_reloc_type r_type;
5388 int tls_type;
5389 struct _ppc64_elf_section_data *ppc64_sec;
5390 struct plt_entry **ifunc, **plt_list;
5391
5392 r_symndx = ELF64_R_SYM (rel->r_info);
5393 if (r_symndx < symtab_hdr->sh_info)
5394 h = NULL;
5395 else
5396 {
5397 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5398 h = elf_follow_link (h);
5399
5400 /* PR15323, ref flags aren't set for references in the same
5401 object. */
5402 h->root.non_ir_ref = 1;
5403
5404 if (h == htab->elf.hgot)
5405 sec->has_toc_reloc = 1;
5406 }
5407
5408 tls_type = 0;
5409 ifunc = NULL;
5410 if (h != NULL)
5411 {
5412 if (h->type == STT_GNU_IFUNC)
5413 {
5414 h->needs_plt = 1;
5415 ifunc = &h->plt.plist;
5416 }
5417 }
5418 else
5419 {
5420 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5421 abfd, r_symndx);
5422 if (isym == NULL)
5423 return FALSE;
5424
5425 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5426 {
5427 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5428 rel->r_addend, PLT_IFUNC);
5429 if (ifunc == NULL)
5430 return FALSE;
5431 }
5432 }
5433
5434 r_type = ELF64_R_TYPE (rel->r_info);
5435 switch (r_type)
5436 {
5437 case R_PPC64_TLSGD:
5438 case R_PPC64_TLSLD:
5439 /* These special tls relocs tie a call to __tls_get_addr with
5440 its parameter symbol. */
5441 break;
5442
5443 case R_PPC64_GOT_TLSLD16:
5444 case R_PPC64_GOT_TLSLD16_LO:
5445 case R_PPC64_GOT_TLSLD16_HI:
5446 case R_PPC64_GOT_TLSLD16_HA:
5447 tls_type = TLS_TLS | TLS_LD;
5448 goto dogottls;
5449
5450 case R_PPC64_GOT_TLSGD16:
5451 case R_PPC64_GOT_TLSGD16_LO:
5452 case R_PPC64_GOT_TLSGD16_HI:
5453 case R_PPC64_GOT_TLSGD16_HA:
5454 tls_type = TLS_TLS | TLS_GD;
5455 goto dogottls;
5456
5457 case R_PPC64_GOT_TPREL16_DS:
5458 case R_PPC64_GOT_TPREL16_LO_DS:
5459 case R_PPC64_GOT_TPREL16_HI:
5460 case R_PPC64_GOT_TPREL16_HA:
5461 if (bfd_link_pic (info))
5462 info->flags |= DF_STATIC_TLS;
5463 tls_type = TLS_TLS | TLS_TPREL;
5464 goto dogottls;
5465
5466 case R_PPC64_GOT_DTPREL16_DS:
5467 case R_PPC64_GOT_DTPREL16_LO_DS:
5468 case R_PPC64_GOT_DTPREL16_HI:
5469 case R_PPC64_GOT_DTPREL16_HA:
5470 tls_type = TLS_TLS | TLS_DTPREL;
5471 dogottls:
5472 sec->has_tls_reloc = 1;
5473 /* Fall through */
5474
5475 case R_PPC64_GOT16:
5476 case R_PPC64_GOT16_DS:
5477 case R_PPC64_GOT16_HA:
5478 case R_PPC64_GOT16_HI:
5479 case R_PPC64_GOT16_LO:
5480 case R_PPC64_GOT16_LO_DS:
5481 /* This symbol requires a global offset table entry. */
5482 sec->has_toc_reloc = 1;
5483 if (r_type == R_PPC64_GOT_TLSLD16
5484 || r_type == R_PPC64_GOT_TLSGD16
5485 || r_type == R_PPC64_GOT_TPREL16_DS
5486 || r_type == R_PPC64_GOT_DTPREL16_DS
5487 || r_type == R_PPC64_GOT16
5488 || r_type == R_PPC64_GOT16_DS)
5489 {
5490 htab->do_multi_toc = 1;
5491 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5492 }
5493
5494 if (ppc64_elf_tdata (abfd)->got == NULL
5495 && !create_got_section (abfd, info))
5496 return FALSE;
5497
5498 if (h != NULL)
5499 {
5500 struct ppc_link_hash_entry *eh;
5501 struct got_entry *ent;
5502
5503 eh = (struct ppc_link_hash_entry *) h;
5504 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5505 if (ent->addend == rel->r_addend
5506 && ent->owner == abfd
5507 && ent->tls_type == tls_type)
5508 break;
5509 if (ent == NULL)
5510 {
5511 bfd_size_type amt = sizeof (*ent);
5512 ent = bfd_alloc (abfd, amt);
5513 if (ent == NULL)
5514 return FALSE;
5515 ent->next = eh->elf.got.glist;
5516 ent->addend = rel->r_addend;
5517 ent->owner = abfd;
5518 ent->tls_type = tls_type;
5519 ent->is_indirect = FALSE;
5520 ent->got.refcount = 0;
5521 eh->elf.got.glist = ent;
5522 }
5523 ent->got.refcount += 1;
5524 eh->tls_mask |= tls_type;
5525 }
5526 else
5527 /* This is a global offset table entry for a local symbol. */
5528 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5529 rel->r_addend, tls_type))
5530 return FALSE;
5531
5532 /* We may also need a plt entry if the symbol turns out to be
5533 an ifunc. */
5534 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5535 {
5536 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5537 return FALSE;
5538 }
5539 break;
5540
5541 case R_PPC64_PLT16_HA:
5542 case R_PPC64_PLT16_HI:
5543 case R_PPC64_PLT16_LO:
5544 case R_PPC64_PLT32:
5545 case R_PPC64_PLT64:
5546 /* This symbol requires a procedure linkage table entry. */
5547 plt_list = ifunc;
5548 if (h != NULL)
5549 {
5550 h->needs_plt = 1;
5551 if (h->root.root.string[0] == '.'
5552 && h->root.root.string[1] != '\0')
5553 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5554 plt_list = &h->plt.plist;
5555 }
5556 if (plt_list == NULL)
5557 {
5558 /* It does not make sense to have a procedure linkage
5559 table entry for a non-ifunc local symbol. */
5560 info->callbacks->einfo
5561 /* xgettext:c-format */
5562 (_("%P: %H: %s reloc against local symbol\n"),
5563 abfd, sec, rel->r_offset,
5564 ppc64_elf_howto_table[r_type]->name);
5565 bfd_set_error (bfd_error_bad_value);
5566 return FALSE;
5567 }
5568 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5569 return FALSE;
5570 break;
5571
5572 /* The following relocations don't need to propagate the
5573 relocation if linking a shared object since they are
5574 section relative. */
5575 case R_PPC64_SECTOFF:
5576 case R_PPC64_SECTOFF_LO:
5577 case R_PPC64_SECTOFF_HI:
5578 case R_PPC64_SECTOFF_HA:
5579 case R_PPC64_SECTOFF_DS:
5580 case R_PPC64_SECTOFF_LO_DS:
5581 case R_PPC64_DTPREL16:
5582 case R_PPC64_DTPREL16_LO:
5583 case R_PPC64_DTPREL16_HI:
5584 case R_PPC64_DTPREL16_HA:
5585 case R_PPC64_DTPREL16_DS:
5586 case R_PPC64_DTPREL16_LO_DS:
5587 case R_PPC64_DTPREL16_HIGH:
5588 case R_PPC64_DTPREL16_HIGHA:
5589 case R_PPC64_DTPREL16_HIGHER:
5590 case R_PPC64_DTPREL16_HIGHERA:
5591 case R_PPC64_DTPREL16_HIGHEST:
5592 case R_PPC64_DTPREL16_HIGHESTA:
5593 break;
5594
5595 /* Nor do these. */
5596 case R_PPC64_REL16:
5597 case R_PPC64_REL16_LO:
5598 case R_PPC64_REL16_HI:
5599 case R_PPC64_REL16_HA:
5600 case R_PPC64_REL16DX_HA:
5601 break;
5602
5603 /* Not supported as a dynamic relocation. */
5604 case R_PPC64_ADDR64_LOCAL:
5605 if (bfd_link_pic (info))
5606 {
5607 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5608 ppc_howto_init ();
5609 /* xgettext:c-format */
5610 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5611 "in shared libraries and PIEs.\n"),
5612 abfd, sec, rel->r_offset,
5613 ppc64_elf_howto_table[r_type]->name);
5614 bfd_set_error (bfd_error_bad_value);
5615 return FALSE;
5616 }
5617 break;
5618
5619 case R_PPC64_TOC16:
5620 case R_PPC64_TOC16_DS:
5621 htab->do_multi_toc = 1;
5622 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5623 /* Fall through. */
5624 case R_PPC64_TOC16_LO:
5625 case R_PPC64_TOC16_HI:
5626 case R_PPC64_TOC16_HA:
5627 case R_PPC64_TOC16_LO_DS:
5628 sec->has_toc_reloc = 1;
5629 break;
5630
5631 /* Marker reloc. */
5632 case R_PPC64_ENTRY:
5633 break;
5634
5635 /* This relocation describes the C++ object vtable hierarchy.
5636 Reconstruct it for later use during GC. */
5637 case R_PPC64_GNU_VTINHERIT:
5638 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5639 return FALSE;
5640 break;
5641
5642 /* This relocation describes which C++ vtable entries are actually
5643 used. Record for later use during GC. */
5644 case R_PPC64_GNU_VTENTRY:
5645 BFD_ASSERT (h != NULL);
5646 if (h != NULL
5647 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5648 return FALSE;
5649 break;
5650
5651 case R_PPC64_REL14:
5652 case R_PPC64_REL14_BRTAKEN:
5653 case R_PPC64_REL14_BRNTAKEN:
5654 {
5655 asection *dest = NULL;
5656
5657 /* Heuristic: If jumping outside our section, chances are
5658 we are going to need a stub. */
5659 if (h != NULL)
5660 {
5661 /* If the sym is weak it may be overridden later, so
5662 don't assume we know where a weak sym lives. */
5663 if (h->root.type == bfd_link_hash_defined)
5664 dest = h->root.u.def.section;
5665 }
5666 else
5667 {
5668 Elf_Internal_Sym *isym;
5669
5670 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5671 abfd, r_symndx);
5672 if (isym == NULL)
5673 return FALSE;
5674
5675 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5676 }
5677
5678 if (dest != sec)
5679 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5680 }
5681 /* Fall through. */
5682
5683 case R_PPC64_REL24:
5684 plt_list = ifunc;
5685 if (h != NULL)
5686 {
5687 h->needs_plt = 1;
5688 if (h->root.root.string[0] == '.'
5689 && h->root.root.string[1] != '\0')
5690 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5691
5692 if (h == tga || h == dottga)
5693 {
5694 sec->has_tls_reloc = 1;
5695 if (rel != relocs
5696 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5697 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5698 /* We have a new-style __tls_get_addr call with
5699 a marker reloc. */
5700 ;
5701 else
5702 /* Mark this section as having an old-style call. */
5703 sec->has_tls_get_addr_call = 1;
5704 }
5705 plt_list = &h->plt.plist;
5706 }
5707
5708 /* We may need a .plt entry if the function this reloc
5709 refers to is in a shared lib. */
5710 if (plt_list
5711 && !update_plt_info (abfd, plt_list, rel->r_addend))
5712 return FALSE;
5713 break;
5714
5715 case R_PPC64_ADDR14:
5716 case R_PPC64_ADDR14_BRNTAKEN:
5717 case R_PPC64_ADDR14_BRTAKEN:
5718 case R_PPC64_ADDR24:
5719 goto dodyn;
5720
5721 case R_PPC64_TPREL64:
5722 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5723 if (bfd_link_pic (info))
5724 info->flags |= DF_STATIC_TLS;
5725 goto dotlstoc;
5726
5727 case R_PPC64_DTPMOD64:
5728 if (rel + 1 < rel_end
5729 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5730 && rel[1].r_offset == rel->r_offset + 8)
5731 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5732 else
5733 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5734 goto dotlstoc;
5735
5736 case R_PPC64_DTPREL64:
5737 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5738 if (rel != relocs
5739 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5740 && rel[-1].r_offset == rel->r_offset - 8)
5741 /* This is the second reloc of a dtpmod, dtprel pair.
5742 Don't mark with TLS_DTPREL. */
5743 goto dodyn;
5744
5745 dotlstoc:
5746 sec->has_tls_reloc = 1;
5747 if (h != NULL)
5748 {
5749 struct ppc_link_hash_entry *eh;
5750 eh = (struct ppc_link_hash_entry *) h;
5751 eh->tls_mask |= tls_type;
5752 }
5753 else
5754 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5755 rel->r_addend, tls_type))
5756 return FALSE;
5757
5758 ppc64_sec = ppc64_elf_section_data (sec);
5759 if (ppc64_sec->sec_type != sec_toc)
5760 {
5761 bfd_size_type amt;
5762
5763 /* One extra to simplify get_tls_mask. */
5764 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5765 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5766 if (ppc64_sec->u.toc.symndx == NULL)
5767 return FALSE;
5768 amt = sec->size * sizeof (bfd_vma) / 8;
5769 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5770 if (ppc64_sec->u.toc.add == NULL)
5771 return FALSE;
5772 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5773 ppc64_sec->sec_type = sec_toc;
5774 }
5775 BFD_ASSERT (rel->r_offset % 8 == 0);
5776 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5777 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5778
5779 /* Mark the second slot of a GD or LD entry.
5780 -1 to indicate GD and -2 to indicate LD. */
5781 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5782 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5783 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5784 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5785 goto dodyn;
5786
5787 case R_PPC64_TPREL16:
5788 case R_PPC64_TPREL16_LO:
5789 case R_PPC64_TPREL16_HI:
5790 case R_PPC64_TPREL16_HA:
5791 case R_PPC64_TPREL16_DS:
5792 case R_PPC64_TPREL16_LO_DS:
5793 case R_PPC64_TPREL16_HIGH:
5794 case R_PPC64_TPREL16_HIGHA:
5795 case R_PPC64_TPREL16_HIGHER:
5796 case R_PPC64_TPREL16_HIGHERA:
5797 case R_PPC64_TPREL16_HIGHEST:
5798 case R_PPC64_TPREL16_HIGHESTA:
5799 if (bfd_link_pic (info))
5800 {
5801 info->flags |= DF_STATIC_TLS;
5802 goto dodyn;
5803 }
5804 break;
5805
5806 case R_PPC64_ADDR64:
5807 if (opd_sym_map != NULL
5808 && rel + 1 < rel_end
5809 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5810 {
5811 if (h != NULL)
5812 {
5813 if (h->root.root.string[0] == '.'
5814 && h->root.root.string[1] != 0
5815 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5816 ;
5817 else
5818 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5819 }
5820 else
5821 {
5822 asection *s;
5823 Elf_Internal_Sym *isym;
5824
5825 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5826 abfd, r_symndx);
5827 if (isym == NULL)
5828 return FALSE;
5829
5830 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5831 if (s != NULL && s != sec)
5832 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5833 }
5834 }
5835 /* Fall through. */
5836
5837 case R_PPC64_ADDR16:
5838 case R_PPC64_ADDR16_DS:
5839 case R_PPC64_ADDR16_HA:
5840 case R_PPC64_ADDR16_HI:
5841 case R_PPC64_ADDR16_HIGH:
5842 case R_PPC64_ADDR16_HIGHA:
5843 case R_PPC64_ADDR16_HIGHER:
5844 case R_PPC64_ADDR16_HIGHERA:
5845 case R_PPC64_ADDR16_HIGHEST:
5846 case R_PPC64_ADDR16_HIGHESTA:
5847 case R_PPC64_ADDR16_LO:
5848 case R_PPC64_ADDR16_LO_DS:
5849 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5850 && rel->r_addend == 0)
5851 {
5852 /* We may need a .plt entry if this reloc refers to a
5853 function in a shared lib. */
5854 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5855 return FALSE;
5856 h->pointer_equality_needed = 1;
5857 }
5858 /* Fall through. */
5859
5860 case R_PPC64_REL30:
5861 case R_PPC64_REL32:
5862 case R_PPC64_REL64:
5863 case R_PPC64_ADDR32:
5864 case R_PPC64_UADDR16:
5865 case R_PPC64_UADDR32:
5866 case R_PPC64_UADDR64:
5867 case R_PPC64_TOC:
5868 if (h != NULL && !bfd_link_pic (info))
5869 /* We may need a copy reloc. */
5870 h->non_got_ref = 1;
5871
5872 /* Don't propagate .opd relocs. */
5873 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5874 break;
5875
5876 /* If we are creating a shared library, and this is a reloc
5877 against a global symbol, or a non PC relative reloc
5878 against a local symbol, then we need to copy the reloc
5879 into the shared library. However, if we are linking with
5880 -Bsymbolic, we do not need to copy a reloc against a
5881 global symbol which is defined in an object we are
5882 including in the link (i.e., DEF_REGULAR is set). At
5883 this point we have not seen all the input files, so it is
5884 possible that DEF_REGULAR is not set now but will be set
5885 later (it is never cleared). In case of a weak definition,
5886 DEF_REGULAR may be cleared later by a strong definition in
5887 a shared library. We account for that possibility below by
5888 storing information in the dyn_relocs field of the hash
5889 table entry. A similar situation occurs when creating
5890 shared libraries and symbol visibility changes render the
5891 symbol local.
5892
5893 If on the other hand, we are creating an executable, we
5894 may need to keep relocations for symbols satisfied by a
5895 dynamic library if we manage to avoid copy relocs for the
5896 symbol. */
5897 dodyn:
5898 if ((bfd_link_pic (info)
5899 && (must_be_dyn_reloc (info, r_type)
5900 || (h != NULL
5901 && (!SYMBOLIC_BIND (info, h)
5902 || h->root.type == bfd_link_hash_defweak
5903 || !h->def_regular))))
5904 || (ELIMINATE_COPY_RELOCS
5905 && !bfd_link_pic (info)
5906 && h != NULL
5907 && (h->root.type == bfd_link_hash_defweak
5908 || !h->def_regular))
5909 || (!bfd_link_pic (info)
5910 && ifunc != NULL))
5911 {
5912 /* We must copy these reloc types into the output file.
5913 Create a reloc section in dynobj and make room for
5914 this reloc. */
5915 if (sreloc == NULL)
5916 {
5917 sreloc = _bfd_elf_make_dynamic_reloc_section
5918 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5919
5920 if (sreloc == NULL)
5921 return FALSE;
5922 }
5923
5924 /* If this is a global symbol, we count the number of
5925 relocations we need for this symbol. */
5926 if (h != NULL)
5927 {
5928 struct elf_dyn_relocs *p;
5929 struct elf_dyn_relocs **head;
5930
5931 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5932 p = *head;
5933 if (p == NULL || p->sec != sec)
5934 {
5935 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5936 if (p == NULL)
5937 return FALSE;
5938 p->next = *head;
5939 *head = p;
5940 p->sec = sec;
5941 p->count = 0;
5942 p->pc_count = 0;
5943 }
5944 p->count += 1;
5945 if (!must_be_dyn_reloc (info, r_type))
5946 p->pc_count += 1;
5947 }
5948 else
5949 {
5950 /* Track dynamic relocs needed for local syms too.
5951 We really need local syms available to do this
5952 easily. Oh well. */
5953 struct ppc_dyn_relocs *p;
5954 struct ppc_dyn_relocs **head;
5955 bfd_boolean is_ifunc;
5956 asection *s;
5957 void *vpp;
5958 Elf_Internal_Sym *isym;
5959
5960 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5961 abfd, r_symndx);
5962 if (isym == NULL)
5963 return FALSE;
5964
5965 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5966 if (s == NULL)
5967 s = sec;
5968
5969 vpp = &elf_section_data (s)->local_dynrel;
5970 head = (struct ppc_dyn_relocs **) vpp;
5971 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5972 p = *head;
5973 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5974 p = p->next;
5975 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5976 {
5977 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5978 if (p == NULL)
5979 return FALSE;
5980 p->next = *head;
5981 *head = p;
5982 p->sec = sec;
5983 p->ifunc = is_ifunc;
5984 p->count = 0;
5985 }
5986 p->count += 1;
5987 }
5988 }
5989 break;
5990
5991 default:
5992 break;
5993 }
5994 }
5995
5996 return TRUE;
5997 }
5998
5999 /* Merge backend specific data from an object file to the output
6000 object file when linking. */
6001
6002 static bfd_boolean
6003 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6004 {
6005 bfd *obfd = info->output_bfd;
6006 unsigned long iflags, oflags;
6007
6008 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6009 return TRUE;
6010
6011 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6012 return TRUE;
6013
6014 if (!_bfd_generic_verify_endian_match (ibfd, info))
6015 return FALSE;
6016
6017 iflags = elf_elfheader (ibfd)->e_flags;
6018 oflags = elf_elfheader (obfd)->e_flags;
6019
6020 if (iflags & ~EF_PPC64_ABI)
6021 {
6022 _bfd_error_handler
6023 /* xgettext:c-format */
6024 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6025 bfd_set_error (bfd_error_bad_value);
6026 return FALSE;
6027 }
6028 else if (iflags != oflags && iflags != 0)
6029 {
6030 _bfd_error_handler
6031 /* xgettext:c-format */
6032 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6033 ibfd, iflags, oflags);
6034 bfd_set_error (bfd_error_bad_value);
6035 return FALSE;
6036 }
6037
6038 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6039
6040 /* Merge Tag_compatibility attributes and any common GNU ones. */
6041 _bfd_elf_merge_object_attributes (ibfd, info);
6042
6043 return TRUE;
6044 }
6045
6046 static bfd_boolean
6047 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6048 {
6049 /* Print normal ELF private data. */
6050 _bfd_elf_print_private_bfd_data (abfd, ptr);
6051
6052 if (elf_elfheader (abfd)->e_flags != 0)
6053 {
6054 FILE *file = ptr;
6055
6056 fprintf (file, _("private flags = 0x%lx:"),
6057 elf_elfheader (abfd)->e_flags);
6058
6059 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6060 fprintf (file, _(" [abiv%ld]"),
6061 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6062 fputc ('\n', file);
6063 }
6064
6065 return TRUE;
6066 }
6067
6068 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6069 of the code entry point, and its section, which must be in the same
6070 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6071
6072 static bfd_vma
6073 opd_entry_value (asection *opd_sec,
6074 bfd_vma offset,
6075 asection **code_sec,
6076 bfd_vma *code_off,
6077 bfd_boolean in_code_sec)
6078 {
6079 bfd *opd_bfd = opd_sec->owner;
6080 Elf_Internal_Rela *relocs;
6081 Elf_Internal_Rela *lo, *hi, *look;
6082 bfd_vma val;
6083
6084 /* No relocs implies we are linking a --just-symbols object, or looking
6085 at a final linked executable with addr2line or somesuch. */
6086 if (opd_sec->reloc_count == 0)
6087 {
6088 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6089
6090 if (contents == NULL)
6091 {
6092 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6093 return (bfd_vma) -1;
6094 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6095 }
6096
6097 /* PR 17512: file: 64b9dfbb. */
6098 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6099 return (bfd_vma) -1;
6100
6101 val = bfd_get_64 (opd_bfd, contents + offset);
6102 if (code_sec != NULL)
6103 {
6104 asection *sec, *likely = NULL;
6105
6106 if (in_code_sec)
6107 {
6108 sec = *code_sec;
6109 if (sec->vma <= val
6110 && val < sec->vma + sec->size)
6111 likely = sec;
6112 else
6113 val = -1;
6114 }
6115 else
6116 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6117 if (sec->vma <= val
6118 && (sec->flags & SEC_LOAD) != 0
6119 && (sec->flags & SEC_ALLOC) != 0)
6120 likely = sec;
6121 if (likely != NULL)
6122 {
6123 *code_sec = likely;
6124 if (code_off != NULL)
6125 *code_off = val - likely->vma;
6126 }
6127 }
6128 return val;
6129 }
6130
6131 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6132
6133 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6134 if (relocs == NULL)
6135 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6136 /* PR 17512: file: df8e1fd6. */
6137 if (relocs == NULL)
6138 return (bfd_vma) -1;
6139
6140 /* Go find the opd reloc at the sym address. */
6141 lo = relocs;
6142 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6143 val = (bfd_vma) -1;
6144 while (lo < hi)
6145 {
6146 look = lo + (hi - lo) / 2;
6147 if (look->r_offset < offset)
6148 lo = look + 1;
6149 else if (look->r_offset > offset)
6150 hi = look;
6151 else
6152 {
6153 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6154
6155 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6156 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6157 {
6158 unsigned long symndx = ELF64_R_SYM (look->r_info);
6159 asection *sec = NULL;
6160
6161 if (symndx >= symtab_hdr->sh_info
6162 && elf_sym_hashes (opd_bfd) != NULL)
6163 {
6164 struct elf_link_hash_entry **sym_hashes;
6165 struct elf_link_hash_entry *rh;
6166
6167 sym_hashes = elf_sym_hashes (opd_bfd);
6168 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6169 if (rh != NULL)
6170 {
6171 rh = elf_follow_link (rh);
6172 if (rh->root.type != bfd_link_hash_defined
6173 && rh->root.type != bfd_link_hash_defweak)
6174 break;
6175 if (rh->root.u.def.section->owner == opd_bfd)
6176 {
6177 val = rh->root.u.def.value;
6178 sec = rh->root.u.def.section;
6179 }
6180 }
6181 }
6182
6183 if (sec == NULL)
6184 {
6185 Elf_Internal_Sym *sym;
6186
6187 if (symndx < symtab_hdr->sh_info)
6188 {
6189 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6190 if (sym == NULL)
6191 {
6192 size_t symcnt = symtab_hdr->sh_info;
6193 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6194 symcnt, 0,
6195 NULL, NULL, NULL);
6196 if (sym == NULL)
6197 break;
6198 symtab_hdr->contents = (bfd_byte *) sym;
6199 }
6200 sym += symndx;
6201 }
6202 else
6203 {
6204 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6205 1, symndx,
6206 NULL, NULL, NULL);
6207 if (sym == NULL)
6208 break;
6209 }
6210 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6211 if (sec == NULL)
6212 break;
6213 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6214 val = sym->st_value;
6215 }
6216
6217 val += look->r_addend;
6218 if (code_off != NULL)
6219 *code_off = val;
6220 if (code_sec != NULL)
6221 {
6222 if (in_code_sec && *code_sec != sec)
6223 return -1;
6224 else
6225 *code_sec = sec;
6226 }
6227 if (sec->output_section != NULL)
6228 val += sec->output_section->vma + sec->output_offset;
6229 }
6230 break;
6231 }
6232 }
6233
6234 return val;
6235 }
6236
6237 /* If the ELF symbol SYM might be a function in SEC, return the
6238 function size and set *CODE_OFF to the function's entry point,
6239 otherwise return zero. */
6240
6241 static bfd_size_type
6242 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6243 bfd_vma *code_off)
6244 {
6245 bfd_size_type size;
6246
6247 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6248 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6249 return 0;
6250
6251 size = 0;
6252 if (!(sym->flags & BSF_SYNTHETIC))
6253 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6254
6255 if (strcmp (sym->section->name, ".opd") == 0)
6256 {
6257 struct _opd_sec_data *opd = get_opd_info (sym->section);
6258 bfd_vma symval = sym->value;
6259
6260 if (opd != NULL
6261 && opd->adjust != NULL
6262 && elf_section_data (sym->section)->relocs != NULL)
6263 {
6264 /* opd_entry_value will use cached relocs that have been
6265 adjusted, but with raw symbols. That means both local
6266 and global symbols need adjusting. */
6267 long adjust = opd->adjust[OPD_NDX (symval)];
6268 if (adjust == -1)
6269 return 0;
6270 symval += adjust;
6271 }
6272
6273 if (opd_entry_value (sym->section, symval,
6274 &sec, code_off, TRUE) == (bfd_vma) -1)
6275 return 0;
6276 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6277 symbol. This size has nothing to do with the code size of the
6278 function, which is what we're supposed to return, but the
6279 code size isn't available without looking up the dot-sym.
6280 However, doing that would be a waste of time particularly
6281 since elf_find_function will look at the dot-sym anyway.
6282 Now, elf_find_function will keep the largest size of any
6283 function sym found at the code address of interest, so return
6284 1 here to avoid it incorrectly caching a larger function size
6285 for a small function. This does mean we return the wrong
6286 size for a new-ABI function of size 24, but all that does is
6287 disable caching for such functions. */
6288 if (size == 24)
6289 size = 1;
6290 }
6291 else
6292 {
6293 if (sym->section != sec)
6294 return 0;
6295 *code_off = sym->value;
6296 }
6297 if (size == 0)
6298 size = 1;
6299 return size;
6300 }
6301
6302 /* Return true if symbol is defined in a regular object file. */
6303
6304 static bfd_boolean
6305 is_static_defined (struct elf_link_hash_entry *h)
6306 {
6307 return ((h->root.type == bfd_link_hash_defined
6308 || h->root.type == bfd_link_hash_defweak)
6309 && h->root.u.def.section != NULL
6310 && h->root.u.def.section->output_section != NULL);
6311 }
6312
6313 /* If FDH is a function descriptor symbol, return the associated code
6314 entry symbol if it is defined. Return NULL otherwise. */
6315
6316 static struct ppc_link_hash_entry *
6317 defined_code_entry (struct ppc_link_hash_entry *fdh)
6318 {
6319 if (fdh->is_func_descriptor)
6320 {
6321 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6322 if (fh->elf.root.type == bfd_link_hash_defined
6323 || fh->elf.root.type == bfd_link_hash_defweak)
6324 return fh;
6325 }
6326 return NULL;
6327 }
6328
6329 /* If FH is a function code entry symbol, return the associated
6330 function descriptor symbol if it is defined. Return NULL otherwise. */
6331
6332 static struct ppc_link_hash_entry *
6333 defined_func_desc (struct ppc_link_hash_entry *fh)
6334 {
6335 if (fh->oh != NULL
6336 && fh->oh->is_func_descriptor)
6337 {
6338 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6339 if (fdh->elf.root.type == bfd_link_hash_defined
6340 || fdh->elf.root.type == bfd_link_hash_defweak)
6341 return fdh;
6342 }
6343 return NULL;
6344 }
6345
6346 /* Mark all our entry sym sections, both opd and code section. */
6347
6348 static void
6349 ppc64_elf_gc_keep (struct bfd_link_info *info)
6350 {
6351 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6352 struct bfd_sym_chain *sym;
6353
6354 if (htab == NULL)
6355 return;
6356
6357 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6358 {
6359 struct ppc_link_hash_entry *eh, *fh;
6360 asection *sec;
6361
6362 eh = (struct ppc_link_hash_entry *)
6363 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6364 if (eh == NULL)
6365 continue;
6366 if (eh->elf.root.type != bfd_link_hash_defined
6367 && eh->elf.root.type != bfd_link_hash_defweak)
6368 continue;
6369
6370 fh = defined_code_entry (eh);
6371 if (fh != NULL)
6372 {
6373 sec = fh->elf.root.u.def.section;
6374 sec->flags |= SEC_KEEP;
6375 }
6376 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6377 && opd_entry_value (eh->elf.root.u.def.section,
6378 eh->elf.root.u.def.value,
6379 &sec, NULL, FALSE) != (bfd_vma) -1)
6380 sec->flags |= SEC_KEEP;
6381
6382 sec = eh->elf.root.u.def.section;
6383 sec->flags |= SEC_KEEP;
6384 }
6385 }
6386
6387 /* Mark sections containing dynamically referenced symbols. When
6388 building shared libraries, we must assume that any visible symbol is
6389 referenced. */
6390
6391 static bfd_boolean
6392 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6393 {
6394 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6395 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6396 struct ppc_link_hash_entry *fdh;
6397 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6398
6399 /* Dynamic linking info is on the func descriptor sym. */
6400 fdh = defined_func_desc (eh);
6401 if (fdh != NULL)
6402 eh = fdh;
6403
6404 if ((eh->elf.root.type == bfd_link_hash_defined
6405 || eh->elf.root.type == bfd_link_hash_defweak)
6406 && (eh->elf.ref_dynamic
6407 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6408 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6409 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6410 && (!bfd_link_executable (info)
6411 || info->export_dynamic
6412 || (eh->elf.dynamic
6413 && d != NULL
6414 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6415 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6416 || !bfd_hide_sym_by_version (info->version_info,
6417 eh->elf.root.root.string)))))
6418 {
6419 asection *code_sec;
6420 struct ppc_link_hash_entry *fh;
6421
6422 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6423
6424 /* Function descriptor syms cause the associated
6425 function code sym section to be marked. */
6426 fh = defined_code_entry (eh);
6427 if (fh != NULL)
6428 {
6429 code_sec = fh->elf.root.u.def.section;
6430 code_sec->flags |= SEC_KEEP;
6431 }
6432 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6433 && opd_entry_value (eh->elf.root.u.def.section,
6434 eh->elf.root.u.def.value,
6435 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6436 code_sec->flags |= SEC_KEEP;
6437 }
6438
6439 return TRUE;
6440 }
6441
6442 /* Return the section that should be marked against GC for a given
6443 relocation. */
6444
6445 static asection *
6446 ppc64_elf_gc_mark_hook (asection *sec,
6447 struct bfd_link_info *info,
6448 Elf_Internal_Rela *rel,
6449 struct elf_link_hash_entry *h,
6450 Elf_Internal_Sym *sym)
6451 {
6452 asection *rsec;
6453
6454 /* Syms return NULL if we're marking .opd, so we avoid marking all
6455 function sections, as all functions are referenced in .opd. */
6456 rsec = NULL;
6457 if (get_opd_info (sec) != NULL)
6458 return rsec;
6459
6460 if (h != NULL)
6461 {
6462 enum elf_ppc64_reloc_type r_type;
6463 struct ppc_link_hash_entry *eh, *fh, *fdh;
6464
6465 r_type = ELF64_R_TYPE (rel->r_info);
6466 switch (r_type)
6467 {
6468 case R_PPC64_GNU_VTINHERIT:
6469 case R_PPC64_GNU_VTENTRY:
6470 break;
6471
6472 default:
6473 switch (h->root.type)
6474 {
6475 case bfd_link_hash_defined:
6476 case bfd_link_hash_defweak:
6477 eh = (struct ppc_link_hash_entry *) h;
6478 fdh = defined_func_desc (eh);
6479 if (fdh != NULL)
6480 eh = fdh;
6481
6482 /* Function descriptor syms cause the associated
6483 function code sym section to be marked. */
6484 fh = defined_code_entry (eh);
6485 if (fh != NULL)
6486 {
6487 /* They also mark their opd section. */
6488 eh->elf.root.u.def.section->gc_mark = 1;
6489
6490 rsec = fh->elf.root.u.def.section;
6491 }
6492 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6493 && opd_entry_value (eh->elf.root.u.def.section,
6494 eh->elf.root.u.def.value,
6495 &rsec, NULL, FALSE) != (bfd_vma) -1)
6496 eh->elf.root.u.def.section->gc_mark = 1;
6497 else
6498 rsec = h->root.u.def.section;
6499 break;
6500
6501 case bfd_link_hash_common:
6502 rsec = h->root.u.c.p->section;
6503 break;
6504
6505 default:
6506 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6507 }
6508 }
6509 }
6510 else
6511 {
6512 struct _opd_sec_data *opd;
6513
6514 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6515 opd = get_opd_info (rsec);
6516 if (opd != NULL && opd->func_sec != NULL)
6517 {
6518 rsec->gc_mark = 1;
6519
6520 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6521 }
6522 }
6523
6524 return rsec;
6525 }
6526
6527 /* Update the .got, .plt. and dynamic reloc reference counts for the
6528 section being removed. */
6529
6530 static bfd_boolean
6531 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6532 asection *sec, const Elf_Internal_Rela *relocs)
6533 {
6534 struct ppc_link_hash_table *htab;
6535 Elf_Internal_Shdr *symtab_hdr;
6536 struct elf_link_hash_entry **sym_hashes;
6537 struct got_entry **local_got_ents;
6538 const Elf_Internal_Rela *rel, *relend;
6539
6540 if (bfd_link_relocatable (info))
6541 return TRUE;
6542
6543 if ((sec->flags & SEC_ALLOC) == 0)
6544 return TRUE;
6545
6546 elf_section_data (sec)->local_dynrel = NULL;
6547
6548 htab = ppc_hash_table (info);
6549 if (htab == NULL)
6550 return FALSE;
6551
6552 symtab_hdr = &elf_symtab_hdr (abfd);
6553 sym_hashes = elf_sym_hashes (abfd);
6554 local_got_ents = elf_local_got_ents (abfd);
6555
6556 relend = relocs + sec->reloc_count;
6557 for (rel = relocs; rel < relend; rel++)
6558 {
6559 unsigned long r_symndx;
6560 enum elf_ppc64_reloc_type r_type;
6561 struct elf_link_hash_entry *h = NULL;
6562 struct plt_entry **plt_list;
6563 unsigned char tls_type = 0;
6564
6565 r_symndx = ELF64_R_SYM (rel->r_info);
6566 r_type = ELF64_R_TYPE (rel->r_info);
6567 if (r_symndx >= symtab_hdr->sh_info)
6568 {
6569 struct ppc_link_hash_entry *eh;
6570 struct elf_dyn_relocs **pp;
6571 struct elf_dyn_relocs *p;
6572
6573 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6574 h = elf_follow_link (h);
6575 eh = (struct ppc_link_hash_entry *) h;
6576
6577 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6578 if (p->sec == sec)
6579 {
6580 /* Everything must go for SEC. */
6581 *pp = p->next;
6582 break;
6583 }
6584 }
6585
6586 switch (r_type)
6587 {
6588 case R_PPC64_GOT_TLSLD16:
6589 case R_PPC64_GOT_TLSLD16_LO:
6590 case R_PPC64_GOT_TLSLD16_HI:
6591 case R_PPC64_GOT_TLSLD16_HA:
6592 tls_type = TLS_TLS | TLS_LD;
6593 goto dogot;
6594
6595 case R_PPC64_GOT_TLSGD16:
6596 case R_PPC64_GOT_TLSGD16_LO:
6597 case R_PPC64_GOT_TLSGD16_HI:
6598 case R_PPC64_GOT_TLSGD16_HA:
6599 tls_type = TLS_TLS | TLS_GD;
6600 goto dogot;
6601
6602 case R_PPC64_GOT_TPREL16_DS:
6603 case R_PPC64_GOT_TPREL16_LO_DS:
6604 case R_PPC64_GOT_TPREL16_HI:
6605 case R_PPC64_GOT_TPREL16_HA:
6606 tls_type = TLS_TLS | TLS_TPREL;
6607 goto dogot;
6608
6609 case R_PPC64_GOT_DTPREL16_DS:
6610 case R_PPC64_GOT_DTPREL16_LO_DS:
6611 case R_PPC64_GOT_DTPREL16_HI:
6612 case R_PPC64_GOT_DTPREL16_HA:
6613 tls_type = TLS_TLS | TLS_DTPREL;
6614 goto dogot;
6615
6616 case R_PPC64_GOT16:
6617 case R_PPC64_GOT16_DS:
6618 case R_PPC64_GOT16_HA:
6619 case R_PPC64_GOT16_HI:
6620 case R_PPC64_GOT16_LO:
6621 case R_PPC64_GOT16_LO_DS:
6622 dogot:
6623 {
6624 struct got_entry *ent;
6625
6626 if (h != NULL)
6627 ent = h->got.glist;
6628 else
6629 ent = local_got_ents[r_symndx];
6630
6631 for (; ent != NULL; ent = ent->next)
6632 if (ent->addend == rel->r_addend
6633 && ent->owner == abfd
6634 && ent->tls_type == tls_type)
6635 break;
6636 if (ent == NULL)
6637 abort ();
6638 if (ent->got.refcount > 0)
6639 ent->got.refcount -= 1;
6640 }
6641 break;
6642
6643 case R_PPC64_PLT16_HA:
6644 case R_PPC64_PLT16_HI:
6645 case R_PPC64_PLT16_LO:
6646 case R_PPC64_PLT32:
6647 case R_PPC64_PLT64:
6648 case R_PPC64_REL14:
6649 case R_PPC64_REL14_BRNTAKEN:
6650 case R_PPC64_REL14_BRTAKEN:
6651 case R_PPC64_REL24:
6652 plt_list = NULL;
6653 if (h != NULL)
6654 plt_list = &h->plt.plist;
6655 else if (local_got_ents != NULL)
6656 {
6657 struct plt_entry **local_plt = (struct plt_entry **)
6658 (local_got_ents + symtab_hdr->sh_info);
6659 unsigned char *local_got_tls_masks = (unsigned char *)
6660 (local_plt + symtab_hdr->sh_info);
6661 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6662 plt_list = local_plt + r_symndx;
6663 }
6664 if (plt_list)
6665 {
6666 struct plt_entry *ent;
6667
6668 for (ent = *plt_list; ent != NULL; ent = ent->next)
6669 if (ent->addend == rel->r_addend)
6670 break;
6671 if (ent != NULL && ent->plt.refcount > 0)
6672 ent->plt.refcount -= 1;
6673 }
6674 break;
6675
6676 default:
6677 break;
6678 }
6679 }
6680 return TRUE;
6681 }
6682
6683 /* The maximum size of .sfpr. */
6684 #define SFPR_MAX (218*4)
6685
6686 struct sfpr_def_parms
6687 {
6688 const char name[12];
6689 unsigned char lo, hi;
6690 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6691 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6692 };
6693
6694 /* Auto-generate _save*, _rest* functions in .sfpr.
6695 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6696 instead. */
6697
6698 static bfd_boolean
6699 sfpr_define (struct bfd_link_info *info,
6700 const struct sfpr_def_parms *parm,
6701 asection *stub_sec)
6702 {
6703 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6704 unsigned int i;
6705 size_t len = strlen (parm->name);
6706 bfd_boolean writing = FALSE;
6707 char sym[16];
6708
6709 if (htab == NULL)
6710 return FALSE;
6711
6712 memcpy (sym, parm->name, len);
6713 sym[len + 2] = 0;
6714
6715 for (i = parm->lo; i <= parm->hi; i++)
6716 {
6717 struct ppc_link_hash_entry *h;
6718
6719 sym[len + 0] = i / 10 + '0';
6720 sym[len + 1] = i % 10 + '0';
6721 h = (struct ppc_link_hash_entry *)
6722 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6723 if (stub_sec != NULL)
6724 {
6725 if (h != NULL
6726 && h->elf.root.type == bfd_link_hash_defined
6727 && h->elf.root.u.def.section == htab->sfpr)
6728 {
6729 struct elf_link_hash_entry *s;
6730 char buf[32];
6731 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6732 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6733 if (s == NULL)
6734 return FALSE;
6735 if (s->root.type == bfd_link_hash_new
6736 || (s->root.type = bfd_link_hash_defined
6737 && s->root.u.def.section == stub_sec))
6738 {
6739 s->root.type = bfd_link_hash_defined;
6740 s->root.u.def.section = stub_sec;
6741 s->root.u.def.value = (stub_sec->size
6742 + h->elf.root.u.def.value);
6743 s->ref_regular = 1;
6744 s->def_regular = 1;
6745 s->ref_regular_nonweak = 1;
6746 s->forced_local = 1;
6747 s->non_elf = 0;
6748 s->root.linker_def = 1;
6749 }
6750 }
6751 continue;
6752 }
6753 if (h != NULL)
6754 {
6755 h->save_res = 1;
6756 if (!h->elf.def_regular)
6757 {
6758 h->elf.root.type = bfd_link_hash_defined;
6759 h->elf.root.u.def.section = htab->sfpr;
6760 h->elf.root.u.def.value = htab->sfpr->size;
6761 h->elf.type = STT_FUNC;
6762 h->elf.def_regular = 1;
6763 h->elf.non_elf = 0;
6764 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6765 writing = TRUE;
6766 if (htab->sfpr->contents == NULL)
6767 {
6768 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6769 if (htab->sfpr->contents == NULL)
6770 return FALSE;
6771 }
6772 }
6773 }
6774 if (writing)
6775 {
6776 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6777 if (i != parm->hi)
6778 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6779 else
6780 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6781 htab->sfpr->size = p - htab->sfpr->contents;
6782 }
6783 }
6784
6785 return TRUE;
6786 }
6787
6788 static bfd_byte *
6789 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6790 {
6791 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6792 return p + 4;
6793 }
6794
6795 static bfd_byte *
6796 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6797 {
6798 p = savegpr0 (abfd, p, r);
6799 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6800 p = p + 4;
6801 bfd_put_32 (abfd, BLR, p);
6802 return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6807 {
6808 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6809 return p + 4;
6810 }
6811
6812 static bfd_byte *
6813 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6814 {
6815 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6816 p = p + 4;
6817 p = restgpr0 (abfd, p, r);
6818 bfd_put_32 (abfd, MTLR_R0, p);
6819 p = p + 4;
6820 if (r == 29)
6821 {
6822 p = restgpr0 (abfd, p, 30);
6823 p = restgpr0 (abfd, p, 31);
6824 }
6825 bfd_put_32 (abfd, BLR, p);
6826 return p + 4;
6827 }
6828
6829 static bfd_byte *
6830 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6831 {
6832 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6833 return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6838 {
6839 p = savegpr1 (abfd, p, r);
6840 bfd_put_32 (abfd, BLR, p);
6841 return p + 4;
6842 }
6843
6844 static bfd_byte *
6845 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6846 {
6847 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6848 return p + 4;
6849 }
6850
6851 static bfd_byte *
6852 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6853 {
6854 p = restgpr1 (abfd, p, r);
6855 bfd_put_32 (abfd, BLR, p);
6856 return p + 4;
6857 }
6858
6859 static bfd_byte *
6860 savefpr (bfd *abfd, bfd_byte *p, int r)
6861 {
6862 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6863 return p + 4;
6864 }
6865
6866 static bfd_byte *
6867 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6868 {
6869 p = savefpr (abfd, p, r);
6870 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6871 p = p + 4;
6872 bfd_put_32 (abfd, BLR, p);
6873 return p + 4;
6874 }
6875
6876 static bfd_byte *
6877 restfpr (bfd *abfd, bfd_byte *p, int r)
6878 {
6879 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6880 return p + 4;
6881 }
6882
6883 static bfd_byte *
6884 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6885 {
6886 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6887 p = p + 4;
6888 p = restfpr (abfd, p, r);
6889 bfd_put_32 (abfd, MTLR_R0, p);
6890 p = p + 4;
6891 if (r == 29)
6892 {
6893 p = restfpr (abfd, p, 30);
6894 p = restfpr (abfd, p, 31);
6895 }
6896 bfd_put_32 (abfd, BLR, p);
6897 return p + 4;
6898 }
6899
6900 static bfd_byte *
6901 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6902 {
6903 p = savefpr (abfd, p, r);
6904 bfd_put_32 (abfd, BLR, p);
6905 return p + 4;
6906 }
6907
6908 static bfd_byte *
6909 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6910 {
6911 p = restfpr (abfd, p, r);
6912 bfd_put_32 (abfd, BLR, p);
6913 return p + 4;
6914 }
6915
6916 static bfd_byte *
6917 savevr (bfd *abfd, bfd_byte *p, int r)
6918 {
6919 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6920 p = p + 4;
6921 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6922 return p + 4;
6923 }
6924
6925 static bfd_byte *
6926 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6927 {
6928 p = savevr (abfd, p, r);
6929 bfd_put_32 (abfd, BLR, p);
6930 return p + 4;
6931 }
6932
6933 static bfd_byte *
6934 restvr (bfd *abfd, bfd_byte *p, int r)
6935 {
6936 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6937 p = p + 4;
6938 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6939 return p + 4;
6940 }
6941
6942 static bfd_byte *
6943 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6944 {
6945 p = restvr (abfd, p, r);
6946 bfd_put_32 (abfd, BLR, p);
6947 return p + 4;
6948 }
6949
6950 /* Called via elf_link_hash_traverse to transfer dynamic linking
6951 information on function code symbol entries to their corresponding
6952 function descriptor symbol entries. */
6953
6954 static bfd_boolean
6955 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6956 {
6957 struct bfd_link_info *info;
6958 struct ppc_link_hash_table *htab;
6959 struct plt_entry *ent;
6960 struct ppc_link_hash_entry *fh;
6961 struct ppc_link_hash_entry *fdh;
6962 bfd_boolean force_local;
6963
6964 fh = (struct ppc_link_hash_entry *) h;
6965 if (fh->elf.root.type == bfd_link_hash_indirect)
6966 return TRUE;
6967
6968 info = inf;
6969 htab = ppc_hash_table (info);
6970 if (htab == NULL)
6971 return FALSE;
6972
6973 /* Resolve undefined references to dot-symbols as the value
6974 in the function descriptor, if we have one in a regular object.
6975 This is to satisfy cases like ".quad .foo". Calls to functions
6976 in dynamic objects are handled elsewhere. */
6977 if (fh->elf.root.type == bfd_link_hash_undefweak
6978 && fh->was_undefined
6979 && (fdh = defined_func_desc (fh)) != NULL
6980 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6981 && opd_entry_value (fdh->elf.root.u.def.section,
6982 fdh->elf.root.u.def.value,
6983 &fh->elf.root.u.def.section,
6984 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6985 {
6986 fh->elf.root.type = fdh->elf.root.type;
6987 fh->elf.forced_local = 1;
6988 fh->elf.def_regular = fdh->elf.def_regular;
6989 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6990 }
6991
6992 /* If this is a function code symbol, transfer dynamic linking
6993 information to the function descriptor symbol. */
6994 if (!fh->is_func)
6995 return TRUE;
6996
6997 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6998 if (ent->plt.refcount > 0)
6999 break;
7000 if (ent == NULL
7001 || fh->elf.root.root.string[0] != '.'
7002 || fh->elf.root.root.string[1] == '\0')
7003 return TRUE;
7004
7005 /* Find the corresponding function descriptor symbol. Create it
7006 as undefined if necessary. */
7007
7008 fdh = lookup_fdh (fh, htab);
7009 if (fdh == NULL
7010 && !bfd_link_executable (info)
7011 && (fh->elf.root.type == bfd_link_hash_undefined
7012 || fh->elf.root.type == bfd_link_hash_undefweak))
7013 {
7014 fdh = make_fdh (info, fh);
7015 if (fdh == NULL)
7016 return FALSE;
7017 }
7018
7019 /* Fake function descriptors are made undefweak. If the function
7020 code symbol is strong undefined, make the fake sym the same.
7021 If the function code symbol is defined, then force the fake
7022 descriptor local; We can't support overriding of symbols in a
7023 shared library on a fake descriptor. */
7024
7025 if (fdh != NULL
7026 && fdh->fake
7027 && fdh->elf.root.type == bfd_link_hash_undefweak)
7028 {
7029 if (fh->elf.root.type == bfd_link_hash_undefined)
7030 {
7031 fdh->elf.root.type = bfd_link_hash_undefined;
7032 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
7033 }
7034 else if (fh->elf.root.type == bfd_link_hash_defined
7035 || fh->elf.root.type == bfd_link_hash_defweak)
7036 {
7037 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7038 }
7039 }
7040
7041 if (fdh != NULL
7042 && !fdh->elf.forced_local
7043 && (!bfd_link_executable (info)
7044 || fdh->elf.def_dynamic
7045 || fdh->elf.ref_dynamic
7046 || (fdh->elf.root.type == bfd_link_hash_undefweak
7047 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7048 {
7049 if (fdh->elf.dynindx == -1)
7050 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7051 return FALSE;
7052 fdh->elf.ref_regular |= fh->elf.ref_regular;
7053 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7054 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7055 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7056 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7057 {
7058 move_plt_plist (fh, fdh);
7059 fdh->elf.needs_plt = 1;
7060 }
7061 fdh->is_func_descriptor = 1;
7062 fdh->oh = fh;
7063 fh->oh = fdh;
7064 }
7065
7066 /* Now that the info is on the function descriptor, clear the
7067 function code sym info. Any function code syms for which we
7068 don't have a definition in a regular file, we force local.
7069 This prevents a shared library from exporting syms that have
7070 been imported from another library. Function code syms that
7071 are really in the library we must leave global to prevent the
7072 linker dragging in a definition from a static library. */
7073 force_local = (!fh->elf.def_regular
7074 || fdh == NULL
7075 || !fdh->elf.def_regular
7076 || fdh->elf.forced_local);
7077 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7078
7079 return TRUE;
7080 }
7081
7082 static const struct sfpr_def_parms save_res_funcs[] =
7083 {
7084 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7085 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7086 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7087 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7088 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7089 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7090 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7091 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7092 { "._savef", 14, 31, savefpr, savefpr1_tail },
7093 { "._restf", 14, 31, restfpr, restfpr1_tail },
7094 { "_savevr_", 20, 31, savevr, savevr_tail },
7095 { "_restvr_", 20, 31, restvr, restvr_tail }
7096 };
7097
7098 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7099 this hook to a) provide some gcc support functions, and b) transfer
7100 dynamic linking information gathered so far on function code symbol
7101 entries, to their corresponding function descriptor symbol entries. */
7102
7103 static bfd_boolean
7104 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7105 struct bfd_link_info *info)
7106 {
7107 struct ppc_link_hash_table *htab;
7108
7109 htab = ppc_hash_table (info);
7110 if (htab == NULL)
7111 return FALSE;
7112
7113 /* Provide any missing _save* and _rest* functions. */
7114 if (htab->sfpr != NULL)
7115 {
7116 unsigned int i;
7117
7118 htab->sfpr->size = 0;
7119 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7120 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7121 return FALSE;
7122 if (htab->sfpr->size == 0)
7123 htab->sfpr->flags |= SEC_EXCLUDE;
7124 }
7125
7126 if (bfd_link_relocatable (info))
7127 return TRUE;
7128
7129 if (htab->elf.hgot != NULL)
7130 {
7131 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7132 /* Make .TOC. defined so as to prevent it being made dynamic.
7133 The wrong value here is fixed later in ppc64_elf_set_toc. */
7134 if (!htab->elf.hgot->def_regular
7135 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7136 {
7137 htab->elf.hgot->root.type = bfd_link_hash_defined;
7138 htab->elf.hgot->root.u.def.value = 0;
7139 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7140 htab->elf.hgot->def_regular = 1;
7141 htab->elf.hgot->root.linker_def = 1;
7142 }
7143 htab->elf.hgot->type = STT_OBJECT;
7144 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7145 | STV_HIDDEN);
7146 }
7147
7148 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7149
7150 return TRUE;
7151 }
7152
7153 /* Return true if we have dynamic relocs against H that apply to
7154 read-only sections. */
7155
7156 static bfd_boolean
7157 readonly_dynrelocs (struct elf_link_hash_entry *h)
7158 {
7159 struct ppc_link_hash_entry *eh;
7160 struct elf_dyn_relocs *p;
7161
7162 eh = (struct ppc_link_hash_entry *) h;
7163 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7164 {
7165 asection *s = p->sec->output_section;
7166
7167 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7168 return TRUE;
7169 }
7170 return FALSE;
7171 }
7172
7173 /* Return true if we have dynamic relocs against H or any of its weak
7174 aliases, that apply to read-only sections. */
7175
7176 static bfd_boolean
7177 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7178 {
7179 struct ppc_link_hash_entry *eh;
7180
7181 eh = (struct ppc_link_hash_entry *) h;
7182 do
7183 {
7184 if (readonly_dynrelocs (&eh->elf))
7185 return TRUE;
7186 eh = eh->weakref;
7187 } while (eh != NULL && &eh->elf != h);
7188
7189 return FALSE;
7190 }
7191
7192 /* Return whether EH has pc-relative dynamic relocs. */
7193
7194 static bfd_boolean
7195 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7196 {
7197 struct elf_dyn_relocs *p;
7198
7199 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7200 if (p->pc_count != 0)
7201 return TRUE;
7202 return FALSE;
7203 }
7204
7205 /* Return true if a global entry stub will be created for H. Valid
7206 for ELFv2 before plt entries have been allocated. */
7207
7208 static bfd_boolean
7209 global_entry_stub (struct elf_link_hash_entry *h)
7210 {
7211 struct plt_entry *pent;
7212
7213 if (!h->pointer_equality_needed
7214 || h->def_regular)
7215 return FALSE;
7216
7217 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7218 if (pent->plt.refcount > 0
7219 && pent->addend == 0)
7220 return TRUE;
7221
7222 return FALSE;
7223 }
7224
7225 /* Adjust a symbol defined by a dynamic object and referenced by a
7226 regular object. The current definition is in some section of the
7227 dynamic object, but we're not including those sections. We have to
7228 change the definition to something the rest of the link can
7229 understand. */
7230
7231 static bfd_boolean
7232 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7233 struct elf_link_hash_entry *h)
7234 {
7235 struct ppc_link_hash_table *htab;
7236 asection *s;
7237
7238 htab = ppc_hash_table (info);
7239 if (htab == NULL)
7240 return FALSE;
7241
7242 /* Deal with function syms. */
7243 if (h->type == STT_FUNC
7244 || h->type == STT_GNU_IFUNC
7245 || h->needs_plt)
7246 {
7247 /* Clear procedure linkage table information for any symbol that
7248 won't need a .plt entry. */
7249 struct plt_entry *ent;
7250 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7251 if (ent->plt.refcount > 0)
7252 break;
7253 if (ent == NULL
7254 || (h->type != STT_GNU_IFUNC
7255 && (SYMBOL_CALLS_LOCAL (info, h)
7256 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7257 && h->root.type == bfd_link_hash_undefweak)))
7258 || ((struct ppc_link_hash_entry *) h)->save_res)
7259 {
7260 h->plt.plist = NULL;
7261 h->needs_plt = 0;
7262 h->pointer_equality_needed = 0;
7263 }
7264 else if (abiversion (info->output_bfd) >= 2)
7265 {
7266 /* Taking a function's address in a read/write section
7267 doesn't require us to define the function symbol in the
7268 executable on a global entry stub. A dynamic reloc can
7269 be used instead. The reason we prefer a few more dynamic
7270 relocs is that calling via a global entry stub costs a
7271 few more instructions, and pointer_equality_needed causes
7272 extra work in ld.so when resolving these symbols. */
7273 if (global_entry_stub (h)
7274 && !alias_readonly_dynrelocs (h))
7275 {
7276 h->pointer_equality_needed = 0;
7277 /* After adjust_dynamic_symbol, non_got_ref set in
7278 the non-pic case means that dyn_relocs for this
7279 symbol should be discarded. */
7280 h->non_got_ref = 0;
7281 }
7282
7283 /* If making a plt entry, then we don't need copy relocs. */
7284 return TRUE;
7285 }
7286 }
7287 else
7288 h->plt.plist = NULL;
7289
7290 /* If this is a weak symbol, and there is a real definition, the
7291 processor independent code will have arranged for us to see the
7292 real definition first, and we can just use the same value. */
7293 if (h->u.weakdef != NULL)
7294 {
7295 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7296 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7297 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7298 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7299 if (ELIMINATE_COPY_RELOCS)
7300 h->non_got_ref = h->u.weakdef->non_got_ref;
7301 return TRUE;
7302 }
7303
7304 /* If we are creating a shared library, we must presume that the
7305 only references to the symbol are via the global offset table.
7306 For such cases we need not do anything here; the relocations will
7307 be handled correctly by relocate_section. */
7308 if (bfd_link_pic (info))
7309 return TRUE;
7310
7311 /* If there are no references to this symbol that do not use the
7312 GOT, we don't need to generate a copy reloc. */
7313 if (!h->non_got_ref)
7314 return TRUE;
7315
7316 /* Don't generate a copy reloc for symbols defined in the executable. */
7317 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7318
7319 /* If -z nocopyreloc was given, don't generate them either. */
7320 || info->nocopyreloc
7321
7322 /* If we didn't find any dynamic relocs in read-only sections, then
7323 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7324 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7325
7326 /* Protected variables do not work with .dynbss. The copy in
7327 .dynbss won't be used by the shared library with the protected
7328 definition for the variable. Text relocations are preferable
7329 to an incorrect program. */
7330 || h->protected_def)
7331 {
7332 h->non_got_ref = 0;
7333 return TRUE;
7334 }
7335
7336 if (h->plt.plist != NULL)
7337 {
7338 /* We should never get here, but unfortunately there are versions
7339 of gcc out there that improperly (for this ABI) put initialized
7340 function pointers, vtable refs and suchlike in read-only
7341 sections. Allow them to proceed, but warn that this might
7342 break at runtime. */
7343 info->callbacks->einfo
7344 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7345 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7346 h->root.root.string);
7347 }
7348
7349 /* This is a reference to a symbol defined by a dynamic object which
7350 is not a function. */
7351
7352 /* We must allocate the symbol in our .dynbss section, which will
7353 become part of the .bss section of the executable. There will be
7354 an entry for this symbol in the .dynsym section. The dynamic
7355 object will contain position independent code, so all references
7356 from the dynamic object to this symbol will go through the global
7357 offset table. The dynamic linker will use the .dynsym entry to
7358 determine the address it must put in the global offset table, so
7359 both the dynamic object and the regular object will refer to the
7360 same memory location for the variable. */
7361
7362 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7363 to copy the initial value out of the dynamic object and into the
7364 runtime process image. We need to remember the offset into the
7365 .rela.bss section we are going to use. */
7366 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7367 {
7368 htab->relbss->size += sizeof (Elf64_External_Rela);
7369 h->needs_copy = 1;
7370 }
7371
7372 s = htab->dynbss;
7373
7374 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7375 }
7376
7377 /* If given a function descriptor symbol, hide both the function code
7378 sym and the descriptor. */
7379 static void
7380 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7381 struct elf_link_hash_entry *h,
7382 bfd_boolean force_local)
7383 {
7384 struct ppc_link_hash_entry *eh;
7385 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7386
7387 eh = (struct ppc_link_hash_entry *) h;
7388 if (eh->is_func_descriptor)
7389 {
7390 struct ppc_link_hash_entry *fh = eh->oh;
7391
7392 if (fh == NULL)
7393 {
7394 const char *p, *q;
7395 struct elf_link_hash_table *htab = elf_hash_table (info);
7396 char save;
7397
7398 /* We aren't supposed to use alloca in BFD because on
7399 systems which do not have alloca the version in libiberty
7400 calls xmalloc, which might cause the program to crash
7401 when it runs out of memory. This function doesn't have a
7402 return status, so there's no way to gracefully return an
7403 error. So cheat. We know that string[-1] can be safely
7404 accessed; It's either a string in an ELF string table,
7405 or allocated in an objalloc structure. */
7406
7407 p = eh->elf.root.root.string - 1;
7408 save = *p;
7409 *(char *) p = '.';
7410 fh = (struct ppc_link_hash_entry *)
7411 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7412 *(char *) p = save;
7413
7414 /* Unfortunately, if it so happens that the string we were
7415 looking for was allocated immediately before this string,
7416 then we overwrote the string terminator. That's the only
7417 reason the lookup should fail. */
7418 if (fh == NULL)
7419 {
7420 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7421 while (q >= eh->elf.root.root.string && *q == *p)
7422 --q, --p;
7423 if (q < eh->elf.root.root.string && *p == '.')
7424 fh = (struct ppc_link_hash_entry *)
7425 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7426 }
7427 if (fh != NULL)
7428 {
7429 eh->oh = fh;
7430 fh->oh = eh;
7431 }
7432 }
7433 if (fh != NULL)
7434 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7435 }
7436 }
7437
7438 static bfd_boolean
7439 get_sym_h (struct elf_link_hash_entry **hp,
7440 Elf_Internal_Sym **symp,
7441 asection **symsecp,
7442 unsigned char **tls_maskp,
7443 Elf_Internal_Sym **locsymsp,
7444 unsigned long r_symndx,
7445 bfd *ibfd)
7446 {
7447 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7448
7449 if (r_symndx >= symtab_hdr->sh_info)
7450 {
7451 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7452 struct elf_link_hash_entry *h;
7453
7454 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7455 h = elf_follow_link (h);
7456
7457 if (hp != NULL)
7458 *hp = h;
7459
7460 if (symp != NULL)
7461 *symp = NULL;
7462
7463 if (symsecp != NULL)
7464 {
7465 asection *symsec = NULL;
7466 if (h->root.type == bfd_link_hash_defined
7467 || h->root.type == bfd_link_hash_defweak)
7468 symsec = h->root.u.def.section;
7469 *symsecp = symsec;
7470 }
7471
7472 if (tls_maskp != NULL)
7473 {
7474 struct ppc_link_hash_entry *eh;
7475
7476 eh = (struct ppc_link_hash_entry *) h;
7477 *tls_maskp = &eh->tls_mask;
7478 }
7479 }
7480 else
7481 {
7482 Elf_Internal_Sym *sym;
7483 Elf_Internal_Sym *locsyms = *locsymsp;
7484
7485 if (locsyms == NULL)
7486 {
7487 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7488 if (locsyms == NULL)
7489 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7490 symtab_hdr->sh_info,
7491 0, NULL, NULL, NULL);
7492 if (locsyms == NULL)
7493 return FALSE;
7494 *locsymsp = locsyms;
7495 }
7496 sym = locsyms + r_symndx;
7497
7498 if (hp != NULL)
7499 *hp = NULL;
7500
7501 if (symp != NULL)
7502 *symp = sym;
7503
7504 if (symsecp != NULL)
7505 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7506
7507 if (tls_maskp != NULL)
7508 {
7509 struct got_entry **lgot_ents;
7510 unsigned char *tls_mask;
7511
7512 tls_mask = NULL;
7513 lgot_ents = elf_local_got_ents (ibfd);
7514 if (lgot_ents != NULL)
7515 {
7516 struct plt_entry **local_plt = (struct plt_entry **)
7517 (lgot_ents + symtab_hdr->sh_info);
7518 unsigned char *lgot_masks = (unsigned char *)
7519 (local_plt + symtab_hdr->sh_info);
7520 tls_mask = &lgot_masks[r_symndx];
7521 }
7522 *tls_maskp = tls_mask;
7523 }
7524 }
7525 return TRUE;
7526 }
7527
7528 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7529 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7530 type suitable for optimization, and 1 otherwise. */
7531
7532 static int
7533 get_tls_mask (unsigned char **tls_maskp,
7534 unsigned long *toc_symndx,
7535 bfd_vma *toc_addend,
7536 Elf_Internal_Sym **locsymsp,
7537 const Elf_Internal_Rela *rel,
7538 bfd *ibfd)
7539 {
7540 unsigned long r_symndx;
7541 int next_r;
7542 struct elf_link_hash_entry *h;
7543 Elf_Internal_Sym *sym;
7544 asection *sec;
7545 bfd_vma off;
7546
7547 r_symndx = ELF64_R_SYM (rel->r_info);
7548 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7549 return 0;
7550
7551 if ((*tls_maskp != NULL && **tls_maskp != 0)
7552 || sec == NULL
7553 || ppc64_elf_section_data (sec) == NULL
7554 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7555 return 1;
7556
7557 /* Look inside a TOC section too. */
7558 if (h != NULL)
7559 {
7560 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7561 off = h->root.u.def.value;
7562 }
7563 else
7564 off = sym->st_value;
7565 off += rel->r_addend;
7566 BFD_ASSERT (off % 8 == 0);
7567 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7568 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7569 if (toc_symndx != NULL)
7570 *toc_symndx = r_symndx;
7571 if (toc_addend != NULL)
7572 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7573 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7574 return 0;
7575 if ((h == NULL || is_static_defined (h))
7576 && (next_r == -1 || next_r == -2))
7577 return 1 - next_r;
7578 return 1;
7579 }
7580
7581 /* Find (or create) an entry in the tocsave hash table. */
7582
7583 static struct tocsave_entry *
7584 tocsave_find (struct ppc_link_hash_table *htab,
7585 enum insert_option insert,
7586 Elf_Internal_Sym **local_syms,
7587 const Elf_Internal_Rela *irela,
7588 bfd *ibfd)
7589 {
7590 unsigned long r_indx;
7591 struct elf_link_hash_entry *h;
7592 Elf_Internal_Sym *sym;
7593 struct tocsave_entry ent, *p;
7594 hashval_t hash;
7595 struct tocsave_entry **slot;
7596
7597 r_indx = ELF64_R_SYM (irela->r_info);
7598 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7599 return NULL;
7600 if (ent.sec == NULL || ent.sec->output_section == NULL)
7601 {
7602 _bfd_error_handler
7603 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7604 return NULL;
7605 }
7606
7607 if (h != NULL)
7608 ent.offset = h->root.u.def.value;
7609 else
7610 ent.offset = sym->st_value;
7611 ent.offset += irela->r_addend;
7612
7613 hash = tocsave_htab_hash (&ent);
7614 slot = ((struct tocsave_entry **)
7615 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7616 if (slot == NULL)
7617 return NULL;
7618
7619 if (*slot == NULL)
7620 {
7621 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7622 if (p == NULL)
7623 return NULL;
7624 *p = ent;
7625 *slot = p;
7626 }
7627 return *slot;
7628 }
7629
7630 /* Adjust all global syms defined in opd sections. In gcc generated
7631 code for the old ABI, these will already have been done. */
7632
7633 static bfd_boolean
7634 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7635 {
7636 struct ppc_link_hash_entry *eh;
7637 asection *sym_sec;
7638 struct _opd_sec_data *opd;
7639
7640 if (h->root.type == bfd_link_hash_indirect)
7641 return TRUE;
7642
7643 if (h->root.type != bfd_link_hash_defined
7644 && h->root.type != bfd_link_hash_defweak)
7645 return TRUE;
7646
7647 eh = (struct ppc_link_hash_entry *) h;
7648 if (eh->adjust_done)
7649 return TRUE;
7650
7651 sym_sec = eh->elf.root.u.def.section;
7652 opd = get_opd_info (sym_sec);
7653 if (opd != NULL && opd->adjust != NULL)
7654 {
7655 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7656 if (adjust == -1)
7657 {
7658 /* This entry has been deleted. */
7659 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7660 if (dsec == NULL)
7661 {
7662 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7663 if (discarded_section (dsec))
7664 {
7665 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7666 break;
7667 }
7668 }
7669 eh->elf.root.u.def.value = 0;
7670 eh->elf.root.u.def.section = dsec;
7671 }
7672 else
7673 eh->elf.root.u.def.value += adjust;
7674 eh->adjust_done = 1;
7675 }
7676 return TRUE;
7677 }
7678
7679 /* Handles decrementing dynamic reloc counts for the reloc specified by
7680 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7681 have already been determined. */
7682
7683 static bfd_boolean
7684 dec_dynrel_count (bfd_vma r_info,
7685 asection *sec,
7686 struct bfd_link_info *info,
7687 Elf_Internal_Sym **local_syms,
7688 struct elf_link_hash_entry *h,
7689 Elf_Internal_Sym *sym)
7690 {
7691 enum elf_ppc64_reloc_type r_type;
7692 asection *sym_sec = NULL;
7693
7694 /* Can this reloc be dynamic? This switch, and later tests here
7695 should be kept in sync with the code in check_relocs. */
7696 r_type = ELF64_R_TYPE (r_info);
7697 switch (r_type)
7698 {
7699 default:
7700 return TRUE;
7701
7702 case R_PPC64_TPREL16:
7703 case R_PPC64_TPREL16_LO:
7704 case R_PPC64_TPREL16_HI:
7705 case R_PPC64_TPREL16_HA:
7706 case R_PPC64_TPREL16_DS:
7707 case R_PPC64_TPREL16_LO_DS:
7708 case R_PPC64_TPREL16_HIGH:
7709 case R_PPC64_TPREL16_HIGHA:
7710 case R_PPC64_TPREL16_HIGHER:
7711 case R_PPC64_TPREL16_HIGHERA:
7712 case R_PPC64_TPREL16_HIGHEST:
7713 case R_PPC64_TPREL16_HIGHESTA:
7714 if (!bfd_link_pic (info))
7715 return TRUE;
7716
7717 case R_PPC64_TPREL64:
7718 case R_PPC64_DTPMOD64:
7719 case R_PPC64_DTPREL64:
7720 case R_PPC64_ADDR64:
7721 case R_PPC64_REL30:
7722 case R_PPC64_REL32:
7723 case R_PPC64_REL64:
7724 case R_PPC64_ADDR14:
7725 case R_PPC64_ADDR14_BRNTAKEN:
7726 case R_PPC64_ADDR14_BRTAKEN:
7727 case R_PPC64_ADDR16:
7728 case R_PPC64_ADDR16_DS:
7729 case R_PPC64_ADDR16_HA:
7730 case R_PPC64_ADDR16_HI:
7731 case R_PPC64_ADDR16_HIGH:
7732 case R_PPC64_ADDR16_HIGHA:
7733 case R_PPC64_ADDR16_HIGHER:
7734 case R_PPC64_ADDR16_HIGHERA:
7735 case R_PPC64_ADDR16_HIGHEST:
7736 case R_PPC64_ADDR16_HIGHESTA:
7737 case R_PPC64_ADDR16_LO:
7738 case R_PPC64_ADDR16_LO_DS:
7739 case R_PPC64_ADDR24:
7740 case R_PPC64_ADDR32:
7741 case R_PPC64_UADDR16:
7742 case R_PPC64_UADDR32:
7743 case R_PPC64_UADDR64:
7744 case R_PPC64_TOC:
7745 break;
7746 }
7747
7748 if (local_syms != NULL)
7749 {
7750 unsigned long r_symndx;
7751 bfd *ibfd = sec->owner;
7752
7753 r_symndx = ELF64_R_SYM (r_info);
7754 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7755 return FALSE;
7756 }
7757
7758 if ((bfd_link_pic (info)
7759 && (must_be_dyn_reloc (info, r_type)
7760 || (h != NULL
7761 && (!SYMBOLIC_BIND (info, h)
7762 || h->root.type == bfd_link_hash_defweak
7763 || !h->def_regular))))
7764 || (ELIMINATE_COPY_RELOCS
7765 && !bfd_link_pic (info)
7766 && h != NULL
7767 && (h->root.type == bfd_link_hash_defweak
7768 || !h->def_regular)))
7769 ;
7770 else
7771 return TRUE;
7772
7773 if (h != NULL)
7774 {
7775 struct elf_dyn_relocs *p;
7776 struct elf_dyn_relocs **pp;
7777 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7778
7779 /* elf_gc_sweep may have already removed all dyn relocs associated
7780 with local syms for a given section. Also, symbol flags are
7781 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7782 report a dynreloc miscount. */
7783 if (*pp == NULL && info->gc_sections)
7784 return TRUE;
7785
7786 while ((p = *pp) != NULL)
7787 {
7788 if (p->sec == sec)
7789 {
7790 if (!must_be_dyn_reloc (info, r_type))
7791 p->pc_count -= 1;
7792 p->count -= 1;
7793 if (p->count == 0)
7794 *pp = p->next;
7795 return TRUE;
7796 }
7797 pp = &p->next;
7798 }
7799 }
7800 else
7801 {
7802 struct ppc_dyn_relocs *p;
7803 struct ppc_dyn_relocs **pp;
7804 void *vpp;
7805 bfd_boolean is_ifunc;
7806
7807 if (local_syms == NULL)
7808 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7809 if (sym_sec == NULL)
7810 sym_sec = sec;
7811
7812 vpp = &elf_section_data (sym_sec)->local_dynrel;
7813 pp = (struct ppc_dyn_relocs **) vpp;
7814
7815 if (*pp == NULL && info->gc_sections)
7816 return TRUE;
7817
7818 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7819 while ((p = *pp) != NULL)
7820 {
7821 if (p->sec == sec && p->ifunc == is_ifunc)
7822 {
7823 p->count -= 1;
7824 if (p->count == 0)
7825 *pp = p->next;
7826 return TRUE;
7827 }
7828 pp = &p->next;
7829 }
7830 }
7831
7832 /* xgettext:c-format */
7833 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7834 sec->owner, sec);
7835 bfd_set_error (bfd_error_bad_value);
7836 return FALSE;
7837 }
7838
7839 /* Remove unused Official Procedure Descriptor entries. Currently we
7840 only remove those associated with functions in discarded link-once
7841 sections, or weakly defined functions that have been overridden. It
7842 would be possible to remove many more entries for statically linked
7843 applications. */
7844
7845 bfd_boolean
7846 ppc64_elf_edit_opd (struct bfd_link_info *info)
7847 {
7848 bfd *ibfd;
7849 bfd_boolean some_edited = FALSE;
7850 asection *need_pad = NULL;
7851 struct ppc_link_hash_table *htab;
7852
7853 htab = ppc_hash_table (info);
7854 if (htab == NULL)
7855 return FALSE;
7856
7857 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7858 {
7859 asection *sec;
7860 Elf_Internal_Rela *relstart, *rel, *relend;
7861 Elf_Internal_Shdr *symtab_hdr;
7862 Elf_Internal_Sym *local_syms;
7863 struct _opd_sec_data *opd;
7864 bfd_boolean need_edit, add_aux_fields, broken;
7865 bfd_size_type cnt_16b = 0;
7866
7867 if (!is_ppc64_elf (ibfd))
7868 continue;
7869
7870 sec = bfd_get_section_by_name (ibfd, ".opd");
7871 if (sec == NULL || sec->size == 0)
7872 continue;
7873
7874 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7875 continue;
7876
7877 if (sec->output_section == bfd_abs_section_ptr)
7878 continue;
7879
7880 /* Look through the section relocs. */
7881 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7882 continue;
7883
7884 local_syms = NULL;
7885 symtab_hdr = &elf_symtab_hdr (ibfd);
7886
7887 /* Read the relocations. */
7888 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7889 info->keep_memory);
7890 if (relstart == NULL)
7891 return FALSE;
7892
7893 /* First run through the relocs to check they are sane, and to
7894 determine whether we need to edit this opd section. */
7895 need_edit = FALSE;
7896 broken = FALSE;
7897 need_pad = sec;
7898 relend = relstart + sec->reloc_count;
7899 for (rel = relstart; rel < relend; )
7900 {
7901 enum elf_ppc64_reloc_type r_type;
7902 unsigned long r_symndx;
7903 asection *sym_sec;
7904 struct elf_link_hash_entry *h;
7905 Elf_Internal_Sym *sym;
7906 bfd_vma offset;
7907
7908 /* .opd contains an array of 16 or 24 byte entries. We're
7909 only interested in the reloc pointing to a function entry
7910 point. */
7911 offset = rel->r_offset;
7912 if (rel + 1 == relend
7913 || rel[1].r_offset != offset + 8)
7914 {
7915 /* If someone messes with .opd alignment then after a
7916 "ld -r" we might have padding in the middle of .opd.
7917 Also, there's nothing to prevent someone putting
7918 something silly in .opd with the assembler. No .opd
7919 optimization for them! */
7920 broken_opd:
7921 _bfd_error_handler
7922 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7923 broken = TRUE;
7924 break;
7925 }
7926
7927 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7928 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7929 {
7930 _bfd_error_handler
7931 /* xgettext:c-format */
7932 (_("%B: unexpected reloc type %u in .opd section"),
7933 ibfd, r_type);
7934 broken = TRUE;
7935 break;
7936 }
7937
7938 r_symndx = ELF64_R_SYM (rel->r_info);
7939 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7940 r_symndx, ibfd))
7941 goto error_ret;
7942
7943 if (sym_sec == NULL || sym_sec->owner == NULL)
7944 {
7945 const char *sym_name;
7946 if (h != NULL)
7947 sym_name = h->root.root.string;
7948 else
7949 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7950 sym_sec);
7951
7952 _bfd_error_handler
7953 /* xgettext:c-format */
7954 (_("%B: undefined sym `%s' in .opd section"),
7955 ibfd, sym_name);
7956 broken = TRUE;
7957 break;
7958 }
7959
7960 /* opd entries are always for functions defined in the
7961 current input bfd. If the symbol isn't defined in the
7962 input bfd, then we won't be using the function in this
7963 bfd; It must be defined in a linkonce section in another
7964 bfd, or is weak. It's also possible that we are
7965 discarding the function due to a linker script /DISCARD/,
7966 which we test for via the output_section. */
7967 if (sym_sec->owner != ibfd
7968 || sym_sec->output_section == bfd_abs_section_ptr)
7969 need_edit = TRUE;
7970
7971 rel += 2;
7972 if (rel + 1 == relend
7973 || (rel + 2 < relend
7974 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7975 ++rel;
7976
7977 if (rel == relend)
7978 {
7979 if (sec->size == offset + 24)
7980 {
7981 need_pad = NULL;
7982 break;
7983 }
7984 if (sec->size == offset + 16)
7985 {
7986 cnt_16b++;
7987 break;
7988 }
7989 goto broken_opd;
7990 }
7991 else if (rel + 1 < relend
7992 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7993 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7994 {
7995 if (rel[0].r_offset == offset + 16)
7996 cnt_16b++;
7997 else if (rel[0].r_offset != offset + 24)
7998 goto broken_opd;
7999 }
8000 else
8001 goto broken_opd;
8002 }
8003
8004 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8005
8006 if (!broken && (need_edit || add_aux_fields))
8007 {
8008 Elf_Internal_Rela *write_rel;
8009 Elf_Internal_Shdr *rel_hdr;
8010 bfd_byte *rptr, *wptr;
8011 bfd_byte *new_contents;
8012 bfd_size_type amt;
8013
8014 new_contents = NULL;
8015 amt = OPD_NDX (sec->size) * sizeof (long);
8016 opd = &ppc64_elf_section_data (sec)->u.opd;
8017 opd->adjust = bfd_zalloc (sec->owner, amt);
8018 if (opd->adjust == NULL)
8019 return FALSE;
8020 ppc64_elf_section_data (sec)->sec_type = sec_opd;
8021
8022 /* This seems a waste of time as input .opd sections are all
8023 zeros as generated by gcc, but I suppose there's no reason
8024 this will always be so. We might start putting something in
8025 the third word of .opd entries. */
8026 if ((sec->flags & SEC_IN_MEMORY) == 0)
8027 {
8028 bfd_byte *loc;
8029 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8030 {
8031 if (loc != NULL)
8032 free (loc);
8033 error_ret:
8034 if (local_syms != NULL
8035 && symtab_hdr->contents != (unsigned char *) local_syms)
8036 free (local_syms);
8037 if (elf_section_data (sec)->relocs != relstart)
8038 free (relstart);
8039 return FALSE;
8040 }
8041 sec->contents = loc;
8042 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8043 }
8044
8045 elf_section_data (sec)->relocs = relstart;
8046
8047 new_contents = sec->contents;
8048 if (add_aux_fields)
8049 {
8050 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8051 if (new_contents == NULL)
8052 return FALSE;
8053 need_pad = NULL;
8054 }
8055 wptr = new_contents;
8056 rptr = sec->contents;
8057 write_rel = relstart;
8058 for (rel = relstart; rel < relend; )
8059 {
8060 unsigned long r_symndx;
8061 asection *sym_sec;
8062 struct elf_link_hash_entry *h;
8063 struct ppc_link_hash_entry *fdh = NULL;
8064 Elf_Internal_Sym *sym;
8065 long opd_ent_size;
8066 Elf_Internal_Rela *next_rel;
8067 bfd_boolean skip;
8068
8069 r_symndx = ELF64_R_SYM (rel->r_info);
8070 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8071 r_symndx, ibfd))
8072 goto error_ret;
8073
8074 next_rel = rel + 2;
8075 if (next_rel + 1 == relend
8076 || (next_rel + 2 < relend
8077 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8078 ++next_rel;
8079
8080 /* See if the .opd entry is full 24 byte or
8081 16 byte (with fd_aux entry overlapped with next
8082 fd_func). */
8083 opd_ent_size = 24;
8084 if (next_rel == relend)
8085 {
8086 if (sec->size == rel->r_offset + 16)
8087 opd_ent_size = 16;
8088 }
8089 else if (next_rel->r_offset == rel->r_offset + 16)
8090 opd_ent_size = 16;
8091
8092 if (h != NULL
8093 && h->root.root.string[0] == '.')
8094 {
8095 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8096 if (fdh != NULL
8097 && fdh->elf.root.type != bfd_link_hash_defined
8098 && fdh->elf.root.type != bfd_link_hash_defweak)
8099 fdh = NULL;
8100 }
8101
8102 skip = (sym_sec->owner != ibfd
8103 || sym_sec->output_section == bfd_abs_section_ptr);
8104 if (skip)
8105 {
8106 if (fdh != NULL && sym_sec->owner == ibfd)
8107 {
8108 /* Arrange for the function descriptor sym
8109 to be dropped. */
8110 fdh->elf.root.u.def.value = 0;
8111 fdh->elf.root.u.def.section = sym_sec;
8112 }
8113 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8114
8115 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8116 rel = next_rel;
8117 else
8118 while (1)
8119 {
8120 if (!dec_dynrel_count (rel->r_info, sec, info,
8121 NULL, h, sym))
8122 goto error_ret;
8123
8124 if (++rel == next_rel)
8125 break;
8126
8127 r_symndx = ELF64_R_SYM (rel->r_info);
8128 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8129 r_symndx, ibfd))
8130 goto error_ret;
8131 }
8132 }
8133 else
8134 {
8135 /* We'll be keeping this opd entry. */
8136 long adjust;
8137
8138 if (fdh != NULL)
8139 {
8140 /* Redefine the function descriptor symbol to
8141 this location in the opd section. It is
8142 necessary to update the value here rather
8143 than using an array of adjustments as we do
8144 for local symbols, because various places
8145 in the generic ELF code use the value
8146 stored in u.def.value. */
8147 fdh->elf.root.u.def.value = wptr - new_contents;
8148 fdh->adjust_done = 1;
8149 }
8150
8151 /* Local syms are a bit tricky. We could
8152 tweak them as they can be cached, but
8153 we'd need to look through the local syms
8154 for the function descriptor sym which we
8155 don't have at the moment. So keep an
8156 array of adjustments. */
8157 adjust = (wptr - new_contents) - (rptr - sec->contents);
8158 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8159
8160 if (wptr != rptr)
8161 memcpy (wptr, rptr, opd_ent_size);
8162 wptr += opd_ent_size;
8163 if (add_aux_fields && opd_ent_size == 16)
8164 {
8165 memset (wptr, '\0', 8);
8166 wptr += 8;
8167 }
8168
8169 /* We need to adjust any reloc offsets to point to the
8170 new opd entries. */
8171 for ( ; rel != next_rel; ++rel)
8172 {
8173 rel->r_offset += adjust;
8174 if (write_rel != rel)
8175 memcpy (write_rel, rel, sizeof (*rel));
8176 ++write_rel;
8177 }
8178 }
8179
8180 rptr += opd_ent_size;
8181 }
8182
8183 sec->size = wptr - new_contents;
8184 sec->reloc_count = write_rel - relstart;
8185 if (add_aux_fields)
8186 {
8187 free (sec->contents);
8188 sec->contents = new_contents;
8189 }
8190
8191 /* Fudge the header size too, as this is used later in
8192 elf_bfd_final_link if we are emitting relocs. */
8193 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8194 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8195 some_edited = TRUE;
8196 }
8197 else if (elf_section_data (sec)->relocs != relstart)
8198 free (relstart);
8199
8200 if (local_syms != NULL
8201 && symtab_hdr->contents != (unsigned char *) local_syms)
8202 {
8203 if (!info->keep_memory)
8204 free (local_syms);
8205 else
8206 symtab_hdr->contents = (unsigned char *) local_syms;
8207 }
8208 }
8209
8210 if (some_edited)
8211 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8212
8213 /* If we are doing a final link and the last .opd entry is just 16 byte
8214 long, add a 8 byte padding after it. */
8215 if (need_pad != NULL && !bfd_link_relocatable (info))
8216 {
8217 bfd_byte *p;
8218
8219 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8220 {
8221 BFD_ASSERT (need_pad->size > 0);
8222
8223 p = bfd_malloc (need_pad->size + 8);
8224 if (p == NULL)
8225 return FALSE;
8226
8227 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8228 p, 0, need_pad->size))
8229 return FALSE;
8230
8231 need_pad->contents = p;
8232 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8233 }
8234 else
8235 {
8236 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8237 if (p == NULL)
8238 return FALSE;
8239
8240 need_pad->contents = p;
8241 }
8242
8243 memset (need_pad->contents + need_pad->size, 0, 8);
8244 need_pad->size += 8;
8245 }
8246
8247 return TRUE;
8248 }
8249
8250 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8251
8252 asection *
8253 ppc64_elf_tls_setup (struct bfd_link_info *info)
8254 {
8255 struct ppc_link_hash_table *htab;
8256
8257 htab = ppc_hash_table (info);
8258 if (htab == NULL)
8259 return NULL;
8260
8261 if (abiversion (info->output_bfd) == 1)
8262 htab->opd_abi = 1;
8263
8264 if (htab->params->no_multi_toc)
8265 htab->do_multi_toc = 0;
8266 else if (!htab->do_multi_toc)
8267 htab->params->no_multi_toc = 1;
8268
8269 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8270 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8271 FALSE, FALSE, TRUE));
8272 /* Move dynamic linking info to the function descriptor sym. */
8273 if (htab->tls_get_addr != NULL)
8274 func_desc_adjust (&htab->tls_get_addr->elf, info);
8275 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8276 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8277 FALSE, FALSE, TRUE));
8278 if (htab->params->tls_get_addr_opt)
8279 {
8280 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8281
8282 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8283 FALSE, FALSE, TRUE);
8284 if (opt != NULL)
8285 func_desc_adjust (opt, info);
8286 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8287 FALSE, FALSE, TRUE);
8288 if (opt_fd != NULL
8289 && (opt_fd->root.type == bfd_link_hash_defined
8290 || opt_fd->root.type == bfd_link_hash_defweak))
8291 {
8292 /* If glibc supports an optimized __tls_get_addr call stub,
8293 signalled by the presence of __tls_get_addr_opt, and we'll
8294 be calling __tls_get_addr via a plt call stub, then
8295 make __tls_get_addr point to __tls_get_addr_opt. */
8296 tga_fd = &htab->tls_get_addr_fd->elf;
8297 if (htab->elf.dynamic_sections_created
8298 && tga_fd != NULL
8299 && (tga_fd->type == STT_FUNC
8300 || tga_fd->needs_plt)
8301 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8302 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8303 && tga_fd->root.type == bfd_link_hash_undefweak)))
8304 {
8305 struct plt_entry *ent;
8306
8307 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8308 if (ent->plt.refcount > 0)
8309 break;
8310 if (ent != NULL)
8311 {
8312 tga_fd->root.type = bfd_link_hash_indirect;
8313 tga_fd->root.u.i.link = &opt_fd->root;
8314 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8315 opt_fd->forced_local = 0;
8316 if (opt_fd->dynindx != -1)
8317 {
8318 /* Use __tls_get_addr_opt in dynamic relocations. */
8319 opt_fd->dynindx = -1;
8320 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8321 opt_fd->dynstr_index);
8322 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8323 return NULL;
8324 }
8325 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8326 tga = &htab->tls_get_addr->elf;
8327 if (opt != NULL && tga != NULL)
8328 {
8329 tga->root.type = bfd_link_hash_indirect;
8330 tga->root.u.i.link = &opt->root;
8331 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8332 opt->forced_local = 0;
8333 _bfd_elf_link_hash_hide_symbol (info, opt,
8334 tga->forced_local);
8335 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8336 }
8337 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8338 htab->tls_get_addr_fd->is_func_descriptor = 1;
8339 if (htab->tls_get_addr != NULL)
8340 {
8341 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8342 htab->tls_get_addr->is_func = 1;
8343 }
8344 }
8345 }
8346 }
8347 else if (htab->params->tls_get_addr_opt < 0)
8348 htab->params->tls_get_addr_opt = 0;
8349 }
8350 return _bfd_elf_tls_setup (info->output_bfd, info);
8351 }
8352
8353 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8354 HASH1 or HASH2. */
8355
8356 static bfd_boolean
8357 branch_reloc_hash_match (const bfd *ibfd,
8358 const Elf_Internal_Rela *rel,
8359 const struct ppc_link_hash_entry *hash1,
8360 const struct ppc_link_hash_entry *hash2)
8361 {
8362 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8363 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8364 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8365
8366 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8367 {
8368 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8369 struct elf_link_hash_entry *h;
8370
8371 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8372 h = elf_follow_link (h);
8373 if (h == &hash1->elf || h == &hash2->elf)
8374 return TRUE;
8375 }
8376 return FALSE;
8377 }
8378
8379 /* Run through all the TLS relocs looking for optimization
8380 opportunities. The linker has been hacked (see ppc64elf.em) to do
8381 a preliminary section layout so that we know the TLS segment
8382 offsets. We can't optimize earlier because some optimizations need
8383 to know the tp offset, and we need to optimize before allocating
8384 dynamic relocations. */
8385
8386 bfd_boolean
8387 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8388 {
8389 bfd *ibfd;
8390 asection *sec;
8391 struct ppc_link_hash_table *htab;
8392 unsigned char *toc_ref;
8393 int pass;
8394
8395 if (!bfd_link_executable (info))
8396 return TRUE;
8397
8398 htab = ppc_hash_table (info);
8399 if (htab == NULL)
8400 return FALSE;
8401
8402 /* Make two passes over the relocs. On the first pass, mark toc
8403 entries involved with tls relocs, and check that tls relocs
8404 involved in setting up a tls_get_addr call are indeed followed by
8405 such a call. If they are not, we can't do any tls optimization.
8406 On the second pass twiddle tls_mask flags to notify
8407 relocate_section that optimization can be done, and adjust got
8408 and plt refcounts. */
8409 toc_ref = NULL;
8410 for (pass = 0; pass < 2; ++pass)
8411 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8412 {
8413 Elf_Internal_Sym *locsyms = NULL;
8414 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8415
8416 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8417 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8418 {
8419 Elf_Internal_Rela *relstart, *rel, *relend;
8420 bfd_boolean found_tls_get_addr_arg = 0;
8421
8422 /* Read the relocations. */
8423 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8424 info->keep_memory);
8425 if (relstart == NULL)
8426 {
8427 free (toc_ref);
8428 return FALSE;
8429 }
8430
8431 relend = relstart + sec->reloc_count;
8432 for (rel = relstart; rel < relend; rel++)
8433 {
8434 enum elf_ppc64_reloc_type r_type;
8435 unsigned long r_symndx;
8436 struct elf_link_hash_entry *h;
8437 Elf_Internal_Sym *sym;
8438 asection *sym_sec;
8439 unsigned char *tls_mask;
8440 unsigned char tls_set, tls_clear, tls_type = 0;
8441 bfd_vma value;
8442 bfd_boolean ok_tprel, is_local;
8443 long toc_ref_index = 0;
8444 int expecting_tls_get_addr = 0;
8445 bfd_boolean ret = FALSE;
8446
8447 r_symndx = ELF64_R_SYM (rel->r_info);
8448 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8449 r_symndx, ibfd))
8450 {
8451 err_free_rel:
8452 if (elf_section_data (sec)->relocs != relstart)
8453 free (relstart);
8454 if (toc_ref != NULL)
8455 free (toc_ref);
8456 if (locsyms != NULL
8457 && (elf_symtab_hdr (ibfd).contents
8458 != (unsigned char *) locsyms))
8459 free (locsyms);
8460 return ret;
8461 }
8462
8463 if (h != NULL)
8464 {
8465 if (h->root.type == bfd_link_hash_defined
8466 || h->root.type == bfd_link_hash_defweak)
8467 value = h->root.u.def.value;
8468 else if (h->root.type == bfd_link_hash_undefweak)
8469 value = 0;
8470 else
8471 {
8472 found_tls_get_addr_arg = 0;
8473 continue;
8474 }
8475 }
8476 else
8477 /* Symbols referenced by TLS relocs must be of type
8478 STT_TLS. So no need for .opd local sym adjust. */
8479 value = sym->st_value;
8480
8481 ok_tprel = FALSE;
8482 is_local = FALSE;
8483 if (h == NULL
8484 || !h->def_dynamic)
8485 {
8486 is_local = TRUE;
8487 if (h != NULL
8488 && h->root.type == bfd_link_hash_undefweak)
8489 ok_tprel = TRUE;
8490 else if (sym_sec != NULL
8491 && sym_sec->output_section != NULL)
8492 {
8493 value += sym_sec->output_offset;
8494 value += sym_sec->output_section->vma;
8495 value -= htab->elf.tls_sec->vma;
8496 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8497 < (bfd_vma) 1 << 32);
8498 }
8499 }
8500
8501 r_type = ELF64_R_TYPE (rel->r_info);
8502 /* If this section has old-style __tls_get_addr calls
8503 without marker relocs, then check that each
8504 __tls_get_addr call reloc is preceded by a reloc
8505 that conceivably belongs to the __tls_get_addr arg
8506 setup insn. If we don't find matching arg setup
8507 relocs, don't do any tls optimization. */
8508 if (pass == 0
8509 && sec->has_tls_get_addr_call
8510 && h != NULL
8511 && (h == &htab->tls_get_addr->elf
8512 || h == &htab->tls_get_addr_fd->elf)
8513 && !found_tls_get_addr_arg
8514 && is_branch_reloc (r_type))
8515 {
8516 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8517 "TLS optimization disabled\n"),
8518 ibfd, sec, rel->r_offset);
8519 ret = TRUE;
8520 goto err_free_rel;
8521 }
8522
8523 found_tls_get_addr_arg = 0;
8524 switch (r_type)
8525 {
8526 case R_PPC64_GOT_TLSLD16:
8527 case R_PPC64_GOT_TLSLD16_LO:
8528 expecting_tls_get_addr = 1;
8529 found_tls_get_addr_arg = 1;
8530 /* Fall through. */
8531
8532 case R_PPC64_GOT_TLSLD16_HI:
8533 case R_PPC64_GOT_TLSLD16_HA:
8534 /* These relocs should never be against a symbol
8535 defined in a shared lib. Leave them alone if
8536 that turns out to be the case. */
8537 if (!is_local)
8538 continue;
8539
8540 /* LD -> LE */
8541 tls_set = 0;
8542 tls_clear = TLS_LD;
8543 tls_type = TLS_TLS | TLS_LD;
8544 break;
8545
8546 case R_PPC64_GOT_TLSGD16:
8547 case R_PPC64_GOT_TLSGD16_LO:
8548 expecting_tls_get_addr = 1;
8549 found_tls_get_addr_arg = 1;
8550 /* Fall through. */
8551
8552 case R_PPC64_GOT_TLSGD16_HI:
8553 case R_PPC64_GOT_TLSGD16_HA:
8554 if (ok_tprel)
8555 /* GD -> LE */
8556 tls_set = 0;
8557 else
8558 /* GD -> IE */
8559 tls_set = TLS_TLS | TLS_TPRELGD;
8560 tls_clear = TLS_GD;
8561 tls_type = TLS_TLS | TLS_GD;
8562 break;
8563
8564 case R_PPC64_GOT_TPREL16_DS:
8565 case R_PPC64_GOT_TPREL16_LO_DS:
8566 case R_PPC64_GOT_TPREL16_HI:
8567 case R_PPC64_GOT_TPREL16_HA:
8568 if (ok_tprel)
8569 {
8570 /* IE -> LE */
8571 tls_set = 0;
8572 tls_clear = TLS_TPREL;
8573 tls_type = TLS_TLS | TLS_TPREL;
8574 break;
8575 }
8576 continue;
8577
8578 case R_PPC64_TLSGD:
8579 case R_PPC64_TLSLD:
8580 found_tls_get_addr_arg = 1;
8581 /* Fall through. */
8582
8583 case R_PPC64_TLS:
8584 case R_PPC64_TOC16:
8585 case R_PPC64_TOC16_LO:
8586 if (sym_sec == NULL || sym_sec != toc)
8587 continue;
8588
8589 /* Mark this toc entry as referenced by a TLS
8590 code sequence. We can do that now in the
8591 case of R_PPC64_TLS, and after checking for
8592 tls_get_addr for the TOC16 relocs. */
8593 if (toc_ref == NULL)
8594 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8595 if (toc_ref == NULL)
8596 goto err_free_rel;
8597
8598 if (h != NULL)
8599 value = h->root.u.def.value;
8600 else
8601 value = sym->st_value;
8602 value += rel->r_addend;
8603 if (value % 8 != 0)
8604 continue;
8605 BFD_ASSERT (value < toc->size
8606 && toc->output_offset % 8 == 0);
8607 toc_ref_index = (value + toc->output_offset) / 8;
8608 if (r_type == R_PPC64_TLS
8609 || r_type == R_PPC64_TLSGD
8610 || r_type == R_PPC64_TLSLD)
8611 {
8612 toc_ref[toc_ref_index] = 1;
8613 continue;
8614 }
8615
8616 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8617 continue;
8618
8619 tls_set = 0;
8620 tls_clear = 0;
8621 expecting_tls_get_addr = 2;
8622 break;
8623
8624 case R_PPC64_TPREL64:
8625 if (pass == 0
8626 || sec != toc
8627 || toc_ref == NULL
8628 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8629 continue;
8630 if (ok_tprel)
8631 {
8632 /* IE -> LE */
8633 tls_set = TLS_EXPLICIT;
8634 tls_clear = TLS_TPREL;
8635 break;
8636 }
8637 continue;
8638
8639 case R_PPC64_DTPMOD64:
8640 if (pass == 0
8641 || sec != toc
8642 || toc_ref == NULL
8643 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8644 continue;
8645 if (rel + 1 < relend
8646 && (rel[1].r_info
8647 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8648 && rel[1].r_offset == rel->r_offset + 8)
8649 {
8650 if (ok_tprel)
8651 /* GD -> LE */
8652 tls_set = TLS_EXPLICIT | TLS_GD;
8653 else
8654 /* GD -> IE */
8655 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8656 tls_clear = TLS_GD;
8657 }
8658 else
8659 {
8660 if (!is_local)
8661 continue;
8662
8663 /* LD -> LE */
8664 tls_set = TLS_EXPLICIT;
8665 tls_clear = TLS_LD;
8666 }
8667 break;
8668
8669 default:
8670 continue;
8671 }
8672
8673 if (pass == 0)
8674 {
8675 if (!expecting_tls_get_addr
8676 || !sec->has_tls_get_addr_call)
8677 continue;
8678
8679 if (rel + 1 < relend
8680 && branch_reloc_hash_match (ibfd, rel + 1,
8681 htab->tls_get_addr,
8682 htab->tls_get_addr_fd))
8683 {
8684 if (expecting_tls_get_addr == 2)
8685 {
8686 /* Check for toc tls entries. */
8687 unsigned char *toc_tls;
8688 int retval;
8689
8690 retval = get_tls_mask (&toc_tls, NULL, NULL,
8691 &locsyms,
8692 rel, ibfd);
8693 if (retval == 0)
8694 goto err_free_rel;
8695 if (toc_tls != NULL)
8696 {
8697 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8698 found_tls_get_addr_arg = 1;
8699 if (retval > 1)
8700 toc_ref[toc_ref_index] = 1;
8701 }
8702 }
8703 continue;
8704 }
8705
8706 if (expecting_tls_get_addr != 1)
8707 continue;
8708
8709 /* Uh oh, we didn't find the expected call. We
8710 could just mark this symbol to exclude it
8711 from tls optimization but it's safer to skip
8712 the entire optimization. */
8713 /* xgettext:c-format */
8714 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8715 "TLS optimization disabled\n"),
8716 ibfd, sec, rel->r_offset);
8717 ret = TRUE;
8718 goto err_free_rel;
8719 }
8720
8721 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8722 {
8723 struct plt_entry *ent;
8724 for (ent = htab->tls_get_addr->elf.plt.plist;
8725 ent != NULL;
8726 ent = ent->next)
8727 if (ent->addend == 0)
8728 {
8729 if (ent->plt.refcount > 0)
8730 {
8731 ent->plt.refcount -= 1;
8732 expecting_tls_get_addr = 0;
8733 }
8734 break;
8735 }
8736 }
8737
8738 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8739 {
8740 struct plt_entry *ent;
8741 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8742 ent != NULL;
8743 ent = ent->next)
8744 if (ent->addend == 0)
8745 {
8746 if (ent->plt.refcount > 0)
8747 ent->plt.refcount -= 1;
8748 break;
8749 }
8750 }
8751
8752 if (tls_clear == 0)
8753 continue;
8754
8755 if ((tls_set & TLS_EXPLICIT) == 0)
8756 {
8757 struct got_entry *ent;
8758
8759 /* Adjust got entry for this reloc. */
8760 if (h != NULL)
8761 ent = h->got.glist;
8762 else
8763 ent = elf_local_got_ents (ibfd)[r_symndx];
8764
8765 for (; ent != NULL; ent = ent->next)
8766 if (ent->addend == rel->r_addend
8767 && ent->owner == ibfd
8768 && ent->tls_type == tls_type)
8769 break;
8770 if (ent == NULL)
8771 abort ();
8772
8773 if (tls_set == 0)
8774 {
8775 /* We managed to get rid of a got entry. */
8776 if (ent->got.refcount > 0)
8777 ent->got.refcount -= 1;
8778 }
8779 }
8780 else
8781 {
8782 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8783 we'll lose one or two dyn relocs. */
8784 if (!dec_dynrel_count (rel->r_info, sec, info,
8785 NULL, h, sym))
8786 return FALSE;
8787
8788 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8789 {
8790 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8791 NULL, h, sym))
8792 return FALSE;
8793 }
8794 }
8795
8796 *tls_mask |= tls_set;
8797 *tls_mask &= ~tls_clear;
8798 }
8799
8800 if (elf_section_data (sec)->relocs != relstart)
8801 free (relstart);
8802 }
8803
8804 if (locsyms != NULL
8805 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8806 {
8807 if (!info->keep_memory)
8808 free (locsyms);
8809 else
8810 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8811 }
8812 }
8813
8814 if (toc_ref != NULL)
8815 free (toc_ref);
8816 return TRUE;
8817 }
8818
8819 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8820 the values of any global symbols in a toc section that has been
8821 edited. Globals in toc sections should be a rarity, so this function
8822 sets a flag if any are found in toc sections other than the one just
8823 edited, so that futher hash table traversals can be avoided. */
8824
8825 struct adjust_toc_info
8826 {
8827 asection *toc;
8828 unsigned long *skip;
8829 bfd_boolean global_toc_syms;
8830 };
8831
8832 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8833
8834 static bfd_boolean
8835 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8836 {
8837 struct ppc_link_hash_entry *eh;
8838 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8839 unsigned long i;
8840
8841 if (h->root.type != bfd_link_hash_defined
8842 && h->root.type != bfd_link_hash_defweak)
8843 return TRUE;
8844
8845 eh = (struct ppc_link_hash_entry *) h;
8846 if (eh->adjust_done)
8847 return TRUE;
8848
8849 if (eh->elf.root.u.def.section == toc_inf->toc)
8850 {
8851 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8852 i = toc_inf->toc->rawsize >> 3;
8853 else
8854 i = eh->elf.root.u.def.value >> 3;
8855
8856 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8857 {
8858 _bfd_error_handler
8859 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8860 do
8861 ++i;
8862 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8863 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8864 }
8865
8866 eh->elf.root.u.def.value -= toc_inf->skip[i];
8867 eh->adjust_done = 1;
8868 }
8869 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8870 toc_inf->global_toc_syms = TRUE;
8871
8872 return TRUE;
8873 }
8874
8875 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8876
8877 static bfd_boolean
8878 ok_lo_toc_insn (unsigned int insn)
8879 {
8880 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8881 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8882 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8883 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8884 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8885 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8886 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8887 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8888 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8889 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8890 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8891 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8892 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8893 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8894 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8895 && (insn & 3) != 1)
8896 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8897 && ((insn & 3) == 0 || (insn & 3) == 3))
8898 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8899 }
8900
8901 /* Examine all relocs referencing .toc sections in order to remove
8902 unused .toc entries. */
8903
8904 bfd_boolean
8905 ppc64_elf_edit_toc (struct bfd_link_info *info)
8906 {
8907 bfd *ibfd;
8908 struct adjust_toc_info toc_inf;
8909 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8910
8911 htab->do_toc_opt = 1;
8912 toc_inf.global_toc_syms = TRUE;
8913 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8914 {
8915 asection *toc, *sec;
8916 Elf_Internal_Shdr *symtab_hdr;
8917 Elf_Internal_Sym *local_syms;
8918 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8919 unsigned long *skip, *drop;
8920 unsigned char *used;
8921 unsigned char *keep, last, some_unused;
8922
8923 if (!is_ppc64_elf (ibfd))
8924 continue;
8925
8926 toc = bfd_get_section_by_name (ibfd, ".toc");
8927 if (toc == NULL
8928 || toc->size == 0
8929 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8930 || discarded_section (toc))
8931 continue;
8932
8933 toc_relocs = NULL;
8934 local_syms = NULL;
8935 symtab_hdr = &elf_symtab_hdr (ibfd);
8936
8937 /* Look at sections dropped from the final link. */
8938 skip = NULL;
8939 relstart = NULL;
8940 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8941 {
8942 if (sec->reloc_count == 0
8943 || !discarded_section (sec)
8944 || get_opd_info (sec)
8945 || (sec->flags & SEC_ALLOC) == 0
8946 || (sec->flags & SEC_DEBUGGING) != 0)
8947 continue;
8948
8949 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8950 if (relstart == NULL)
8951 goto error_ret;
8952
8953 /* Run through the relocs to see which toc entries might be
8954 unused. */
8955 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8956 {
8957 enum elf_ppc64_reloc_type r_type;
8958 unsigned long r_symndx;
8959 asection *sym_sec;
8960 struct elf_link_hash_entry *h;
8961 Elf_Internal_Sym *sym;
8962 bfd_vma val;
8963
8964 r_type = ELF64_R_TYPE (rel->r_info);
8965 switch (r_type)
8966 {
8967 default:
8968 continue;
8969
8970 case R_PPC64_TOC16:
8971 case R_PPC64_TOC16_LO:
8972 case R_PPC64_TOC16_HI:
8973 case R_PPC64_TOC16_HA:
8974 case R_PPC64_TOC16_DS:
8975 case R_PPC64_TOC16_LO_DS:
8976 break;
8977 }
8978
8979 r_symndx = ELF64_R_SYM (rel->r_info);
8980 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8981 r_symndx, ibfd))
8982 goto error_ret;
8983
8984 if (sym_sec != toc)
8985 continue;
8986
8987 if (h != NULL)
8988 val = h->root.u.def.value;
8989 else
8990 val = sym->st_value;
8991 val += rel->r_addend;
8992
8993 if (val >= toc->size)
8994 continue;
8995
8996 /* Anything in the toc ought to be aligned to 8 bytes.
8997 If not, don't mark as unused. */
8998 if (val & 7)
8999 continue;
9000
9001 if (skip == NULL)
9002 {
9003 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9004 if (skip == NULL)
9005 goto error_ret;
9006 }
9007
9008 skip[val >> 3] = ref_from_discarded;
9009 }
9010
9011 if (elf_section_data (sec)->relocs != relstart)
9012 free (relstart);
9013 }
9014
9015 /* For largetoc loads of address constants, we can convert
9016 . addis rx,2,addr@got@ha
9017 . ld ry,addr@got@l(rx)
9018 to
9019 . addis rx,2,addr@toc@ha
9020 . addi ry,rx,addr@toc@l
9021 when addr is within 2G of the toc pointer. This then means
9022 that the word storing "addr" in the toc is no longer needed. */
9023
9024 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9025 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9026 && toc->reloc_count != 0)
9027 {
9028 /* Read toc relocs. */
9029 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9030 info->keep_memory);
9031 if (toc_relocs == NULL)
9032 goto error_ret;
9033
9034 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9035 {
9036 enum elf_ppc64_reloc_type r_type;
9037 unsigned long r_symndx;
9038 asection *sym_sec;
9039 struct elf_link_hash_entry *h;
9040 Elf_Internal_Sym *sym;
9041 bfd_vma val, addr;
9042
9043 r_type = ELF64_R_TYPE (rel->r_info);
9044 if (r_type != R_PPC64_ADDR64)
9045 continue;
9046
9047 r_symndx = ELF64_R_SYM (rel->r_info);
9048 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9049 r_symndx, ibfd))
9050 goto error_ret;
9051
9052 if (sym_sec == NULL
9053 || sym_sec->output_section == NULL
9054 || discarded_section (sym_sec))
9055 continue;
9056
9057 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9058 continue;
9059
9060 if (h != NULL)
9061 {
9062 if (h->type == STT_GNU_IFUNC)
9063 continue;
9064 val = h->root.u.def.value;
9065 }
9066 else
9067 {
9068 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9069 continue;
9070 val = sym->st_value;
9071 }
9072 val += rel->r_addend;
9073 val += sym_sec->output_section->vma + sym_sec->output_offset;
9074
9075 /* We don't yet know the exact toc pointer value, but we
9076 know it will be somewhere in the toc section. Don't
9077 optimize if the difference from any possible toc
9078 pointer is outside [ff..f80008000, 7fff7fff]. */
9079 addr = toc->output_section->vma + TOC_BASE_OFF;
9080 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9081 continue;
9082
9083 addr = toc->output_section->vma + toc->output_section->rawsize;
9084 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9085 continue;
9086
9087 if (skip == NULL)
9088 {
9089 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9090 if (skip == NULL)
9091 goto error_ret;
9092 }
9093
9094 skip[rel->r_offset >> 3]
9095 |= can_optimize | ((rel - toc_relocs) << 2);
9096 }
9097 }
9098
9099 if (skip == NULL)
9100 continue;
9101
9102 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9103 if (used == NULL)
9104 {
9105 error_ret:
9106 if (local_syms != NULL
9107 && symtab_hdr->contents != (unsigned char *) local_syms)
9108 free (local_syms);
9109 if (sec != NULL
9110 && relstart != NULL
9111 && elf_section_data (sec)->relocs != relstart)
9112 free (relstart);
9113 if (toc_relocs != NULL
9114 && elf_section_data (toc)->relocs != toc_relocs)
9115 free (toc_relocs);
9116 if (skip != NULL)
9117 free (skip);
9118 return FALSE;
9119 }
9120
9121 /* Now check all kept sections that might reference the toc.
9122 Check the toc itself last. */
9123 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9124 : ibfd->sections);
9125 sec != NULL;
9126 sec = (sec == toc ? NULL
9127 : sec->next == NULL ? toc
9128 : sec->next == toc && toc->next ? toc->next
9129 : sec->next))
9130 {
9131 int repeat;
9132
9133 if (sec->reloc_count == 0
9134 || discarded_section (sec)
9135 || get_opd_info (sec)
9136 || (sec->flags & SEC_ALLOC) == 0
9137 || (sec->flags & SEC_DEBUGGING) != 0)
9138 continue;
9139
9140 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9141 info->keep_memory);
9142 if (relstart == NULL)
9143 {
9144 free (used);
9145 goto error_ret;
9146 }
9147
9148 /* Mark toc entries referenced as used. */
9149 do
9150 {
9151 repeat = 0;
9152 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9153 {
9154 enum elf_ppc64_reloc_type r_type;
9155 unsigned long r_symndx;
9156 asection *sym_sec;
9157 struct elf_link_hash_entry *h;
9158 Elf_Internal_Sym *sym;
9159 bfd_vma val;
9160 enum {no_check, check_lo, check_ha} insn_check;
9161
9162 r_type = ELF64_R_TYPE (rel->r_info);
9163 switch (r_type)
9164 {
9165 default:
9166 insn_check = no_check;
9167 break;
9168
9169 case R_PPC64_GOT_TLSLD16_HA:
9170 case R_PPC64_GOT_TLSGD16_HA:
9171 case R_PPC64_GOT_TPREL16_HA:
9172 case R_PPC64_GOT_DTPREL16_HA:
9173 case R_PPC64_GOT16_HA:
9174 case R_PPC64_TOC16_HA:
9175 insn_check = check_ha;
9176 break;
9177
9178 case R_PPC64_GOT_TLSLD16_LO:
9179 case R_PPC64_GOT_TLSGD16_LO:
9180 case R_PPC64_GOT_TPREL16_LO_DS:
9181 case R_PPC64_GOT_DTPREL16_LO_DS:
9182 case R_PPC64_GOT16_LO:
9183 case R_PPC64_GOT16_LO_DS:
9184 case R_PPC64_TOC16_LO:
9185 case R_PPC64_TOC16_LO_DS:
9186 insn_check = check_lo;
9187 break;
9188 }
9189
9190 if (insn_check != no_check)
9191 {
9192 bfd_vma off = rel->r_offset & ~3;
9193 unsigned char buf[4];
9194 unsigned int insn;
9195
9196 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9197 {
9198 free (used);
9199 goto error_ret;
9200 }
9201 insn = bfd_get_32 (ibfd, buf);
9202 if (insn_check == check_lo
9203 ? !ok_lo_toc_insn (insn)
9204 : ((insn & ((0x3f << 26) | 0x1f << 16))
9205 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9206 {
9207 char str[12];
9208
9209 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9210 sprintf (str, "%#08x", insn);
9211 info->callbacks->einfo
9212 /* xgettext:c-format */
9213 (_("%P: %H: toc optimization is not supported for"
9214 " %s instruction.\n"),
9215 ibfd, sec, rel->r_offset & ~3, str);
9216 }
9217 }
9218
9219 switch (r_type)
9220 {
9221 case R_PPC64_TOC16:
9222 case R_PPC64_TOC16_LO:
9223 case R_PPC64_TOC16_HI:
9224 case R_PPC64_TOC16_HA:
9225 case R_PPC64_TOC16_DS:
9226 case R_PPC64_TOC16_LO_DS:
9227 /* In case we're taking addresses of toc entries. */
9228 case R_PPC64_ADDR64:
9229 break;
9230
9231 default:
9232 continue;
9233 }
9234
9235 r_symndx = ELF64_R_SYM (rel->r_info);
9236 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9237 r_symndx, ibfd))
9238 {
9239 free (used);
9240 goto error_ret;
9241 }
9242
9243 if (sym_sec != toc)
9244 continue;
9245
9246 if (h != NULL)
9247 val = h->root.u.def.value;
9248 else
9249 val = sym->st_value;
9250 val += rel->r_addend;
9251
9252 if (val >= toc->size)
9253 continue;
9254
9255 if ((skip[val >> 3] & can_optimize) != 0)
9256 {
9257 bfd_vma off;
9258 unsigned char opc;
9259
9260 switch (r_type)
9261 {
9262 case R_PPC64_TOC16_HA:
9263 break;
9264
9265 case R_PPC64_TOC16_LO_DS:
9266 off = rel->r_offset;
9267 off += (bfd_big_endian (ibfd) ? -2 : 3);
9268 if (!bfd_get_section_contents (ibfd, sec, &opc,
9269 off, 1))
9270 {
9271 free (used);
9272 goto error_ret;
9273 }
9274 if ((opc & (0x3f << 2)) == (58u << 2))
9275 break;
9276 /* Fall through. */
9277
9278 default:
9279 /* Wrong sort of reloc, or not a ld. We may
9280 as well clear ref_from_discarded too. */
9281 skip[val >> 3] = 0;
9282 }
9283 }
9284
9285 if (sec != toc)
9286 used[val >> 3] = 1;
9287 /* For the toc section, we only mark as used if this
9288 entry itself isn't unused. */
9289 else if ((used[rel->r_offset >> 3]
9290 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9291 && !used[val >> 3])
9292 {
9293 /* Do all the relocs again, to catch reference
9294 chains. */
9295 repeat = 1;
9296 used[val >> 3] = 1;
9297 }
9298 }
9299 }
9300 while (repeat);
9301
9302 if (elf_section_data (sec)->relocs != relstart)
9303 free (relstart);
9304 }
9305
9306 /* Merge the used and skip arrays. Assume that TOC
9307 doublewords not appearing as either used or unused belong
9308 to to an entry more than one doubleword in size. */
9309 for (drop = skip, keep = used, last = 0, some_unused = 0;
9310 drop < skip + (toc->size + 7) / 8;
9311 ++drop, ++keep)
9312 {
9313 if (*keep)
9314 {
9315 *drop &= ~ref_from_discarded;
9316 if ((*drop & can_optimize) != 0)
9317 some_unused = 1;
9318 last = 0;
9319 }
9320 else if ((*drop & ref_from_discarded) != 0)
9321 {
9322 some_unused = 1;
9323 last = ref_from_discarded;
9324 }
9325 else
9326 *drop = last;
9327 }
9328
9329 free (used);
9330
9331 if (some_unused)
9332 {
9333 bfd_byte *contents, *src;
9334 unsigned long off;
9335 Elf_Internal_Sym *sym;
9336 bfd_boolean local_toc_syms = FALSE;
9337
9338 /* Shuffle the toc contents, and at the same time convert the
9339 skip array from booleans into offsets. */
9340 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9341 goto error_ret;
9342
9343 elf_section_data (toc)->this_hdr.contents = contents;
9344
9345 for (src = contents, off = 0, drop = skip;
9346 src < contents + toc->size;
9347 src += 8, ++drop)
9348 {
9349 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9350 off += 8;
9351 else if (off != 0)
9352 {
9353 *drop = off;
9354 memcpy (src - off, src, 8);
9355 }
9356 }
9357 *drop = off;
9358 toc->rawsize = toc->size;
9359 toc->size = src - contents - off;
9360
9361 /* Adjust addends for relocs against the toc section sym,
9362 and optimize any accesses we can. */
9363 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9364 {
9365 if (sec->reloc_count == 0
9366 || discarded_section (sec))
9367 continue;
9368
9369 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9370 info->keep_memory);
9371 if (relstart == NULL)
9372 goto error_ret;
9373
9374 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9375 {
9376 enum elf_ppc64_reloc_type r_type;
9377 unsigned long r_symndx;
9378 asection *sym_sec;
9379 struct elf_link_hash_entry *h;
9380 bfd_vma val;
9381
9382 r_type = ELF64_R_TYPE (rel->r_info);
9383 switch (r_type)
9384 {
9385 default:
9386 continue;
9387
9388 case R_PPC64_TOC16:
9389 case R_PPC64_TOC16_LO:
9390 case R_PPC64_TOC16_HI:
9391 case R_PPC64_TOC16_HA:
9392 case R_PPC64_TOC16_DS:
9393 case R_PPC64_TOC16_LO_DS:
9394 case R_PPC64_ADDR64:
9395 break;
9396 }
9397
9398 r_symndx = ELF64_R_SYM (rel->r_info);
9399 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9400 r_symndx, ibfd))
9401 goto error_ret;
9402
9403 if (sym_sec != toc)
9404 continue;
9405
9406 if (h != NULL)
9407 val = h->root.u.def.value;
9408 else
9409 {
9410 val = sym->st_value;
9411 if (val != 0)
9412 local_toc_syms = TRUE;
9413 }
9414
9415 val += rel->r_addend;
9416
9417 if (val > toc->rawsize)
9418 val = toc->rawsize;
9419 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9420 continue;
9421 else if ((skip[val >> 3] & can_optimize) != 0)
9422 {
9423 Elf_Internal_Rela *tocrel
9424 = toc_relocs + (skip[val >> 3] >> 2);
9425 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9426
9427 switch (r_type)
9428 {
9429 case R_PPC64_TOC16_HA:
9430 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9431 break;
9432
9433 case R_PPC64_TOC16_LO_DS:
9434 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9435 break;
9436
9437 default:
9438 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9439 ppc_howto_init ();
9440 info->callbacks->einfo
9441 /* xgettext:c-format */
9442 (_("%P: %H: %s references "
9443 "optimized away TOC entry\n"),
9444 ibfd, sec, rel->r_offset,
9445 ppc64_elf_howto_table[r_type]->name);
9446 bfd_set_error (bfd_error_bad_value);
9447 goto error_ret;
9448 }
9449 rel->r_addend = tocrel->r_addend;
9450 elf_section_data (sec)->relocs = relstart;
9451 continue;
9452 }
9453
9454 if (h != NULL || sym->st_value != 0)
9455 continue;
9456
9457 rel->r_addend -= skip[val >> 3];
9458 elf_section_data (sec)->relocs = relstart;
9459 }
9460
9461 if (elf_section_data (sec)->relocs != relstart)
9462 free (relstart);
9463 }
9464
9465 /* We shouldn't have local or global symbols defined in the TOC,
9466 but handle them anyway. */
9467 if (local_syms != NULL)
9468 for (sym = local_syms;
9469 sym < local_syms + symtab_hdr->sh_info;
9470 ++sym)
9471 if (sym->st_value != 0
9472 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9473 {
9474 unsigned long i;
9475
9476 if (sym->st_value > toc->rawsize)
9477 i = toc->rawsize >> 3;
9478 else
9479 i = sym->st_value >> 3;
9480
9481 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9482 {
9483 if (local_toc_syms)
9484 _bfd_error_handler
9485 (_("%s defined on removed toc entry"),
9486 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9487 do
9488 ++i;
9489 while ((skip[i] & (ref_from_discarded | can_optimize)));
9490 sym->st_value = (bfd_vma) i << 3;
9491 }
9492
9493 sym->st_value -= skip[i];
9494 symtab_hdr->contents = (unsigned char *) local_syms;
9495 }
9496
9497 /* Adjust any global syms defined in this toc input section. */
9498 if (toc_inf.global_toc_syms)
9499 {
9500 toc_inf.toc = toc;
9501 toc_inf.skip = skip;
9502 toc_inf.global_toc_syms = FALSE;
9503 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9504 &toc_inf);
9505 }
9506
9507 if (toc->reloc_count != 0)
9508 {
9509 Elf_Internal_Shdr *rel_hdr;
9510 Elf_Internal_Rela *wrel;
9511 bfd_size_type sz;
9512
9513 /* Remove unused toc relocs, and adjust those we keep. */
9514 if (toc_relocs == NULL)
9515 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9516 info->keep_memory);
9517 if (toc_relocs == NULL)
9518 goto error_ret;
9519
9520 wrel = toc_relocs;
9521 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9522 if ((skip[rel->r_offset >> 3]
9523 & (ref_from_discarded | can_optimize)) == 0)
9524 {
9525 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9526 wrel->r_info = rel->r_info;
9527 wrel->r_addend = rel->r_addend;
9528 ++wrel;
9529 }
9530 else if (!dec_dynrel_count (rel->r_info, toc, info,
9531 &local_syms, NULL, NULL))
9532 goto error_ret;
9533
9534 elf_section_data (toc)->relocs = toc_relocs;
9535 toc->reloc_count = wrel - toc_relocs;
9536 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9537 sz = rel_hdr->sh_entsize;
9538 rel_hdr->sh_size = toc->reloc_count * sz;
9539 }
9540 }
9541 else if (toc_relocs != NULL
9542 && elf_section_data (toc)->relocs != toc_relocs)
9543 free (toc_relocs);
9544
9545 if (local_syms != NULL
9546 && symtab_hdr->contents != (unsigned char *) local_syms)
9547 {
9548 if (!info->keep_memory)
9549 free (local_syms);
9550 else
9551 symtab_hdr->contents = (unsigned char *) local_syms;
9552 }
9553 free (skip);
9554 }
9555
9556 return TRUE;
9557 }
9558
9559 /* Return true iff input section I references the TOC using
9560 instructions limited to +/-32k offsets. */
9561
9562 bfd_boolean
9563 ppc64_elf_has_small_toc_reloc (asection *i)
9564 {
9565 return (is_ppc64_elf (i->owner)
9566 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9567 }
9568
9569 /* Allocate space for one GOT entry. */
9570
9571 static void
9572 allocate_got (struct elf_link_hash_entry *h,
9573 struct bfd_link_info *info,
9574 struct got_entry *gent)
9575 {
9576 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9577 bfd_boolean dyn;
9578 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9579 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9580 ? 16 : 8);
9581 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9582 ? 2 : 1) * sizeof (Elf64_External_Rela);
9583 asection *got = ppc64_elf_tdata (gent->owner)->got;
9584
9585 gent->got.offset = got->size;
9586 got->size += entsize;
9587
9588 dyn = htab->elf.dynamic_sections_created;
9589 if (h->type == STT_GNU_IFUNC)
9590 {
9591 htab->elf.irelplt->size += rentsize;
9592 htab->got_reli_size += rentsize;
9593 }
9594 else if ((bfd_link_pic (info)
9595 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9596 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9597 || h->root.type != bfd_link_hash_undefweak))
9598 {
9599 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9600 relgot->size += rentsize;
9601 }
9602 }
9603
9604 /* This function merges got entries in the same toc group. */
9605
9606 static void
9607 merge_got_entries (struct got_entry **pent)
9608 {
9609 struct got_entry *ent, *ent2;
9610
9611 for (ent = *pent; ent != NULL; ent = ent->next)
9612 if (!ent->is_indirect)
9613 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9614 if (!ent2->is_indirect
9615 && ent2->addend == ent->addend
9616 && ent2->tls_type == ent->tls_type
9617 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9618 {
9619 ent2->is_indirect = TRUE;
9620 ent2->got.ent = ent;
9621 }
9622 }
9623
9624 /* Allocate space in .plt, .got and associated reloc sections for
9625 dynamic relocs. */
9626
9627 static bfd_boolean
9628 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9629 {
9630 struct bfd_link_info *info;
9631 struct ppc_link_hash_table *htab;
9632 asection *s;
9633 struct ppc_link_hash_entry *eh;
9634 struct got_entry **pgent, *gent;
9635
9636 if (h->root.type == bfd_link_hash_indirect)
9637 return TRUE;
9638
9639 info = (struct bfd_link_info *) inf;
9640 htab = ppc_hash_table (info);
9641 if (htab == NULL)
9642 return FALSE;
9643
9644 eh = (struct ppc_link_hash_entry *) h;
9645 /* Run through the TLS GD got entries first if we're changing them
9646 to TPREL. */
9647 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9648 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9649 if (gent->got.refcount > 0
9650 && (gent->tls_type & TLS_GD) != 0)
9651 {
9652 /* This was a GD entry that has been converted to TPREL. If
9653 there happens to be a TPREL entry we can use that one. */
9654 struct got_entry *ent;
9655 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9656 if (ent->got.refcount > 0
9657 && (ent->tls_type & TLS_TPREL) != 0
9658 && ent->addend == gent->addend
9659 && ent->owner == gent->owner)
9660 {
9661 gent->got.refcount = 0;
9662 break;
9663 }
9664
9665 /* If not, then we'll be using our own TPREL entry. */
9666 if (gent->got.refcount != 0)
9667 gent->tls_type = TLS_TLS | TLS_TPREL;
9668 }
9669
9670 /* Remove any list entry that won't generate a word in the GOT before
9671 we call merge_got_entries. Otherwise we risk merging to empty
9672 entries. */
9673 pgent = &h->got.glist;
9674 while ((gent = *pgent) != NULL)
9675 if (gent->got.refcount > 0)
9676 {
9677 if ((gent->tls_type & TLS_LD) != 0
9678 && !h->def_dynamic)
9679 {
9680 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9681 *pgent = gent->next;
9682 }
9683 else
9684 pgent = &gent->next;
9685 }
9686 else
9687 *pgent = gent->next;
9688
9689 if (!htab->do_multi_toc)
9690 merge_got_entries (&h->got.glist);
9691
9692 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9693 if (!gent->is_indirect)
9694 {
9695 /* Make sure this symbol is output as a dynamic symbol.
9696 Undefined weak syms won't yet be marked as dynamic,
9697 nor will all TLS symbols. */
9698 if (h->dynindx == -1
9699 && !h->forced_local
9700 && h->type != STT_GNU_IFUNC
9701 && htab->elf.dynamic_sections_created)
9702 {
9703 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9704 return FALSE;
9705 }
9706
9707 if (!is_ppc64_elf (gent->owner))
9708 abort ();
9709
9710 allocate_got (h, info, gent);
9711 }
9712
9713 if (!htab->elf.dynamic_sections_created
9714 && h->type != STT_GNU_IFUNC)
9715 eh->dyn_relocs = NULL;
9716
9717 if (eh->dyn_relocs != NULL)
9718 {
9719 struct elf_dyn_relocs *p, **pp;
9720
9721 /* In the shared -Bsymbolic case, discard space allocated for
9722 dynamic pc-relative relocs against symbols which turn out to
9723 be defined in regular objects. For the normal shared case,
9724 discard space for relocs that have become local due to symbol
9725 visibility changes. */
9726
9727 if (bfd_link_pic (info))
9728 {
9729 /* Relocs that use pc_count are those that appear on a call
9730 insn, or certain REL relocs (see must_be_dyn_reloc) that
9731 can be generated via assembly. We want calls to
9732 protected symbols to resolve directly to the function
9733 rather than going via the plt. If people want function
9734 pointer comparisons to work as expected then they should
9735 avoid writing weird assembly. */
9736 if (SYMBOL_CALLS_LOCAL (info, h))
9737 {
9738 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9739 {
9740 p->count -= p->pc_count;
9741 p->pc_count = 0;
9742 if (p->count == 0)
9743 *pp = p->next;
9744 else
9745 pp = &p->next;
9746 }
9747 }
9748
9749 /* Also discard relocs on undefined weak syms with
9750 non-default visibility. */
9751 if (eh->dyn_relocs != NULL
9752 && h->root.type == bfd_link_hash_undefweak)
9753 {
9754 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9755 eh->dyn_relocs = NULL;
9756
9757 /* Make sure this symbol is output as a dynamic symbol.
9758 Undefined weak syms won't yet be marked as dynamic. */
9759 else if (h->dynindx == -1
9760 && !h->forced_local)
9761 {
9762 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9763 return FALSE;
9764 }
9765 }
9766 }
9767 else if (h->type == STT_GNU_IFUNC)
9768 {
9769 /* A plt entry is always created when making direct calls to
9770 an ifunc, even when building a static executable, but
9771 that doesn't cover all cases. We may have only an ifunc
9772 initialised function pointer for a given ifunc symbol.
9773
9774 For ELFv2, dynamic relocations are not required when
9775 generating a global entry PLT stub. */
9776 if (abiversion (info->output_bfd) >= 2)
9777 {
9778 if (global_entry_stub (h))
9779 eh->dyn_relocs = NULL;
9780 }
9781
9782 /* For ELFv1 we have function descriptors. Descriptors need
9783 to be treated like PLT entries and thus have dynamic
9784 relocations. One exception is when the function
9785 descriptor is copied into .dynbss (which should only
9786 happen with ancient versions of gcc). */
9787 else if (h->needs_copy)
9788 eh->dyn_relocs = NULL;
9789 }
9790 else if (ELIMINATE_COPY_RELOCS)
9791 {
9792 /* For the non-pic case, discard space for relocs against
9793 symbols which turn out to need copy relocs or are not
9794 dynamic. */
9795
9796 /* First make sure this symbol is output as a dynamic symbol.
9797 Undefined weak syms won't yet be marked as dynamic. */
9798 if (h->root.type == bfd_link_hash_undefweak
9799 && !h->non_got_ref
9800 && !h->def_regular
9801 && h->dynindx == -1
9802 && !h->forced_local
9803 && !bfd_elf_link_record_dynamic_symbol (info, h))
9804 return FALSE;
9805
9806 if (h->non_got_ref
9807 || h->def_regular
9808 || h->dynindx == -1)
9809 eh->dyn_relocs = NULL;
9810 }
9811
9812 /* Finally, allocate space. */
9813 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9814 {
9815 asection *sreloc = elf_section_data (p->sec)->sreloc;
9816 if (eh->elf.type == STT_GNU_IFUNC)
9817 sreloc = htab->elf.irelplt;
9818 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9819 }
9820 }
9821
9822 if ((htab->elf.dynamic_sections_created
9823 && h->dynindx != -1
9824 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9825 || h->type == STT_GNU_IFUNC)
9826 {
9827 struct plt_entry *pent;
9828 bfd_boolean doneone = FALSE;
9829 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9830 if (pent->plt.refcount > 0)
9831 {
9832 if (!htab->elf.dynamic_sections_created
9833 || h->dynindx == -1)
9834 {
9835 s = htab->elf.iplt;
9836 pent->plt.offset = s->size;
9837 s->size += PLT_ENTRY_SIZE (htab);
9838 s = htab->elf.irelplt;
9839 }
9840 else
9841 {
9842 /* If this is the first .plt entry, make room for the special
9843 first entry. */
9844 s = htab->elf.splt;
9845 if (s->size == 0)
9846 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9847
9848 pent->plt.offset = s->size;
9849
9850 /* Make room for this entry. */
9851 s->size += PLT_ENTRY_SIZE (htab);
9852
9853 /* Make room for the .glink code. */
9854 s = htab->glink;
9855 if (s->size == 0)
9856 s->size += GLINK_CALL_STUB_SIZE;
9857 if (htab->opd_abi)
9858 {
9859 /* We need bigger stubs past index 32767. */
9860 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9861 s->size += 4;
9862 s->size += 2*4;
9863 }
9864 else
9865 s->size += 4;
9866
9867 /* We also need to make an entry in the .rela.plt section. */
9868 s = htab->elf.srelplt;
9869 }
9870 s->size += sizeof (Elf64_External_Rela);
9871 doneone = TRUE;
9872 }
9873 else
9874 pent->plt.offset = (bfd_vma) -1;
9875 if (!doneone)
9876 {
9877 h->plt.plist = NULL;
9878 h->needs_plt = 0;
9879 }
9880 }
9881 else
9882 {
9883 h->plt.plist = NULL;
9884 h->needs_plt = 0;
9885 }
9886
9887 return TRUE;
9888 }
9889
9890 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9891 to set up space for global entry stubs. These are put in glink,
9892 after the branch table. */
9893
9894 static bfd_boolean
9895 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9896 {
9897 struct bfd_link_info *info;
9898 struct ppc_link_hash_table *htab;
9899 struct plt_entry *pent;
9900 asection *s;
9901
9902 if (h->root.type == bfd_link_hash_indirect)
9903 return TRUE;
9904
9905 if (!h->pointer_equality_needed)
9906 return TRUE;
9907
9908 if (h->def_regular)
9909 return TRUE;
9910
9911 info = inf;
9912 htab = ppc_hash_table (info);
9913 if (htab == NULL)
9914 return FALSE;
9915
9916 s = htab->glink;
9917 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9918 if (pent->plt.offset != (bfd_vma) -1
9919 && pent->addend == 0)
9920 {
9921 /* For ELFv2, if this symbol is not defined in a regular file
9922 and we are not generating a shared library or pie, then we
9923 need to define the symbol in the executable on a call stub.
9924 This is to avoid text relocations. */
9925 s->size = (s->size + 15) & -16;
9926 h->root.type = bfd_link_hash_defined;
9927 h->root.u.def.section = s;
9928 h->root.u.def.value = s->size;
9929 s->size += 16;
9930 break;
9931 }
9932 return TRUE;
9933 }
9934
9935 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9936 read-only sections. */
9937
9938 static bfd_boolean
9939 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9940 {
9941 if (h->root.type == bfd_link_hash_indirect)
9942 return TRUE;
9943
9944 if (readonly_dynrelocs (h))
9945 {
9946 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9947
9948 /* Not an error, just cut short the traversal. */
9949 return FALSE;
9950 }
9951 return TRUE;
9952 }
9953
9954 /* Set the sizes of the dynamic sections. */
9955
9956 static bfd_boolean
9957 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9958 struct bfd_link_info *info)
9959 {
9960 struct ppc_link_hash_table *htab;
9961 bfd *dynobj;
9962 asection *s;
9963 bfd_boolean relocs;
9964 bfd *ibfd;
9965 struct got_entry *first_tlsld;
9966
9967 htab = ppc_hash_table (info);
9968 if (htab == NULL)
9969 return FALSE;
9970
9971 dynobj = htab->elf.dynobj;
9972 if (dynobj == NULL)
9973 abort ();
9974
9975 if (htab->elf.dynamic_sections_created)
9976 {
9977 /* Set the contents of the .interp section to the interpreter. */
9978 if (bfd_link_executable (info) && !info->nointerp)
9979 {
9980 s = bfd_get_linker_section (dynobj, ".interp");
9981 if (s == NULL)
9982 abort ();
9983 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9984 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9985 }
9986 }
9987
9988 /* Set up .got offsets for local syms, and space for local dynamic
9989 relocs. */
9990 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9991 {
9992 struct got_entry **lgot_ents;
9993 struct got_entry **end_lgot_ents;
9994 struct plt_entry **local_plt;
9995 struct plt_entry **end_local_plt;
9996 unsigned char *lgot_masks;
9997 bfd_size_type locsymcount;
9998 Elf_Internal_Shdr *symtab_hdr;
9999
10000 if (!is_ppc64_elf (ibfd))
10001 continue;
10002
10003 for (s = ibfd->sections; s != NULL; s = s->next)
10004 {
10005 struct ppc_dyn_relocs *p;
10006
10007 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10008 {
10009 if (!bfd_is_abs_section (p->sec)
10010 && bfd_is_abs_section (p->sec->output_section))
10011 {
10012 /* Input section has been discarded, either because
10013 it is a copy of a linkonce section or due to
10014 linker script /DISCARD/, so we'll be discarding
10015 the relocs too. */
10016 }
10017 else if (p->count != 0)
10018 {
10019 asection *srel = elf_section_data (p->sec)->sreloc;
10020 if (p->ifunc)
10021 srel = htab->elf.irelplt;
10022 srel->size += p->count * sizeof (Elf64_External_Rela);
10023 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10024 info->flags |= DF_TEXTREL;
10025 }
10026 }
10027 }
10028
10029 lgot_ents = elf_local_got_ents (ibfd);
10030 if (!lgot_ents)
10031 continue;
10032
10033 symtab_hdr = &elf_symtab_hdr (ibfd);
10034 locsymcount = symtab_hdr->sh_info;
10035 end_lgot_ents = lgot_ents + locsymcount;
10036 local_plt = (struct plt_entry **) end_lgot_ents;
10037 end_local_plt = local_plt + locsymcount;
10038 lgot_masks = (unsigned char *) end_local_plt;
10039 s = ppc64_elf_tdata (ibfd)->got;
10040 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10041 {
10042 struct got_entry **pent, *ent;
10043
10044 pent = lgot_ents;
10045 while ((ent = *pent) != NULL)
10046 if (ent->got.refcount > 0)
10047 {
10048 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10049 {
10050 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10051 *pent = ent->next;
10052 }
10053 else
10054 {
10055 unsigned int ent_size = 8;
10056 unsigned int rel_size = sizeof (Elf64_External_Rela);
10057
10058 ent->got.offset = s->size;
10059 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10060 {
10061 ent_size *= 2;
10062 rel_size *= 2;
10063 }
10064 s->size += ent_size;
10065 if ((*lgot_masks & PLT_IFUNC) != 0)
10066 {
10067 htab->elf.irelplt->size += rel_size;
10068 htab->got_reli_size += rel_size;
10069 }
10070 else if (bfd_link_pic (info))
10071 {
10072 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10073 srel->size += rel_size;
10074 }
10075 pent = &ent->next;
10076 }
10077 }
10078 else
10079 *pent = ent->next;
10080 }
10081
10082 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10083 for (; local_plt < end_local_plt; ++local_plt)
10084 {
10085 struct plt_entry *ent;
10086
10087 for (ent = *local_plt; ent != NULL; ent = ent->next)
10088 if (ent->plt.refcount > 0)
10089 {
10090 s = htab->elf.iplt;
10091 ent->plt.offset = s->size;
10092 s->size += PLT_ENTRY_SIZE (htab);
10093
10094 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10095 }
10096 else
10097 ent->plt.offset = (bfd_vma) -1;
10098 }
10099 }
10100
10101 /* Allocate global sym .plt and .got entries, and space for global
10102 sym dynamic relocs. */
10103 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10104 /* Stash the end of glink branch table. */
10105 if (htab->glink != NULL)
10106 htab->glink->rawsize = htab->glink->size;
10107
10108 if (!htab->opd_abi && !bfd_link_pic (info))
10109 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10110
10111 first_tlsld = NULL;
10112 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10113 {
10114 struct got_entry *ent;
10115
10116 if (!is_ppc64_elf (ibfd))
10117 continue;
10118
10119 ent = ppc64_tlsld_got (ibfd);
10120 if (ent->got.refcount > 0)
10121 {
10122 if (!htab->do_multi_toc && first_tlsld != NULL)
10123 {
10124 ent->is_indirect = TRUE;
10125 ent->got.ent = first_tlsld;
10126 }
10127 else
10128 {
10129 if (first_tlsld == NULL)
10130 first_tlsld = ent;
10131 s = ppc64_elf_tdata (ibfd)->got;
10132 ent->got.offset = s->size;
10133 ent->owner = ibfd;
10134 s->size += 16;
10135 if (bfd_link_pic (info))
10136 {
10137 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10138 srel->size += sizeof (Elf64_External_Rela);
10139 }
10140 }
10141 }
10142 else
10143 ent->got.offset = (bfd_vma) -1;
10144 }
10145
10146 /* We now have determined the sizes of the various dynamic sections.
10147 Allocate memory for them. */
10148 relocs = FALSE;
10149 for (s = dynobj->sections; s != NULL; s = s->next)
10150 {
10151 if ((s->flags & SEC_LINKER_CREATED) == 0)
10152 continue;
10153
10154 if (s == htab->brlt || s == htab->relbrlt)
10155 /* These haven't been allocated yet; don't strip. */
10156 continue;
10157 else if (s == htab->elf.sgot
10158 || s == htab->elf.splt
10159 || s == htab->elf.iplt
10160 || s == htab->glink
10161 || s == htab->dynbss)
10162 {
10163 /* Strip this section if we don't need it; see the
10164 comment below. */
10165 }
10166 else if (s == htab->glink_eh_frame)
10167 {
10168 if (!bfd_is_abs_section (s->output_section))
10169 /* Not sized yet. */
10170 continue;
10171 }
10172 else if (CONST_STRNEQ (s->name, ".rela"))
10173 {
10174 if (s->size != 0)
10175 {
10176 if (s != htab->elf.srelplt)
10177 relocs = TRUE;
10178
10179 /* We use the reloc_count field as a counter if we need
10180 to copy relocs into the output file. */
10181 s->reloc_count = 0;
10182 }
10183 }
10184 else
10185 {
10186 /* It's not one of our sections, so don't allocate space. */
10187 continue;
10188 }
10189
10190 if (s->size == 0)
10191 {
10192 /* If we don't need this section, strip it from the
10193 output file. This is mostly to handle .rela.bss and
10194 .rela.plt. We must create both sections in
10195 create_dynamic_sections, because they must be created
10196 before the linker maps input sections to output
10197 sections. The linker does that before
10198 adjust_dynamic_symbol is called, and it is that
10199 function which decides whether anything needs to go
10200 into these sections. */
10201 s->flags |= SEC_EXCLUDE;
10202 continue;
10203 }
10204
10205 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10206 continue;
10207
10208 /* Allocate memory for the section contents. We use bfd_zalloc
10209 here in case unused entries are not reclaimed before the
10210 section's contents are written out. This should not happen,
10211 but this way if it does we get a R_PPC64_NONE reloc in .rela
10212 sections instead of garbage.
10213 We also rely on the section contents being zero when writing
10214 the GOT. */
10215 s->contents = bfd_zalloc (dynobj, s->size);
10216 if (s->contents == NULL)
10217 return FALSE;
10218 }
10219
10220 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10221 {
10222 if (!is_ppc64_elf (ibfd))
10223 continue;
10224
10225 s = ppc64_elf_tdata (ibfd)->got;
10226 if (s != NULL && s != htab->elf.sgot)
10227 {
10228 if (s->size == 0)
10229 s->flags |= SEC_EXCLUDE;
10230 else
10231 {
10232 s->contents = bfd_zalloc (ibfd, s->size);
10233 if (s->contents == NULL)
10234 return FALSE;
10235 }
10236 }
10237 s = ppc64_elf_tdata (ibfd)->relgot;
10238 if (s != NULL)
10239 {
10240 if (s->size == 0)
10241 s->flags |= SEC_EXCLUDE;
10242 else
10243 {
10244 s->contents = bfd_zalloc (ibfd, s->size);
10245 if (s->contents == NULL)
10246 return FALSE;
10247 relocs = TRUE;
10248 s->reloc_count = 0;
10249 }
10250 }
10251 }
10252
10253 if (htab->elf.dynamic_sections_created)
10254 {
10255 bfd_boolean tls_opt;
10256
10257 /* Add some entries to the .dynamic section. We fill in the
10258 values later, in ppc64_elf_finish_dynamic_sections, but we
10259 must add the entries now so that we get the correct size for
10260 the .dynamic section. The DT_DEBUG entry is filled in by the
10261 dynamic linker and used by the debugger. */
10262 #define add_dynamic_entry(TAG, VAL) \
10263 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10264
10265 if (bfd_link_executable (info))
10266 {
10267 if (!add_dynamic_entry (DT_DEBUG, 0))
10268 return FALSE;
10269 }
10270
10271 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10272 {
10273 if (!add_dynamic_entry (DT_PLTGOT, 0)
10274 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10275 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10276 || !add_dynamic_entry (DT_JMPREL, 0)
10277 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10278 return FALSE;
10279 }
10280
10281 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10282 {
10283 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10284 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10285 return FALSE;
10286 }
10287
10288 tls_opt = (htab->params->tls_get_addr_opt
10289 && htab->tls_get_addr_fd != NULL
10290 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10291 if (tls_opt || !htab->opd_abi)
10292 {
10293 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10294 return FALSE;
10295 }
10296
10297 if (relocs)
10298 {
10299 if (!add_dynamic_entry (DT_RELA, 0)
10300 || !add_dynamic_entry (DT_RELASZ, 0)
10301 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10302 return FALSE;
10303
10304 /* If any dynamic relocs apply to a read-only section,
10305 then we need a DT_TEXTREL entry. */
10306 if ((info->flags & DF_TEXTREL) == 0)
10307 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10308
10309 if ((info->flags & DF_TEXTREL) != 0)
10310 {
10311 if (!add_dynamic_entry (DT_TEXTREL, 0))
10312 return FALSE;
10313 }
10314 }
10315 }
10316 #undef add_dynamic_entry
10317
10318 return TRUE;
10319 }
10320
10321 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10322
10323 static bfd_boolean
10324 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10325 {
10326 if (h->plt.plist != NULL
10327 && !h->def_regular
10328 && !h->pointer_equality_needed)
10329 return FALSE;
10330
10331 return _bfd_elf_hash_symbol (h);
10332 }
10333
10334 /* Determine the type of stub needed, if any, for a call. */
10335
10336 static inline enum ppc_stub_type
10337 ppc_type_of_stub (asection *input_sec,
10338 const Elf_Internal_Rela *rel,
10339 struct ppc_link_hash_entry **hash,
10340 struct plt_entry **plt_ent,
10341 bfd_vma destination,
10342 unsigned long local_off)
10343 {
10344 struct ppc_link_hash_entry *h = *hash;
10345 bfd_vma location;
10346 bfd_vma branch_offset;
10347 bfd_vma max_branch_offset;
10348 enum elf_ppc64_reloc_type r_type;
10349
10350 if (h != NULL)
10351 {
10352 struct plt_entry *ent;
10353 struct ppc_link_hash_entry *fdh = h;
10354 if (h->oh != NULL
10355 && h->oh->is_func_descriptor)
10356 {
10357 fdh = ppc_follow_link (h->oh);
10358 *hash = fdh;
10359 }
10360
10361 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10362 if (ent->addend == rel->r_addend
10363 && ent->plt.offset != (bfd_vma) -1)
10364 {
10365 *plt_ent = ent;
10366 return ppc_stub_plt_call;
10367 }
10368
10369 /* Here, we know we don't have a plt entry. If we don't have a
10370 either a defined function descriptor or a defined entry symbol
10371 in a regular object file, then it is pointless trying to make
10372 any other type of stub. */
10373 if (!is_static_defined (&fdh->elf)
10374 && !is_static_defined (&h->elf))
10375 return ppc_stub_none;
10376 }
10377 else if (elf_local_got_ents (input_sec->owner) != NULL)
10378 {
10379 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10380 struct plt_entry **local_plt = (struct plt_entry **)
10381 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10382 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10383
10384 if (local_plt[r_symndx] != NULL)
10385 {
10386 struct plt_entry *ent;
10387
10388 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10389 if (ent->addend == rel->r_addend
10390 && ent->plt.offset != (bfd_vma) -1)
10391 {
10392 *plt_ent = ent;
10393 return ppc_stub_plt_call;
10394 }
10395 }
10396 }
10397
10398 /* Determine where the call point is. */
10399 location = (input_sec->output_offset
10400 + input_sec->output_section->vma
10401 + rel->r_offset);
10402
10403 branch_offset = destination - location;
10404 r_type = ELF64_R_TYPE (rel->r_info);
10405
10406 /* Determine if a long branch stub is needed. */
10407 max_branch_offset = 1 << 25;
10408 if (r_type != R_PPC64_REL24)
10409 max_branch_offset = 1 << 15;
10410
10411 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10412 /* We need a stub. Figure out whether a long_branch or plt_branch
10413 is needed later. */
10414 return ppc_stub_long_branch;
10415
10416 return ppc_stub_none;
10417 }
10418
10419 /* With power7 weakly ordered memory model, it is possible for ld.so
10420 to update a plt entry in one thread and have another thread see a
10421 stale zero toc entry. To avoid this we need some sort of acquire
10422 barrier in the call stub. One solution is to make the load of the
10423 toc word seem to appear to depend on the load of the function entry
10424 word. Another solution is to test for r2 being zero, and branch to
10425 the appropriate glink entry if so.
10426
10427 . fake dep barrier compare
10428 . ld 12,xxx(2) ld 12,xxx(2)
10429 . mtctr 12 mtctr 12
10430 . xor 11,12,12 ld 2,xxx+8(2)
10431 . add 2,2,11 cmpldi 2,0
10432 . ld 2,xxx+8(2) bnectr+
10433 . bctr b <glink_entry>
10434
10435 The solution involving the compare turns out to be faster, so
10436 that's what we use unless the branch won't reach. */
10437
10438 #define ALWAYS_USE_FAKE_DEP 0
10439 #define ALWAYS_EMIT_R2SAVE 0
10440
10441 #define PPC_LO(v) ((v) & 0xffff)
10442 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10443 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10444
10445 static inline unsigned int
10446 plt_stub_size (struct ppc_link_hash_table *htab,
10447 struct ppc_stub_hash_entry *stub_entry,
10448 bfd_vma off)
10449 {
10450 unsigned size = 12;
10451
10452 if (ALWAYS_EMIT_R2SAVE
10453 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10454 size += 4;
10455 if (PPC_HA (off) != 0)
10456 size += 4;
10457 if (htab->opd_abi)
10458 {
10459 size += 4;
10460 if (htab->params->plt_static_chain)
10461 size += 4;
10462 if (htab->params->plt_thread_safe
10463 && htab->elf.dynamic_sections_created
10464 && stub_entry->h != NULL
10465 && stub_entry->h->elf.dynindx != -1)
10466 size += 8;
10467 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10468 size += 4;
10469 }
10470 if (stub_entry->h != NULL
10471 && (stub_entry->h == htab->tls_get_addr_fd
10472 || stub_entry->h == htab->tls_get_addr)
10473 && htab->params->tls_get_addr_opt)
10474 size += 13 * 4;
10475 return size;
10476 }
10477
10478 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10479 then return the padding needed to do so. */
10480 static inline unsigned int
10481 plt_stub_pad (struct ppc_link_hash_table *htab,
10482 struct ppc_stub_hash_entry *stub_entry,
10483 bfd_vma plt_off)
10484 {
10485 int stub_align = 1 << htab->params->plt_stub_align;
10486 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10487 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10488
10489 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10490 > ((stub_size - 1) & -stub_align))
10491 return stub_align - (stub_off & (stub_align - 1));
10492 return 0;
10493 }
10494
10495 /* Build a .plt call stub. */
10496
10497 static inline bfd_byte *
10498 build_plt_stub (struct ppc_link_hash_table *htab,
10499 struct ppc_stub_hash_entry *stub_entry,
10500 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10501 {
10502 bfd *obfd = htab->params->stub_bfd;
10503 bfd_boolean plt_load_toc = htab->opd_abi;
10504 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10505 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10506 && htab->elf.dynamic_sections_created
10507 && stub_entry->h != NULL
10508 && stub_entry->h->elf.dynindx != -1);
10509 bfd_boolean use_fake_dep = plt_thread_safe;
10510 bfd_vma cmp_branch_off = 0;
10511
10512 if (!ALWAYS_USE_FAKE_DEP
10513 && plt_load_toc
10514 && plt_thread_safe
10515 && !((stub_entry->h == htab->tls_get_addr_fd
10516 || stub_entry->h == htab->tls_get_addr)
10517 && htab->params->tls_get_addr_opt))
10518 {
10519 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10520 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10521 / PLT_ENTRY_SIZE (htab));
10522 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10523 bfd_vma to, from;
10524
10525 if (pltindex > 32768)
10526 glinkoff += (pltindex - 32768) * 4;
10527 to = (glinkoff
10528 + htab->glink->output_offset
10529 + htab->glink->output_section->vma);
10530 from = (p - stub_entry->group->stub_sec->contents
10531 + 4 * (ALWAYS_EMIT_R2SAVE
10532 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10533 + 4 * (PPC_HA (offset) != 0)
10534 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10535 != PPC_HA (offset))
10536 + 4 * (plt_static_chain != 0)
10537 + 20
10538 + stub_entry->group->stub_sec->output_offset
10539 + stub_entry->group->stub_sec->output_section->vma);
10540 cmp_branch_off = to - from;
10541 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10542 }
10543
10544 if (PPC_HA (offset) != 0)
10545 {
10546 if (r != NULL)
10547 {
10548 if (ALWAYS_EMIT_R2SAVE
10549 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10550 r[0].r_offset += 4;
10551 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10552 r[1].r_offset = r[0].r_offset + 4;
10553 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10554 r[1].r_addend = r[0].r_addend;
10555 if (plt_load_toc)
10556 {
10557 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10558 {
10559 r[2].r_offset = r[1].r_offset + 4;
10560 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10561 r[2].r_addend = r[0].r_addend;
10562 }
10563 else
10564 {
10565 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10566 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10567 r[2].r_addend = r[0].r_addend + 8;
10568 if (plt_static_chain)
10569 {
10570 r[3].r_offset = r[2].r_offset + 4;
10571 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10572 r[3].r_addend = r[0].r_addend + 16;
10573 }
10574 }
10575 }
10576 }
10577 if (ALWAYS_EMIT_R2SAVE
10578 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10579 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10580 if (plt_load_toc)
10581 {
10582 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10583 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10584 }
10585 else
10586 {
10587 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10588 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10589 }
10590 if (plt_load_toc
10591 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10592 {
10593 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10594 offset = 0;
10595 }
10596 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10597 if (plt_load_toc)
10598 {
10599 if (use_fake_dep)
10600 {
10601 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10602 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10603 }
10604 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10605 if (plt_static_chain)
10606 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10607 }
10608 }
10609 else
10610 {
10611 if (r != NULL)
10612 {
10613 if (ALWAYS_EMIT_R2SAVE
10614 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10615 r[0].r_offset += 4;
10616 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10617 if (plt_load_toc)
10618 {
10619 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10620 {
10621 r[1].r_offset = r[0].r_offset + 4;
10622 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10623 r[1].r_addend = r[0].r_addend;
10624 }
10625 else
10626 {
10627 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10628 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10629 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10630 if (plt_static_chain)
10631 {
10632 r[2].r_offset = r[1].r_offset + 4;
10633 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10634 r[2].r_addend = r[0].r_addend + 8;
10635 }
10636 }
10637 }
10638 }
10639 if (ALWAYS_EMIT_R2SAVE
10640 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10641 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10642 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10643 if (plt_load_toc
10644 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10645 {
10646 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10647 offset = 0;
10648 }
10649 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10650 if (plt_load_toc)
10651 {
10652 if (use_fake_dep)
10653 {
10654 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10655 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10656 }
10657 if (plt_static_chain)
10658 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10659 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10660 }
10661 }
10662 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10663 {
10664 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10665 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10666 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10667 }
10668 else
10669 bfd_put_32 (obfd, BCTR, p), p += 4;
10670 return p;
10671 }
10672
10673 /* Build a special .plt call stub for __tls_get_addr. */
10674
10675 #define LD_R11_0R3 0xe9630000
10676 #define LD_R12_0R3 0xe9830000
10677 #define MR_R0_R3 0x7c601b78
10678 #define CMPDI_R11_0 0x2c2b0000
10679 #define ADD_R3_R12_R13 0x7c6c6a14
10680 #define BEQLR 0x4d820020
10681 #define MR_R3_R0 0x7c030378
10682 #define STD_R11_0R1 0xf9610000
10683 #define BCTRL 0x4e800421
10684 #define LD_R11_0R1 0xe9610000
10685 #define MTLR_R11 0x7d6803a6
10686
10687 static inline bfd_byte *
10688 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10689 struct ppc_stub_hash_entry *stub_entry,
10690 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10691 {
10692 bfd *obfd = htab->params->stub_bfd;
10693
10694 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10695 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10696 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10697 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10698 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10699 bfd_put_32 (obfd, BEQLR, p), p += 4;
10700 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10701 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10702 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10703
10704 if (r != NULL)
10705 r[0].r_offset += 9 * 4;
10706 p = build_plt_stub (htab, stub_entry, p, offset, r);
10707 bfd_put_32 (obfd, BCTRL, p - 4);
10708
10709 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10710 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10711 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10712 bfd_put_32 (obfd, BLR, p), p += 4;
10713
10714 return p;
10715 }
10716
10717 static Elf_Internal_Rela *
10718 get_relocs (asection *sec, int count)
10719 {
10720 Elf_Internal_Rela *relocs;
10721 struct bfd_elf_section_data *elfsec_data;
10722
10723 elfsec_data = elf_section_data (sec);
10724 relocs = elfsec_data->relocs;
10725 if (relocs == NULL)
10726 {
10727 bfd_size_type relsize;
10728 relsize = sec->reloc_count * sizeof (*relocs);
10729 relocs = bfd_alloc (sec->owner, relsize);
10730 if (relocs == NULL)
10731 return NULL;
10732 elfsec_data->relocs = relocs;
10733 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10734 sizeof (Elf_Internal_Shdr));
10735 if (elfsec_data->rela.hdr == NULL)
10736 return NULL;
10737 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10738 * sizeof (Elf64_External_Rela));
10739 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10740 sec->reloc_count = 0;
10741 }
10742 relocs += sec->reloc_count;
10743 sec->reloc_count += count;
10744 return relocs;
10745 }
10746
10747 static bfd_vma
10748 get_r2off (struct bfd_link_info *info,
10749 struct ppc_stub_hash_entry *stub_entry)
10750 {
10751 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10752 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10753
10754 if (r2off == 0)
10755 {
10756 /* Support linking -R objects. Get the toc pointer from the
10757 opd entry. */
10758 char buf[8];
10759 if (!htab->opd_abi)
10760 return r2off;
10761 asection *opd = stub_entry->h->elf.root.u.def.section;
10762 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10763
10764 if (strcmp (opd->name, ".opd") != 0
10765 || opd->reloc_count != 0)
10766 {
10767 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10768 stub_entry->h->elf.root.root.string);
10769 bfd_set_error (bfd_error_bad_value);
10770 return (bfd_vma) -1;
10771 }
10772 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10773 return (bfd_vma) -1;
10774 r2off = bfd_get_64 (opd->owner, buf);
10775 r2off -= elf_gp (info->output_bfd);
10776 }
10777 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10778 return r2off;
10779 }
10780
10781 static bfd_boolean
10782 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10783 {
10784 struct ppc_stub_hash_entry *stub_entry;
10785 struct ppc_branch_hash_entry *br_entry;
10786 struct bfd_link_info *info;
10787 struct ppc_link_hash_table *htab;
10788 bfd_byte *loc;
10789 bfd_byte *p;
10790 bfd_vma dest, off;
10791 int size;
10792 Elf_Internal_Rela *r;
10793 asection *plt;
10794
10795 /* Massage our args to the form they really have. */
10796 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10797 info = in_arg;
10798
10799 htab = ppc_hash_table (info);
10800 if (htab == NULL)
10801 return FALSE;
10802
10803 /* Make a note of the offset within the stubs for this entry. */
10804 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10805 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10806
10807 htab->stub_count[stub_entry->stub_type - 1] += 1;
10808 switch (stub_entry->stub_type)
10809 {
10810 case ppc_stub_long_branch:
10811 case ppc_stub_long_branch_r2off:
10812 /* Branches are relative. This is where we are going to. */
10813 dest = (stub_entry->target_value
10814 + stub_entry->target_section->output_offset
10815 + stub_entry->target_section->output_section->vma);
10816 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10817 off = dest;
10818
10819 /* And this is where we are coming from. */
10820 off -= (stub_entry->stub_offset
10821 + stub_entry->group->stub_sec->output_offset
10822 + stub_entry->group->stub_sec->output_section->vma);
10823
10824 size = 4;
10825 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10826 {
10827 bfd_vma r2off = get_r2off (info, stub_entry);
10828
10829 if (r2off == (bfd_vma) -1)
10830 {
10831 htab->stub_error = TRUE;
10832 return FALSE;
10833 }
10834 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10835 loc += 4;
10836 size = 8;
10837 if (PPC_HA (r2off) != 0)
10838 {
10839 bfd_put_32 (htab->params->stub_bfd,
10840 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10841 loc += 4;
10842 size += 4;
10843 }
10844 if (PPC_LO (r2off) != 0)
10845 {
10846 bfd_put_32 (htab->params->stub_bfd,
10847 ADDI_R2_R2 | PPC_LO (r2off), loc);
10848 loc += 4;
10849 size += 4;
10850 }
10851 off -= size - 4;
10852 }
10853 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10854
10855 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10856 {
10857 info->callbacks->einfo
10858 (_("%P: long branch stub `%s' offset overflow\n"),
10859 stub_entry->root.string);
10860 htab->stub_error = TRUE;
10861 return FALSE;
10862 }
10863
10864 if (info->emitrelocations)
10865 {
10866 r = get_relocs (stub_entry->group->stub_sec, 1);
10867 if (r == NULL)
10868 return FALSE;
10869 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10870 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10871 r->r_addend = dest;
10872 if (stub_entry->h != NULL)
10873 {
10874 struct elf_link_hash_entry **hashes;
10875 unsigned long symndx;
10876 struct ppc_link_hash_entry *h;
10877
10878 hashes = elf_sym_hashes (htab->params->stub_bfd);
10879 if (hashes == NULL)
10880 {
10881 bfd_size_type hsize;
10882
10883 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10884 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10885 if (hashes == NULL)
10886 return FALSE;
10887 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10888 htab->stub_globals = 1;
10889 }
10890 symndx = htab->stub_globals++;
10891 h = stub_entry->h;
10892 hashes[symndx] = &h->elf;
10893 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10894 if (h->oh != NULL && h->oh->is_func)
10895 h = ppc_follow_link (h->oh);
10896 if (h->elf.root.u.def.section != stub_entry->target_section)
10897 /* H is an opd symbol. The addend must be zero. */
10898 r->r_addend = 0;
10899 else
10900 {
10901 off = (h->elf.root.u.def.value
10902 + h->elf.root.u.def.section->output_offset
10903 + h->elf.root.u.def.section->output_section->vma);
10904 r->r_addend -= off;
10905 }
10906 }
10907 }
10908 break;
10909
10910 case ppc_stub_plt_branch:
10911 case ppc_stub_plt_branch_r2off:
10912 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10913 stub_entry->root.string + 9,
10914 FALSE, FALSE);
10915 if (br_entry == NULL)
10916 {
10917 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10918 stub_entry->root.string);
10919 htab->stub_error = TRUE;
10920 return FALSE;
10921 }
10922
10923 dest = (stub_entry->target_value
10924 + stub_entry->target_section->output_offset
10925 + stub_entry->target_section->output_section->vma);
10926 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10927 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10928
10929 bfd_put_64 (htab->brlt->owner, dest,
10930 htab->brlt->contents + br_entry->offset);
10931
10932 if (br_entry->iter == htab->stub_iteration)
10933 {
10934 br_entry->iter = 0;
10935
10936 if (htab->relbrlt != NULL)
10937 {
10938 /* Create a reloc for the branch lookup table entry. */
10939 Elf_Internal_Rela rela;
10940 bfd_byte *rl;
10941
10942 rela.r_offset = (br_entry->offset
10943 + htab->brlt->output_offset
10944 + htab->brlt->output_section->vma);
10945 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10946 rela.r_addend = dest;
10947
10948 rl = htab->relbrlt->contents;
10949 rl += (htab->relbrlt->reloc_count++
10950 * sizeof (Elf64_External_Rela));
10951 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10952 }
10953 else if (info->emitrelocations)
10954 {
10955 r = get_relocs (htab->brlt, 1);
10956 if (r == NULL)
10957 return FALSE;
10958 /* brlt, being SEC_LINKER_CREATED does not go through the
10959 normal reloc processing. Symbols and offsets are not
10960 translated from input file to output file form, so
10961 set up the offset per the output file. */
10962 r->r_offset = (br_entry->offset
10963 + htab->brlt->output_offset
10964 + htab->brlt->output_section->vma);
10965 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10966 r->r_addend = dest;
10967 }
10968 }
10969
10970 dest = (br_entry->offset
10971 + htab->brlt->output_offset
10972 + htab->brlt->output_section->vma);
10973
10974 off = (dest
10975 - elf_gp (htab->brlt->output_section->owner)
10976 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10977
10978 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10979 {
10980 info->callbacks->einfo
10981 (_("%P: linkage table error against `%T'\n"),
10982 stub_entry->root.string);
10983 bfd_set_error (bfd_error_bad_value);
10984 htab->stub_error = TRUE;
10985 return FALSE;
10986 }
10987
10988 if (info->emitrelocations)
10989 {
10990 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10991 if (r == NULL)
10992 return FALSE;
10993 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10994 if (bfd_big_endian (info->output_bfd))
10995 r[0].r_offset += 2;
10996 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10997 r[0].r_offset += 4;
10998 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10999 r[0].r_addend = dest;
11000 if (PPC_HA (off) != 0)
11001 {
11002 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11003 r[1].r_offset = r[0].r_offset + 4;
11004 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11005 r[1].r_addend = r[0].r_addend;
11006 }
11007 }
11008
11009 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11010 {
11011 if (PPC_HA (off) != 0)
11012 {
11013 size = 16;
11014 bfd_put_32 (htab->params->stub_bfd,
11015 ADDIS_R12_R2 | PPC_HA (off), loc);
11016 loc += 4;
11017 bfd_put_32 (htab->params->stub_bfd,
11018 LD_R12_0R12 | PPC_LO (off), loc);
11019 }
11020 else
11021 {
11022 size = 12;
11023 bfd_put_32 (htab->params->stub_bfd,
11024 LD_R12_0R2 | PPC_LO (off), loc);
11025 }
11026 }
11027 else
11028 {
11029 bfd_vma r2off = get_r2off (info, stub_entry);
11030
11031 if (r2off == (bfd_vma) -1)
11032 {
11033 htab->stub_error = TRUE;
11034 return FALSE;
11035 }
11036
11037 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11038 loc += 4;
11039 size = 16;
11040 if (PPC_HA (off) != 0)
11041 {
11042 size += 4;
11043 bfd_put_32 (htab->params->stub_bfd,
11044 ADDIS_R12_R2 | PPC_HA (off), loc);
11045 loc += 4;
11046 bfd_put_32 (htab->params->stub_bfd,
11047 LD_R12_0R12 | PPC_LO (off), loc);
11048 }
11049 else
11050 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11051
11052 if (PPC_HA (r2off) != 0)
11053 {
11054 size += 4;
11055 loc += 4;
11056 bfd_put_32 (htab->params->stub_bfd,
11057 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11058 }
11059 if (PPC_LO (r2off) != 0)
11060 {
11061 size += 4;
11062 loc += 4;
11063 bfd_put_32 (htab->params->stub_bfd,
11064 ADDI_R2_R2 | PPC_LO (r2off), loc);
11065 }
11066 }
11067 loc += 4;
11068 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11069 loc += 4;
11070 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11071 break;
11072
11073 case ppc_stub_plt_call:
11074 case ppc_stub_plt_call_r2save:
11075 if (stub_entry->h != NULL
11076 && stub_entry->h->is_func_descriptor
11077 && stub_entry->h->oh != NULL)
11078 {
11079 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11080
11081 /* If the old-ABI "dot-symbol" is undefined make it weak so
11082 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11083 if (fh->elf.root.type == bfd_link_hash_undefined)
11084 fh->elf.root.type = bfd_link_hash_undefweak;
11085 /* Stop undo_symbol_twiddle changing it back to undefined. */
11086 fh->was_undefined = 0;
11087 }
11088
11089 /* Now build the stub. */
11090 dest = stub_entry->plt_ent->plt.offset & ~1;
11091 if (dest >= (bfd_vma) -2)
11092 abort ();
11093
11094 plt = htab->elf.splt;
11095 if (!htab->elf.dynamic_sections_created
11096 || stub_entry->h == NULL
11097 || stub_entry->h->elf.dynindx == -1)
11098 plt = htab->elf.iplt;
11099
11100 dest += plt->output_offset + plt->output_section->vma;
11101
11102 if (stub_entry->h == NULL
11103 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11104 {
11105 Elf_Internal_Rela rela;
11106 bfd_byte *rl;
11107
11108 rela.r_offset = dest;
11109 if (htab->opd_abi)
11110 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11111 else
11112 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11113 rela.r_addend = (stub_entry->target_value
11114 + stub_entry->target_section->output_offset
11115 + stub_entry->target_section->output_section->vma);
11116
11117 rl = (htab->elf.irelplt->contents
11118 + (htab->elf.irelplt->reloc_count++
11119 * sizeof (Elf64_External_Rela)));
11120 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11121 stub_entry->plt_ent->plt.offset |= 1;
11122 }
11123
11124 off = (dest
11125 - elf_gp (plt->output_section->owner)
11126 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11127
11128 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11129 {
11130 info->callbacks->einfo
11131 /* xgettext:c-format */
11132 (_("%P: linkage table error against `%T'\n"),
11133 stub_entry->h != NULL
11134 ? stub_entry->h->elf.root.root.string
11135 : "<local sym>");
11136 bfd_set_error (bfd_error_bad_value);
11137 htab->stub_error = TRUE;
11138 return FALSE;
11139 }
11140
11141 if (htab->params->plt_stub_align != 0)
11142 {
11143 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11144
11145 stub_entry->group->stub_sec->size += pad;
11146 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11147 loc += pad;
11148 }
11149
11150 r = NULL;
11151 if (info->emitrelocations)
11152 {
11153 r = get_relocs (stub_entry->group->stub_sec,
11154 ((PPC_HA (off) != 0)
11155 + (htab->opd_abi
11156 ? 2 + (htab->params->plt_static_chain
11157 && PPC_HA (off + 16) == PPC_HA (off))
11158 : 1)));
11159 if (r == NULL)
11160 return FALSE;
11161 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11162 if (bfd_big_endian (info->output_bfd))
11163 r[0].r_offset += 2;
11164 r[0].r_addend = dest;
11165 }
11166 if (stub_entry->h != NULL
11167 && (stub_entry->h == htab->tls_get_addr_fd
11168 || stub_entry->h == htab->tls_get_addr)
11169 && htab->params->tls_get_addr_opt)
11170 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11171 else
11172 p = build_plt_stub (htab, stub_entry, loc, off, r);
11173 size = p - loc;
11174 break;
11175
11176 case ppc_stub_save_res:
11177 return TRUE;
11178
11179 default:
11180 BFD_FAIL ();
11181 return FALSE;
11182 }
11183
11184 stub_entry->group->stub_sec->size += size;
11185
11186 if (htab->params->emit_stub_syms)
11187 {
11188 struct elf_link_hash_entry *h;
11189 size_t len1, len2;
11190 char *name;
11191 const char *const stub_str[] = { "long_branch",
11192 "long_branch_r2off",
11193 "plt_branch",
11194 "plt_branch_r2off",
11195 "plt_call",
11196 "plt_call" };
11197
11198 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11199 len2 = strlen (stub_entry->root.string);
11200 name = bfd_malloc (len1 + len2 + 2);
11201 if (name == NULL)
11202 return FALSE;
11203 memcpy (name, stub_entry->root.string, 9);
11204 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11205 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11206 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11207 if (h == NULL)
11208 return FALSE;
11209 if (h->root.type == bfd_link_hash_new)
11210 {
11211 h->root.type = bfd_link_hash_defined;
11212 h->root.u.def.section = stub_entry->group->stub_sec;
11213 h->root.u.def.value = stub_entry->stub_offset;
11214 h->ref_regular = 1;
11215 h->def_regular = 1;
11216 h->ref_regular_nonweak = 1;
11217 h->forced_local = 1;
11218 h->non_elf = 0;
11219 h->root.linker_def = 1;
11220 }
11221 }
11222
11223 return TRUE;
11224 }
11225
11226 /* As above, but don't actually build the stub. Just bump offset so
11227 we know stub section sizes, and select plt_branch stubs where
11228 long_branch stubs won't do. */
11229
11230 static bfd_boolean
11231 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11232 {
11233 struct ppc_stub_hash_entry *stub_entry;
11234 struct bfd_link_info *info;
11235 struct ppc_link_hash_table *htab;
11236 bfd_vma off;
11237 int size;
11238
11239 /* Massage our args to the form they really have. */
11240 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11241 info = in_arg;
11242
11243 htab = ppc_hash_table (info);
11244 if (htab == NULL)
11245 return FALSE;
11246
11247 if (stub_entry->h != NULL
11248 && stub_entry->h->save_res
11249 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11250 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11251 {
11252 /* Don't make stubs to out-of-line register save/restore
11253 functions. Instead, emit copies of the functions. */
11254 stub_entry->group->needs_save_res = 1;
11255 stub_entry->stub_type = ppc_stub_save_res;
11256 return TRUE;
11257 }
11258
11259 if (stub_entry->stub_type == ppc_stub_plt_call
11260 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11261 {
11262 asection *plt;
11263 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11264 if (off >= (bfd_vma) -2)
11265 abort ();
11266 plt = htab->elf.splt;
11267 if (!htab->elf.dynamic_sections_created
11268 || stub_entry->h == NULL
11269 || stub_entry->h->elf.dynindx == -1)
11270 plt = htab->elf.iplt;
11271 off += (plt->output_offset
11272 + plt->output_section->vma
11273 - elf_gp (plt->output_section->owner)
11274 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11275
11276 size = plt_stub_size (htab, stub_entry, off);
11277 if (htab->params->plt_stub_align)
11278 size += plt_stub_pad (htab, stub_entry, off);
11279 if (info->emitrelocations)
11280 {
11281 stub_entry->group->stub_sec->reloc_count
11282 += ((PPC_HA (off) != 0)
11283 + (htab->opd_abi
11284 ? 2 + (htab->params->plt_static_chain
11285 && PPC_HA (off + 16) == PPC_HA (off))
11286 : 1));
11287 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11288 }
11289 }
11290 else
11291 {
11292 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11293 variants. */
11294 bfd_vma r2off = 0;
11295 bfd_vma local_off = 0;
11296
11297 off = (stub_entry->target_value
11298 + stub_entry->target_section->output_offset
11299 + stub_entry->target_section->output_section->vma);
11300 off -= (stub_entry->group->stub_sec->size
11301 + stub_entry->group->stub_sec->output_offset
11302 + stub_entry->group->stub_sec->output_section->vma);
11303
11304 /* Reset the stub type from the plt variant in case we now
11305 can reach with a shorter stub. */
11306 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11307 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11308
11309 size = 4;
11310 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11311 {
11312 r2off = get_r2off (info, stub_entry);
11313 if (r2off == (bfd_vma) -1)
11314 {
11315 htab->stub_error = TRUE;
11316 return FALSE;
11317 }
11318 size = 8;
11319 if (PPC_HA (r2off) != 0)
11320 size += 4;
11321 if (PPC_LO (r2off) != 0)
11322 size += 4;
11323 off -= size - 4;
11324 }
11325
11326 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11327
11328 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11329 Do the same for -R objects without function descriptors. */
11330 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11331 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11332 && r2off == 0
11333 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11334 {
11335 struct ppc_branch_hash_entry *br_entry;
11336
11337 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11338 stub_entry->root.string + 9,
11339 TRUE, FALSE);
11340 if (br_entry == NULL)
11341 {
11342 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11343 stub_entry->root.string);
11344 htab->stub_error = TRUE;
11345 return FALSE;
11346 }
11347
11348 if (br_entry->iter != htab->stub_iteration)
11349 {
11350 br_entry->iter = htab->stub_iteration;
11351 br_entry->offset = htab->brlt->size;
11352 htab->brlt->size += 8;
11353
11354 if (htab->relbrlt != NULL)
11355 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11356 else if (info->emitrelocations)
11357 {
11358 htab->brlt->reloc_count += 1;
11359 htab->brlt->flags |= SEC_RELOC;
11360 }
11361 }
11362
11363 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11364 off = (br_entry->offset
11365 + htab->brlt->output_offset
11366 + htab->brlt->output_section->vma
11367 - elf_gp (htab->brlt->output_section->owner)
11368 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11369
11370 if (info->emitrelocations)
11371 {
11372 stub_entry->group->stub_sec->reloc_count
11373 += 1 + (PPC_HA (off) != 0);
11374 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11375 }
11376
11377 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11378 {
11379 size = 12;
11380 if (PPC_HA (off) != 0)
11381 size = 16;
11382 }
11383 else
11384 {
11385 size = 16;
11386 if (PPC_HA (off) != 0)
11387 size += 4;
11388
11389 if (PPC_HA (r2off) != 0)
11390 size += 4;
11391 if (PPC_LO (r2off) != 0)
11392 size += 4;
11393 }
11394 }
11395 else if (info->emitrelocations)
11396 {
11397 stub_entry->group->stub_sec->reloc_count += 1;
11398 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11399 }
11400 }
11401
11402 stub_entry->group->stub_sec->size += size;
11403 return TRUE;
11404 }
11405
11406 /* Set up various things so that we can make a list of input sections
11407 for each output section included in the link. Returns -1 on error,
11408 0 when no stubs will be needed, and 1 on success. */
11409
11410 int
11411 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11412 {
11413 unsigned int id;
11414 bfd_size_type amt;
11415 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11416
11417 if (htab == NULL)
11418 return -1;
11419
11420 htab->sec_info_arr_size = bfd_get_next_section_id ();
11421 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11422 htab->sec_info = bfd_zmalloc (amt);
11423 if (htab->sec_info == NULL)
11424 return -1;
11425
11426 /* Set toc_off for com, und, abs and ind sections. */
11427 for (id = 0; id < 3; id++)
11428 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11429
11430 return 1;
11431 }
11432
11433 /* Set up for first pass at multitoc partitioning. */
11434
11435 void
11436 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11437 {
11438 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11439
11440 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11441 htab->toc_bfd = NULL;
11442 htab->toc_first_sec = NULL;
11443 }
11444
11445 /* The linker repeatedly calls this function for each TOC input section
11446 and linker generated GOT section. Group input bfds such that the toc
11447 within a group is less than 64k in size. */
11448
11449 bfd_boolean
11450 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11451 {
11452 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11453 bfd_vma addr, off, limit;
11454
11455 if (htab == NULL)
11456 return FALSE;
11457
11458 if (!htab->second_toc_pass)
11459 {
11460 /* Keep track of the first .toc or .got section for this input bfd. */
11461 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11462
11463 if (new_bfd)
11464 {
11465 htab->toc_bfd = isec->owner;
11466 htab->toc_first_sec = isec;
11467 }
11468
11469 addr = isec->output_offset + isec->output_section->vma;
11470 off = addr - htab->toc_curr;
11471 limit = 0x80008000;
11472 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11473 limit = 0x10000;
11474 if (off + isec->size > limit)
11475 {
11476 addr = (htab->toc_first_sec->output_offset
11477 + htab->toc_first_sec->output_section->vma);
11478 htab->toc_curr = addr;
11479 htab->toc_curr &= -TOC_BASE_ALIGN;
11480 }
11481
11482 /* toc_curr is the base address of this toc group. Set elf_gp
11483 for the input section to be the offset relative to the
11484 output toc base plus 0x8000. Making the input elf_gp an
11485 offset allows us to move the toc as a whole without
11486 recalculating input elf_gp. */
11487 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11488 off += TOC_BASE_OFF;
11489
11490 /* Die if someone uses a linker script that doesn't keep input
11491 file .toc and .got together. */
11492 if (new_bfd
11493 && elf_gp (isec->owner) != 0
11494 && elf_gp (isec->owner) != off)
11495 return FALSE;
11496
11497 elf_gp (isec->owner) = off;
11498 return TRUE;
11499 }
11500
11501 /* During the second pass toc_first_sec points to the start of
11502 a toc group, and toc_curr is used to track the old elf_gp.
11503 We use toc_bfd to ensure we only look at each bfd once. */
11504 if (htab->toc_bfd == isec->owner)
11505 return TRUE;
11506 htab->toc_bfd = isec->owner;
11507
11508 if (htab->toc_first_sec == NULL
11509 || htab->toc_curr != elf_gp (isec->owner))
11510 {
11511 htab->toc_curr = elf_gp (isec->owner);
11512 htab->toc_first_sec = isec;
11513 }
11514 addr = (htab->toc_first_sec->output_offset
11515 + htab->toc_first_sec->output_section->vma);
11516 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11517 elf_gp (isec->owner) = off;
11518
11519 return TRUE;
11520 }
11521
11522 /* Called via elf_link_hash_traverse to merge GOT entries for global
11523 symbol H. */
11524
11525 static bfd_boolean
11526 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11527 {
11528 if (h->root.type == bfd_link_hash_indirect)
11529 return TRUE;
11530
11531 merge_got_entries (&h->got.glist);
11532
11533 return TRUE;
11534 }
11535
11536 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11537 symbol H. */
11538
11539 static bfd_boolean
11540 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11541 {
11542 struct got_entry *gent;
11543
11544 if (h->root.type == bfd_link_hash_indirect)
11545 return TRUE;
11546
11547 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11548 if (!gent->is_indirect)
11549 allocate_got (h, (struct bfd_link_info *) inf, gent);
11550 return TRUE;
11551 }
11552
11553 /* Called on the first multitoc pass after the last call to
11554 ppc64_elf_next_toc_section. This function removes duplicate GOT
11555 entries. */
11556
11557 bfd_boolean
11558 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11559 {
11560 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11561 struct bfd *ibfd, *ibfd2;
11562 bfd_boolean done_something;
11563
11564 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11565
11566 if (!htab->do_multi_toc)
11567 return FALSE;
11568
11569 /* Merge global sym got entries within a toc group. */
11570 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11571
11572 /* And tlsld_got. */
11573 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11574 {
11575 struct got_entry *ent, *ent2;
11576
11577 if (!is_ppc64_elf (ibfd))
11578 continue;
11579
11580 ent = ppc64_tlsld_got (ibfd);
11581 if (!ent->is_indirect
11582 && ent->got.offset != (bfd_vma) -1)
11583 {
11584 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11585 {
11586 if (!is_ppc64_elf (ibfd2))
11587 continue;
11588
11589 ent2 = ppc64_tlsld_got (ibfd2);
11590 if (!ent2->is_indirect
11591 && ent2->got.offset != (bfd_vma) -1
11592 && elf_gp (ibfd2) == elf_gp (ibfd))
11593 {
11594 ent2->is_indirect = TRUE;
11595 ent2->got.ent = ent;
11596 }
11597 }
11598 }
11599 }
11600
11601 /* Zap sizes of got sections. */
11602 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11603 htab->elf.irelplt->size -= htab->got_reli_size;
11604 htab->got_reli_size = 0;
11605
11606 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11607 {
11608 asection *got, *relgot;
11609
11610 if (!is_ppc64_elf (ibfd))
11611 continue;
11612
11613 got = ppc64_elf_tdata (ibfd)->got;
11614 if (got != NULL)
11615 {
11616 got->rawsize = got->size;
11617 got->size = 0;
11618 relgot = ppc64_elf_tdata (ibfd)->relgot;
11619 relgot->rawsize = relgot->size;
11620 relgot->size = 0;
11621 }
11622 }
11623
11624 /* Now reallocate the got, local syms first. We don't need to
11625 allocate section contents again since we never increase size. */
11626 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11627 {
11628 struct got_entry **lgot_ents;
11629 struct got_entry **end_lgot_ents;
11630 struct plt_entry **local_plt;
11631 struct plt_entry **end_local_plt;
11632 unsigned char *lgot_masks;
11633 bfd_size_type locsymcount;
11634 Elf_Internal_Shdr *symtab_hdr;
11635 asection *s;
11636
11637 if (!is_ppc64_elf (ibfd))
11638 continue;
11639
11640 lgot_ents = elf_local_got_ents (ibfd);
11641 if (!lgot_ents)
11642 continue;
11643
11644 symtab_hdr = &elf_symtab_hdr (ibfd);
11645 locsymcount = symtab_hdr->sh_info;
11646 end_lgot_ents = lgot_ents + locsymcount;
11647 local_plt = (struct plt_entry **) end_lgot_ents;
11648 end_local_plt = local_plt + locsymcount;
11649 lgot_masks = (unsigned char *) end_local_plt;
11650 s = ppc64_elf_tdata (ibfd)->got;
11651 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11652 {
11653 struct got_entry *ent;
11654
11655 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11656 {
11657 unsigned int ent_size = 8;
11658 unsigned int rel_size = sizeof (Elf64_External_Rela);
11659
11660 ent->got.offset = s->size;
11661 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11662 {
11663 ent_size *= 2;
11664 rel_size *= 2;
11665 }
11666 s->size += ent_size;
11667 if ((*lgot_masks & PLT_IFUNC) != 0)
11668 {
11669 htab->elf.irelplt->size += rel_size;
11670 htab->got_reli_size += rel_size;
11671 }
11672 else if (bfd_link_pic (info))
11673 {
11674 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11675 srel->size += rel_size;
11676 }
11677 }
11678 }
11679 }
11680
11681 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11682
11683 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11684 {
11685 struct got_entry *ent;
11686
11687 if (!is_ppc64_elf (ibfd))
11688 continue;
11689
11690 ent = ppc64_tlsld_got (ibfd);
11691 if (!ent->is_indirect
11692 && ent->got.offset != (bfd_vma) -1)
11693 {
11694 asection *s = ppc64_elf_tdata (ibfd)->got;
11695 ent->got.offset = s->size;
11696 s->size += 16;
11697 if (bfd_link_pic (info))
11698 {
11699 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11700 srel->size += sizeof (Elf64_External_Rela);
11701 }
11702 }
11703 }
11704
11705 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11706 if (!done_something)
11707 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11708 {
11709 asection *got;
11710
11711 if (!is_ppc64_elf (ibfd))
11712 continue;
11713
11714 got = ppc64_elf_tdata (ibfd)->got;
11715 if (got != NULL)
11716 {
11717 done_something = got->rawsize != got->size;
11718 if (done_something)
11719 break;
11720 }
11721 }
11722
11723 if (done_something)
11724 (*htab->params->layout_sections_again) ();
11725
11726 /* Set up for second pass over toc sections to recalculate elf_gp
11727 on input sections. */
11728 htab->toc_bfd = NULL;
11729 htab->toc_first_sec = NULL;
11730 htab->second_toc_pass = TRUE;
11731 return done_something;
11732 }
11733
11734 /* Called after second pass of multitoc partitioning. */
11735
11736 void
11737 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11738 {
11739 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11740
11741 /* After the second pass, toc_curr tracks the TOC offset used
11742 for code sections below in ppc64_elf_next_input_section. */
11743 htab->toc_curr = TOC_BASE_OFF;
11744 }
11745
11746 /* No toc references were found in ISEC. If the code in ISEC makes no
11747 calls, then there's no need to use toc adjusting stubs when branching
11748 into ISEC. Actually, indirect calls from ISEC are OK as they will
11749 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11750 needed, and 2 if a cyclical call-graph was found but no other reason
11751 for a stub was detected. If called from the top level, a return of
11752 2 means the same as a return of 0. */
11753
11754 static int
11755 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11756 {
11757 int ret;
11758
11759 /* Mark this section as checked. */
11760 isec->call_check_done = 1;
11761
11762 /* We know none of our code bearing sections will need toc stubs. */
11763 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11764 return 0;
11765
11766 if (isec->size == 0)
11767 return 0;
11768
11769 if (isec->output_section == NULL)
11770 return 0;
11771
11772 ret = 0;
11773 if (isec->reloc_count != 0)
11774 {
11775 Elf_Internal_Rela *relstart, *rel;
11776 Elf_Internal_Sym *local_syms;
11777 struct ppc_link_hash_table *htab;
11778
11779 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11780 info->keep_memory);
11781 if (relstart == NULL)
11782 return -1;
11783
11784 /* Look for branches to outside of this section. */
11785 local_syms = NULL;
11786 htab = ppc_hash_table (info);
11787 if (htab == NULL)
11788 return -1;
11789
11790 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11791 {
11792 enum elf_ppc64_reloc_type r_type;
11793 unsigned long r_symndx;
11794 struct elf_link_hash_entry *h;
11795 struct ppc_link_hash_entry *eh;
11796 Elf_Internal_Sym *sym;
11797 asection *sym_sec;
11798 struct _opd_sec_data *opd;
11799 bfd_vma sym_value;
11800 bfd_vma dest;
11801
11802 r_type = ELF64_R_TYPE (rel->r_info);
11803 if (r_type != R_PPC64_REL24
11804 && r_type != R_PPC64_REL14
11805 && r_type != R_PPC64_REL14_BRTAKEN
11806 && r_type != R_PPC64_REL14_BRNTAKEN)
11807 continue;
11808
11809 r_symndx = ELF64_R_SYM (rel->r_info);
11810 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11811 isec->owner))
11812 {
11813 ret = -1;
11814 break;
11815 }
11816
11817 /* Calls to dynamic lib functions go through a plt call stub
11818 that uses r2. */
11819 eh = (struct ppc_link_hash_entry *) h;
11820 if (eh != NULL
11821 && (eh->elf.plt.plist != NULL
11822 || (eh->oh != NULL
11823 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11824 {
11825 ret = 1;
11826 break;
11827 }
11828
11829 if (sym_sec == NULL)
11830 /* Ignore other undefined symbols. */
11831 continue;
11832
11833 /* Assume branches to other sections not included in the
11834 link need stubs too, to cover -R and absolute syms. */
11835 if (sym_sec->output_section == NULL)
11836 {
11837 ret = 1;
11838 break;
11839 }
11840
11841 if (h == NULL)
11842 sym_value = sym->st_value;
11843 else
11844 {
11845 if (h->root.type != bfd_link_hash_defined
11846 && h->root.type != bfd_link_hash_defweak)
11847 abort ();
11848 sym_value = h->root.u.def.value;
11849 }
11850 sym_value += rel->r_addend;
11851
11852 /* If this branch reloc uses an opd sym, find the code section. */
11853 opd = get_opd_info (sym_sec);
11854 if (opd != NULL)
11855 {
11856 if (h == NULL && opd->adjust != NULL)
11857 {
11858 long adjust;
11859
11860 adjust = opd->adjust[OPD_NDX (sym_value)];
11861 if (adjust == -1)
11862 /* Assume deleted functions won't ever be called. */
11863 continue;
11864 sym_value += adjust;
11865 }
11866
11867 dest = opd_entry_value (sym_sec, sym_value,
11868 &sym_sec, NULL, FALSE);
11869 if (dest == (bfd_vma) -1)
11870 continue;
11871 }
11872 else
11873 dest = (sym_value
11874 + sym_sec->output_offset
11875 + sym_sec->output_section->vma);
11876
11877 /* Ignore branch to self. */
11878 if (sym_sec == isec)
11879 continue;
11880
11881 /* If the called function uses the toc, we need a stub. */
11882 if (sym_sec->has_toc_reloc
11883 || sym_sec->makes_toc_func_call)
11884 {
11885 ret = 1;
11886 break;
11887 }
11888
11889 /* Assume any branch that needs a long branch stub might in fact
11890 need a plt_branch stub. A plt_branch stub uses r2. */
11891 else if (dest - (isec->output_offset
11892 + isec->output_section->vma
11893 + rel->r_offset) + (1 << 25)
11894 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11895 ? h->other
11896 : sym->st_other))
11897 {
11898 ret = 1;
11899 break;
11900 }
11901
11902 /* If calling back to a section in the process of being
11903 tested, we can't say for sure that no toc adjusting stubs
11904 are needed, so don't return zero. */
11905 else if (sym_sec->call_check_in_progress)
11906 ret = 2;
11907
11908 /* Branches to another section that itself doesn't have any TOC
11909 references are OK. Recursively call ourselves to check. */
11910 else if (!sym_sec->call_check_done)
11911 {
11912 int recur;
11913
11914 /* Mark current section as indeterminate, so that other
11915 sections that call back to current won't be marked as
11916 known. */
11917 isec->call_check_in_progress = 1;
11918 recur = toc_adjusting_stub_needed (info, sym_sec);
11919 isec->call_check_in_progress = 0;
11920
11921 if (recur != 0)
11922 {
11923 ret = recur;
11924 if (recur != 2)
11925 break;
11926 }
11927 }
11928 }
11929
11930 if (local_syms != NULL
11931 && (elf_symtab_hdr (isec->owner).contents
11932 != (unsigned char *) local_syms))
11933 free (local_syms);
11934 if (elf_section_data (isec)->relocs != relstart)
11935 free (relstart);
11936 }
11937
11938 if ((ret & 1) == 0
11939 && isec->map_head.s != NULL
11940 && (strcmp (isec->output_section->name, ".init") == 0
11941 || strcmp (isec->output_section->name, ".fini") == 0))
11942 {
11943 if (isec->map_head.s->has_toc_reloc
11944 || isec->map_head.s->makes_toc_func_call)
11945 ret = 1;
11946 else if (!isec->map_head.s->call_check_done)
11947 {
11948 int recur;
11949 isec->call_check_in_progress = 1;
11950 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11951 isec->call_check_in_progress = 0;
11952 if (recur != 0)
11953 ret = recur;
11954 }
11955 }
11956
11957 if (ret == 1)
11958 isec->makes_toc_func_call = 1;
11959
11960 return ret;
11961 }
11962
11963 /* The linker repeatedly calls this function for each input section,
11964 in the order that input sections are linked into output sections.
11965 Build lists of input sections to determine groupings between which
11966 we may insert linker stubs. */
11967
11968 bfd_boolean
11969 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11970 {
11971 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11972
11973 if (htab == NULL)
11974 return FALSE;
11975
11976 if ((isec->output_section->flags & SEC_CODE) != 0
11977 && isec->output_section->id < htab->sec_info_arr_size)
11978 {
11979 /* This happens to make the list in reverse order,
11980 which is what we want. */
11981 htab->sec_info[isec->id].u.list
11982 = htab->sec_info[isec->output_section->id].u.list;
11983 htab->sec_info[isec->output_section->id].u.list = isec;
11984 }
11985
11986 if (htab->multi_toc_needed)
11987 {
11988 /* Analyse sections that aren't already flagged as needing a
11989 valid toc pointer. Exclude .fixup for the linux kernel.
11990 .fixup contains branches, but only back to the function that
11991 hit an exception. */
11992 if (!(isec->has_toc_reloc
11993 || (isec->flags & SEC_CODE) == 0
11994 || strcmp (isec->name, ".fixup") == 0
11995 || isec->call_check_done))
11996 {
11997 if (toc_adjusting_stub_needed (info, isec) < 0)
11998 return FALSE;
11999 }
12000 /* Make all sections use the TOC assigned for this object file.
12001 This will be wrong for pasted sections; We fix that in
12002 check_pasted_section(). */
12003 if (elf_gp (isec->owner) != 0)
12004 htab->toc_curr = elf_gp (isec->owner);
12005 }
12006
12007 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12008 return TRUE;
12009 }
12010
12011 /* Check that all .init and .fini sections use the same toc, if they
12012 have toc relocs. */
12013
12014 static bfd_boolean
12015 check_pasted_section (struct bfd_link_info *info, const char *name)
12016 {
12017 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12018
12019 if (o != NULL)
12020 {
12021 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12022 bfd_vma toc_off = 0;
12023 asection *i;
12024
12025 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12026 if (i->has_toc_reloc)
12027 {
12028 if (toc_off == 0)
12029 toc_off = htab->sec_info[i->id].toc_off;
12030 else if (toc_off != htab->sec_info[i->id].toc_off)
12031 return FALSE;
12032 }
12033
12034 if (toc_off == 0)
12035 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12036 if (i->makes_toc_func_call)
12037 {
12038 toc_off = htab->sec_info[i->id].toc_off;
12039 break;
12040 }
12041
12042 /* Make sure the whole pasted function uses the same toc offset. */
12043 if (toc_off != 0)
12044 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12045 htab->sec_info[i->id].toc_off = toc_off;
12046 }
12047 return TRUE;
12048 }
12049
12050 bfd_boolean
12051 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12052 {
12053 return (check_pasted_section (info, ".init")
12054 & check_pasted_section (info, ".fini"));
12055 }
12056
12057 /* See whether we can group stub sections together. Grouping stub
12058 sections may result in fewer stubs. More importantly, we need to
12059 put all .init* and .fini* stubs at the beginning of the .init or
12060 .fini output sections respectively, because glibc splits the
12061 _init and _fini functions into multiple parts. Putting a stub in
12062 the middle of a function is not a good idea. */
12063
12064 static bfd_boolean
12065 group_sections (struct bfd_link_info *info,
12066 bfd_size_type stub_group_size,
12067 bfd_boolean stubs_always_before_branch)
12068 {
12069 struct ppc_link_hash_table *htab;
12070 asection *osec;
12071 bfd_boolean suppress_size_errors;
12072
12073 htab = ppc_hash_table (info);
12074 if (htab == NULL)
12075 return FALSE;
12076
12077 suppress_size_errors = FALSE;
12078 if (stub_group_size == 1)
12079 {
12080 /* Default values. */
12081 if (stubs_always_before_branch)
12082 stub_group_size = 0x1e00000;
12083 else
12084 stub_group_size = 0x1c00000;
12085 suppress_size_errors = TRUE;
12086 }
12087
12088 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12089 {
12090 asection *tail;
12091
12092 if (osec->id >= htab->sec_info_arr_size)
12093 continue;
12094
12095 tail = htab->sec_info[osec->id].u.list;
12096 while (tail != NULL)
12097 {
12098 asection *curr;
12099 asection *prev;
12100 bfd_size_type total;
12101 bfd_boolean big_sec;
12102 bfd_vma curr_toc;
12103 struct map_stub *group;
12104 bfd_size_type group_size;
12105
12106 curr = tail;
12107 total = tail->size;
12108 group_size = (ppc64_elf_section_data (tail) != NULL
12109 && ppc64_elf_section_data (tail)->has_14bit_branch
12110 ? stub_group_size >> 10 : stub_group_size);
12111
12112 big_sec = total > group_size;
12113 if (big_sec && !suppress_size_errors)
12114 /* xgettext:c-format */
12115 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12116 tail->owner, tail);
12117 curr_toc = htab->sec_info[tail->id].toc_off;
12118
12119 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12120 && ((total += curr->output_offset - prev->output_offset)
12121 < (ppc64_elf_section_data (prev) != NULL
12122 && ppc64_elf_section_data (prev)->has_14bit_branch
12123 ? (group_size = stub_group_size >> 10) : group_size))
12124 && htab->sec_info[prev->id].toc_off == curr_toc)
12125 curr = prev;
12126
12127 /* OK, the size from the start of CURR to the end is less
12128 than group_size and thus can be handled by one stub
12129 section. (or the tail section is itself larger than
12130 group_size, in which case we may be toast.) We should
12131 really be keeping track of the total size of stubs added
12132 here, as stubs contribute to the final output section
12133 size. That's a little tricky, and this way will only
12134 break if stubs added make the total size more than 2^25,
12135 ie. for the default stub_group_size, if stubs total more
12136 than 2097152 bytes, or nearly 75000 plt call stubs. */
12137 group = bfd_alloc (curr->owner, sizeof (*group));
12138 if (group == NULL)
12139 return FALSE;
12140 group->link_sec = curr;
12141 group->stub_sec = NULL;
12142 group->needs_save_res = 0;
12143 group->next = htab->group;
12144 htab->group = group;
12145 do
12146 {
12147 prev = htab->sec_info[tail->id].u.list;
12148 /* Set up this stub group. */
12149 htab->sec_info[tail->id].u.group = group;
12150 }
12151 while (tail != curr && (tail = prev) != NULL);
12152
12153 /* But wait, there's more! Input sections up to group_size
12154 bytes before the stub section can be handled by it too.
12155 Don't do this if we have a really large section after the
12156 stubs, as adding more stubs increases the chance that
12157 branches may not reach into the stub section. */
12158 if (!stubs_always_before_branch && !big_sec)
12159 {
12160 total = 0;
12161 while (prev != NULL
12162 && ((total += tail->output_offset - prev->output_offset)
12163 < (ppc64_elf_section_data (prev) != NULL
12164 && ppc64_elf_section_data (prev)->has_14bit_branch
12165 ? (group_size = stub_group_size >> 10) : group_size))
12166 && htab->sec_info[prev->id].toc_off == curr_toc)
12167 {
12168 tail = prev;
12169 prev = htab->sec_info[tail->id].u.list;
12170 htab->sec_info[tail->id].u.group = group;
12171 }
12172 }
12173 tail = prev;
12174 }
12175 }
12176 return TRUE;
12177 }
12178
12179 static const unsigned char glink_eh_frame_cie[] =
12180 {
12181 0, 0, 0, 16, /* length. */
12182 0, 0, 0, 0, /* id. */
12183 1, /* CIE version. */
12184 'z', 'R', 0, /* Augmentation string. */
12185 4, /* Code alignment. */
12186 0x78, /* Data alignment. */
12187 65, /* RA reg. */
12188 1, /* Augmentation size. */
12189 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12190 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12191 0, 0, 0, 0
12192 };
12193
12194 /* Stripping output sections is normally done before dynamic section
12195 symbols have been allocated. This function is called later, and
12196 handles cases like htab->brlt which is mapped to its own output
12197 section. */
12198
12199 static void
12200 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12201 {
12202 if (isec->size == 0
12203 && isec->output_section->size == 0
12204 && !(isec->output_section->flags & SEC_KEEP)
12205 && !bfd_section_removed_from_list (info->output_bfd,
12206 isec->output_section)
12207 && elf_section_data (isec->output_section)->dynindx == 0)
12208 {
12209 isec->output_section->flags |= SEC_EXCLUDE;
12210 bfd_section_list_remove (info->output_bfd, isec->output_section);
12211 info->output_bfd->section_count--;
12212 }
12213 }
12214
12215 /* Determine and set the size of the stub section for a final link.
12216
12217 The basic idea here is to examine all the relocations looking for
12218 PC-relative calls to a target that is unreachable with a "bl"
12219 instruction. */
12220
12221 bfd_boolean
12222 ppc64_elf_size_stubs (struct bfd_link_info *info)
12223 {
12224 bfd_size_type stub_group_size;
12225 bfd_boolean stubs_always_before_branch;
12226 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12227
12228 if (htab == NULL)
12229 return FALSE;
12230
12231 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12232 htab->params->plt_thread_safe = 1;
12233 if (!htab->opd_abi)
12234 htab->params->plt_thread_safe = 0;
12235 else if (htab->params->plt_thread_safe == -1)
12236 {
12237 static const char *const thread_starter[] =
12238 {
12239 "pthread_create",
12240 /* libstdc++ */
12241 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12242 /* librt */
12243 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12244 "mq_notify", "create_timer",
12245 /* libanl */
12246 "getaddrinfo_a",
12247 /* libgomp */
12248 "GOMP_parallel",
12249 "GOMP_parallel_start",
12250 "GOMP_parallel_loop_static",
12251 "GOMP_parallel_loop_static_start",
12252 "GOMP_parallel_loop_dynamic",
12253 "GOMP_parallel_loop_dynamic_start",
12254 "GOMP_parallel_loop_guided",
12255 "GOMP_parallel_loop_guided_start",
12256 "GOMP_parallel_loop_runtime",
12257 "GOMP_parallel_loop_runtime_start",
12258 "GOMP_parallel_sections",
12259 "GOMP_parallel_sections_start",
12260 /* libgo */
12261 "__go_go",
12262 };
12263 unsigned i;
12264
12265 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12266 {
12267 struct elf_link_hash_entry *h;
12268 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12269 FALSE, FALSE, TRUE);
12270 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12271 if (htab->params->plt_thread_safe)
12272 break;
12273 }
12274 }
12275 stubs_always_before_branch = htab->params->group_size < 0;
12276 if (htab->params->group_size < 0)
12277 stub_group_size = -htab->params->group_size;
12278 else
12279 stub_group_size = htab->params->group_size;
12280
12281 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12282 return FALSE;
12283
12284 #define STUB_SHRINK_ITER 20
12285 /* Loop until no stubs added. After iteration 20 of this loop we may
12286 exit on a stub section shrinking. This is to break out of a
12287 pathological case where adding stubs on one iteration decreases
12288 section gaps (perhaps due to alignment), which then requires
12289 fewer or smaller stubs on the next iteration. */
12290
12291 while (1)
12292 {
12293 bfd *input_bfd;
12294 unsigned int bfd_indx;
12295 struct map_stub *group;
12296 asection *stub_sec;
12297
12298 htab->stub_iteration += 1;
12299
12300 for (input_bfd = info->input_bfds, bfd_indx = 0;
12301 input_bfd != NULL;
12302 input_bfd = input_bfd->link.next, bfd_indx++)
12303 {
12304 Elf_Internal_Shdr *symtab_hdr;
12305 asection *section;
12306 Elf_Internal_Sym *local_syms = NULL;
12307
12308 if (!is_ppc64_elf (input_bfd))
12309 continue;
12310
12311 /* We'll need the symbol table in a second. */
12312 symtab_hdr = &elf_symtab_hdr (input_bfd);
12313 if (symtab_hdr->sh_info == 0)
12314 continue;
12315
12316 /* Walk over each section attached to the input bfd. */
12317 for (section = input_bfd->sections;
12318 section != NULL;
12319 section = section->next)
12320 {
12321 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12322
12323 /* If there aren't any relocs, then there's nothing more
12324 to do. */
12325 if ((section->flags & SEC_RELOC) == 0
12326 || (section->flags & SEC_ALLOC) == 0
12327 || (section->flags & SEC_LOAD) == 0
12328 || (section->flags & SEC_CODE) == 0
12329 || section->reloc_count == 0)
12330 continue;
12331
12332 /* If this section is a link-once section that will be
12333 discarded, then don't create any stubs. */
12334 if (section->output_section == NULL
12335 || section->output_section->owner != info->output_bfd)
12336 continue;
12337
12338 /* Get the relocs. */
12339 internal_relocs
12340 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12341 info->keep_memory);
12342 if (internal_relocs == NULL)
12343 goto error_ret_free_local;
12344
12345 /* Now examine each relocation. */
12346 irela = internal_relocs;
12347 irelaend = irela + section->reloc_count;
12348 for (; irela < irelaend; irela++)
12349 {
12350 enum elf_ppc64_reloc_type r_type;
12351 unsigned int r_indx;
12352 enum ppc_stub_type stub_type;
12353 struct ppc_stub_hash_entry *stub_entry;
12354 asection *sym_sec, *code_sec;
12355 bfd_vma sym_value, code_value;
12356 bfd_vma destination;
12357 unsigned long local_off;
12358 bfd_boolean ok_dest;
12359 struct ppc_link_hash_entry *hash;
12360 struct ppc_link_hash_entry *fdh;
12361 struct elf_link_hash_entry *h;
12362 Elf_Internal_Sym *sym;
12363 char *stub_name;
12364 const asection *id_sec;
12365 struct _opd_sec_data *opd;
12366 struct plt_entry *plt_ent;
12367
12368 r_type = ELF64_R_TYPE (irela->r_info);
12369 r_indx = ELF64_R_SYM (irela->r_info);
12370
12371 if (r_type >= R_PPC64_max)
12372 {
12373 bfd_set_error (bfd_error_bad_value);
12374 goto error_ret_free_internal;
12375 }
12376
12377 /* Only look for stubs on branch instructions. */
12378 if (r_type != R_PPC64_REL24
12379 && r_type != R_PPC64_REL14
12380 && r_type != R_PPC64_REL14_BRTAKEN
12381 && r_type != R_PPC64_REL14_BRNTAKEN)
12382 continue;
12383
12384 /* Now determine the call target, its name, value,
12385 section. */
12386 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12387 r_indx, input_bfd))
12388 goto error_ret_free_internal;
12389 hash = (struct ppc_link_hash_entry *) h;
12390
12391 ok_dest = FALSE;
12392 fdh = NULL;
12393 sym_value = 0;
12394 if (hash == NULL)
12395 {
12396 sym_value = sym->st_value;
12397 if (sym_sec != NULL
12398 && sym_sec->output_section != NULL)
12399 ok_dest = TRUE;
12400 }
12401 else if (hash->elf.root.type == bfd_link_hash_defined
12402 || hash->elf.root.type == bfd_link_hash_defweak)
12403 {
12404 sym_value = hash->elf.root.u.def.value;
12405 if (sym_sec->output_section != NULL)
12406 ok_dest = TRUE;
12407 }
12408 else if (hash->elf.root.type == bfd_link_hash_undefweak
12409 || hash->elf.root.type == bfd_link_hash_undefined)
12410 {
12411 /* Recognise an old ABI func code entry sym, and
12412 use the func descriptor sym instead if it is
12413 defined. */
12414 if (hash->elf.root.root.string[0] == '.'
12415 && (fdh = lookup_fdh (hash, htab)) != NULL)
12416 {
12417 if (fdh->elf.root.type == bfd_link_hash_defined
12418 || fdh->elf.root.type == bfd_link_hash_defweak)
12419 {
12420 sym_sec = fdh->elf.root.u.def.section;
12421 sym_value = fdh->elf.root.u.def.value;
12422 if (sym_sec->output_section != NULL)
12423 ok_dest = TRUE;
12424 }
12425 else
12426 fdh = NULL;
12427 }
12428 }
12429 else
12430 {
12431 bfd_set_error (bfd_error_bad_value);
12432 goto error_ret_free_internal;
12433 }
12434
12435 destination = 0;
12436 local_off = 0;
12437 if (ok_dest)
12438 {
12439 sym_value += irela->r_addend;
12440 destination = (sym_value
12441 + sym_sec->output_offset
12442 + sym_sec->output_section->vma);
12443 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12444 ? hash->elf.other
12445 : sym->st_other);
12446 }
12447
12448 code_sec = sym_sec;
12449 code_value = sym_value;
12450 opd = get_opd_info (sym_sec);
12451 if (opd != NULL)
12452 {
12453 bfd_vma dest;
12454
12455 if (hash == NULL && opd->adjust != NULL)
12456 {
12457 long adjust = opd->adjust[OPD_NDX (sym_value)];
12458 if (adjust == -1)
12459 continue;
12460 code_value += adjust;
12461 sym_value += adjust;
12462 }
12463 dest = opd_entry_value (sym_sec, sym_value,
12464 &code_sec, &code_value, FALSE);
12465 if (dest != (bfd_vma) -1)
12466 {
12467 destination = dest;
12468 if (fdh != NULL)
12469 {
12470 /* Fixup old ABI sym to point at code
12471 entry. */
12472 hash->elf.root.type = bfd_link_hash_defweak;
12473 hash->elf.root.u.def.section = code_sec;
12474 hash->elf.root.u.def.value = code_value;
12475 }
12476 }
12477 }
12478
12479 /* Determine what (if any) linker stub is needed. */
12480 plt_ent = NULL;
12481 stub_type = ppc_type_of_stub (section, irela, &hash,
12482 &plt_ent, destination,
12483 local_off);
12484
12485 if (stub_type != ppc_stub_plt_call)
12486 {
12487 /* Check whether we need a TOC adjusting stub.
12488 Since the linker pastes together pieces from
12489 different object files when creating the
12490 _init and _fini functions, it may be that a
12491 call to what looks like a local sym is in
12492 fact a call needing a TOC adjustment. */
12493 if (code_sec != NULL
12494 && code_sec->output_section != NULL
12495 && (htab->sec_info[code_sec->id].toc_off
12496 != htab->sec_info[section->id].toc_off)
12497 && (code_sec->has_toc_reloc
12498 || code_sec->makes_toc_func_call))
12499 stub_type = ppc_stub_long_branch_r2off;
12500 }
12501
12502 if (stub_type == ppc_stub_none)
12503 continue;
12504
12505 /* __tls_get_addr calls might be eliminated. */
12506 if (stub_type != ppc_stub_plt_call
12507 && hash != NULL
12508 && (hash == htab->tls_get_addr
12509 || hash == htab->tls_get_addr_fd)
12510 && section->has_tls_reloc
12511 && irela != internal_relocs)
12512 {
12513 /* Get tls info. */
12514 unsigned char *tls_mask;
12515
12516 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12517 irela - 1, input_bfd))
12518 goto error_ret_free_internal;
12519 if (*tls_mask != 0)
12520 continue;
12521 }
12522
12523 if (stub_type == ppc_stub_plt_call
12524 && irela + 1 < irelaend
12525 && irela[1].r_offset == irela->r_offset + 4
12526 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12527 {
12528 if (!tocsave_find (htab, INSERT,
12529 &local_syms, irela + 1, input_bfd))
12530 goto error_ret_free_internal;
12531 }
12532 else if (stub_type == ppc_stub_plt_call)
12533 stub_type = ppc_stub_plt_call_r2save;
12534
12535 /* Support for grouping stub sections. */
12536 id_sec = htab->sec_info[section->id].u.group->link_sec;
12537
12538 /* Get the name of this stub. */
12539 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12540 if (!stub_name)
12541 goto error_ret_free_internal;
12542
12543 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12544 stub_name, FALSE, FALSE);
12545 if (stub_entry != NULL)
12546 {
12547 /* The proper stub has already been created. */
12548 free (stub_name);
12549 if (stub_type == ppc_stub_plt_call_r2save)
12550 stub_entry->stub_type = stub_type;
12551 continue;
12552 }
12553
12554 stub_entry = ppc_add_stub (stub_name, section, info);
12555 if (stub_entry == NULL)
12556 {
12557 free (stub_name);
12558 error_ret_free_internal:
12559 if (elf_section_data (section)->relocs == NULL)
12560 free (internal_relocs);
12561 error_ret_free_local:
12562 if (local_syms != NULL
12563 && (symtab_hdr->contents
12564 != (unsigned char *) local_syms))
12565 free (local_syms);
12566 return FALSE;
12567 }
12568
12569 stub_entry->stub_type = stub_type;
12570 if (stub_type != ppc_stub_plt_call
12571 && stub_type != ppc_stub_plt_call_r2save)
12572 {
12573 stub_entry->target_value = code_value;
12574 stub_entry->target_section = code_sec;
12575 }
12576 else
12577 {
12578 stub_entry->target_value = sym_value;
12579 stub_entry->target_section = sym_sec;
12580 }
12581 stub_entry->h = hash;
12582 stub_entry->plt_ent = plt_ent;
12583 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12584
12585 if (stub_entry->h != NULL)
12586 htab->stub_globals += 1;
12587 }
12588
12589 /* We're done with the internal relocs, free them. */
12590 if (elf_section_data (section)->relocs != internal_relocs)
12591 free (internal_relocs);
12592 }
12593
12594 if (local_syms != NULL
12595 && symtab_hdr->contents != (unsigned char *) local_syms)
12596 {
12597 if (!info->keep_memory)
12598 free (local_syms);
12599 else
12600 symtab_hdr->contents = (unsigned char *) local_syms;
12601 }
12602 }
12603
12604 /* We may have added some stubs. Find out the new size of the
12605 stub sections. */
12606 for (stub_sec = htab->params->stub_bfd->sections;
12607 stub_sec != NULL;
12608 stub_sec = stub_sec->next)
12609 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12610 {
12611 if (htab->stub_iteration <= STUB_SHRINK_ITER
12612 || stub_sec->rawsize < stub_sec->size)
12613 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12614 stub_sec->rawsize = stub_sec->size;
12615 stub_sec->size = 0;
12616 stub_sec->reloc_count = 0;
12617 stub_sec->flags &= ~SEC_RELOC;
12618 }
12619
12620 htab->brlt->size = 0;
12621 htab->brlt->reloc_count = 0;
12622 htab->brlt->flags &= ~SEC_RELOC;
12623 if (htab->relbrlt != NULL)
12624 htab->relbrlt->size = 0;
12625
12626 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12627
12628 for (group = htab->group; group != NULL; group = group->next)
12629 if (group->needs_save_res)
12630 group->stub_sec->size += htab->sfpr->size;
12631
12632 if (info->emitrelocations
12633 && htab->glink != NULL && htab->glink->size != 0)
12634 {
12635 htab->glink->reloc_count = 1;
12636 htab->glink->flags |= SEC_RELOC;
12637 }
12638
12639 if (htab->glink_eh_frame != NULL
12640 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12641 && htab->glink_eh_frame->output_section->size != 0)
12642 {
12643 size_t size = 0, align;
12644
12645 for (stub_sec = htab->params->stub_bfd->sections;
12646 stub_sec != NULL;
12647 stub_sec = stub_sec->next)
12648 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12649 size += 24;
12650 if (htab->glink != NULL && htab->glink->size != 0)
12651 size += 24;
12652 if (size != 0)
12653 size += sizeof (glink_eh_frame_cie);
12654 align = 1;
12655 align <<= htab->glink_eh_frame->output_section->alignment_power;
12656 align -= 1;
12657 size = (size + align) & ~align;
12658 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12659 htab->glink_eh_frame->size = size;
12660 }
12661
12662 if (htab->params->plt_stub_align != 0)
12663 for (stub_sec = htab->params->stub_bfd->sections;
12664 stub_sec != NULL;
12665 stub_sec = stub_sec->next)
12666 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12667 stub_sec->size = ((stub_sec->size
12668 + (1 << htab->params->plt_stub_align) - 1)
12669 & -(1 << htab->params->plt_stub_align));
12670
12671 for (stub_sec = htab->params->stub_bfd->sections;
12672 stub_sec != NULL;
12673 stub_sec = stub_sec->next)
12674 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12675 && stub_sec->rawsize != stub_sec->size
12676 && (htab->stub_iteration <= STUB_SHRINK_ITER
12677 || stub_sec->rawsize < stub_sec->size))
12678 break;
12679
12680 if (stub_sec == NULL
12681 && (htab->glink_eh_frame == NULL
12682 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12683 break;
12684
12685 /* Ask the linker to do its stuff. */
12686 (*htab->params->layout_sections_again) ();
12687 }
12688
12689 if (htab->glink_eh_frame != NULL
12690 && htab->glink_eh_frame->size != 0)
12691 {
12692 bfd_vma val;
12693 bfd_byte *p, *last_fde;
12694 size_t last_fde_len, size, align, pad;
12695 asection *stub_sec;
12696
12697 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12698 if (p == NULL)
12699 return FALSE;
12700 htab->glink_eh_frame->contents = p;
12701 last_fde = p;
12702
12703 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12704 /* CIE length (rewrite in case little-endian). */
12705 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12706 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12707 p += sizeof (glink_eh_frame_cie);
12708
12709 for (stub_sec = htab->params->stub_bfd->sections;
12710 stub_sec != NULL;
12711 stub_sec = stub_sec->next)
12712 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12713 {
12714 last_fde = p;
12715 last_fde_len = 20;
12716 /* FDE length. */
12717 bfd_put_32 (htab->elf.dynobj, 20, p);
12718 p += 4;
12719 /* CIE pointer. */
12720 val = p - htab->glink_eh_frame->contents;
12721 bfd_put_32 (htab->elf.dynobj, val, p);
12722 p += 4;
12723 /* Offset to stub section, written later. */
12724 p += 4;
12725 /* stub section size. */
12726 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12727 p += 4;
12728 /* Augmentation. */
12729 p += 1;
12730 /* Pad. */
12731 p += 7;
12732 }
12733 if (htab->glink != NULL && htab->glink->size != 0)
12734 {
12735 last_fde = p;
12736 last_fde_len = 20;
12737 /* FDE length. */
12738 bfd_put_32 (htab->elf.dynobj, 20, p);
12739 p += 4;
12740 /* CIE pointer. */
12741 val = p - htab->glink_eh_frame->contents;
12742 bfd_put_32 (htab->elf.dynobj, val, p);
12743 p += 4;
12744 /* Offset to .glink, written later. */
12745 p += 4;
12746 /* .glink size. */
12747 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12748 p += 4;
12749 /* Augmentation. */
12750 p += 1;
12751
12752 *p++ = DW_CFA_advance_loc + 1;
12753 *p++ = DW_CFA_register;
12754 *p++ = 65;
12755 *p++ = htab->opd_abi ? 12 : 0;
12756 *p++ = DW_CFA_advance_loc + 4;
12757 *p++ = DW_CFA_restore_extended;
12758 *p++ = 65;
12759 }
12760 /* Subsume any padding into the last FDE if user .eh_frame
12761 sections are aligned more than glink_eh_frame. Otherwise any
12762 zero padding will be seen as a terminator. */
12763 size = p - htab->glink_eh_frame->contents;
12764 align = 1;
12765 align <<= htab->glink_eh_frame->output_section->alignment_power;
12766 align -= 1;
12767 pad = ((size + align) & ~align) - size;
12768 htab->glink_eh_frame->size = size + pad;
12769 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12770 }
12771
12772 maybe_strip_output (info, htab->brlt);
12773 if (htab->glink_eh_frame != NULL)
12774 maybe_strip_output (info, htab->glink_eh_frame);
12775
12776 return TRUE;
12777 }
12778
12779 /* Called after we have determined section placement. If sections
12780 move, we'll be called again. Provide a value for TOCstart. */
12781
12782 bfd_vma
12783 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12784 {
12785 asection *s;
12786 bfd_vma TOCstart, adjust;
12787
12788 if (info != NULL)
12789 {
12790 struct elf_link_hash_entry *h;
12791 struct elf_link_hash_table *htab = elf_hash_table (info);
12792
12793 if (is_elf_hash_table (htab)
12794 && htab->hgot != NULL)
12795 h = htab->hgot;
12796 else
12797 {
12798 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12799 if (is_elf_hash_table (htab))
12800 htab->hgot = h;
12801 }
12802 if (h != NULL
12803 && h->root.type == bfd_link_hash_defined
12804 && !h->root.linker_def
12805 && (!is_elf_hash_table (htab)
12806 || h->def_regular))
12807 {
12808 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12809 + h->root.u.def.section->output_offset
12810 + h->root.u.def.section->output_section->vma);
12811 _bfd_set_gp_value (obfd, TOCstart);
12812 return TOCstart;
12813 }
12814 }
12815
12816 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12817 order. The TOC starts where the first of these sections starts. */
12818 s = bfd_get_section_by_name (obfd, ".got");
12819 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12820 s = bfd_get_section_by_name (obfd, ".toc");
12821 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12822 s = bfd_get_section_by_name (obfd, ".tocbss");
12823 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12824 s = bfd_get_section_by_name (obfd, ".plt");
12825 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12826 {
12827 /* This may happen for
12828 o references to TOC base (SYM@toc / TOC[tc0]) without a
12829 .toc directive
12830 o bad linker script
12831 o --gc-sections and empty TOC sections
12832
12833 FIXME: Warn user? */
12834
12835 /* Look for a likely section. We probably won't even be
12836 using TOCstart. */
12837 for (s = obfd->sections; s != NULL; s = s->next)
12838 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12839 | SEC_EXCLUDE))
12840 == (SEC_ALLOC | SEC_SMALL_DATA))
12841 break;
12842 if (s == NULL)
12843 for (s = obfd->sections; s != NULL; s = s->next)
12844 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12845 == (SEC_ALLOC | SEC_SMALL_DATA))
12846 break;
12847 if (s == NULL)
12848 for (s = obfd->sections; s != NULL; s = s->next)
12849 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12850 == SEC_ALLOC)
12851 break;
12852 if (s == NULL)
12853 for (s = obfd->sections; s != NULL; s = s->next)
12854 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12855 break;
12856 }
12857
12858 TOCstart = 0;
12859 if (s != NULL)
12860 TOCstart = s->output_section->vma + s->output_offset;
12861
12862 /* Force alignment. */
12863 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12864 TOCstart -= adjust;
12865 _bfd_set_gp_value (obfd, TOCstart);
12866
12867 if (info != NULL && s != NULL)
12868 {
12869 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12870
12871 if (htab != NULL)
12872 {
12873 if (htab->elf.hgot != NULL)
12874 {
12875 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12876 htab->elf.hgot->root.u.def.section = s;
12877 }
12878 }
12879 else
12880 {
12881 struct bfd_link_hash_entry *bh = NULL;
12882 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12883 s, TOC_BASE_OFF - adjust,
12884 NULL, FALSE, FALSE, &bh);
12885 }
12886 }
12887 return TOCstart;
12888 }
12889
12890 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12891 write out any global entry stubs. */
12892
12893 static bfd_boolean
12894 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12895 {
12896 struct bfd_link_info *info;
12897 struct ppc_link_hash_table *htab;
12898 struct plt_entry *pent;
12899 asection *s;
12900
12901 if (h->root.type == bfd_link_hash_indirect)
12902 return TRUE;
12903
12904 if (!h->pointer_equality_needed)
12905 return TRUE;
12906
12907 if (h->def_regular)
12908 return TRUE;
12909
12910 info = inf;
12911 htab = ppc_hash_table (info);
12912 if (htab == NULL)
12913 return FALSE;
12914
12915 s = htab->glink;
12916 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12917 if (pent->plt.offset != (bfd_vma) -1
12918 && pent->addend == 0)
12919 {
12920 bfd_byte *p;
12921 asection *plt;
12922 bfd_vma off;
12923
12924 p = s->contents + h->root.u.def.value;
12925 plt = htab->elf.splt;
12926 if (!htab->elf.dynamic_sections_created
12927 || h->dynindx == -1)
12928 plt = htab->elf.iplt;
12929 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12930 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12931
12932 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12933 {
12934 info->callbacks->einfo
12935 (_("%P: linkage table error against `%T'\n"),
12936 h->root.root.string);
12937 bfd_set_error (bfd_error_bad_value);
12938 htab->stub_error = TRUE;
12939 }
12940
12941 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12942 if (htab->params->emit_stub_syms)
12943 {
12944 size_t len = strlen (h->root.root.string);
12945 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12946
12947 if (name == NULL)
12948 return FALSE;
12949
12950 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12951 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12952 if (h == NULL)
12953 return FALSE;
12954 if (h->root.type == bfd_link_hash_new)
12955 {
12956 h->root.type = bfd_link_hash_defined;
12957 h->root.u.def.section = s;
12958 h->root.u.def.value = p - s->contents;
12959 h->ref_regular = 1;
12960 h->def_regular = 1;
12961 h->ref_regular_nonweak = 1;
12962 h->forced_local = 1;
12963 h->non_elf = 0;
12964 h->root.linker_def = 1;
12965 }
12966 }
12967
12968 if (PPC_HA (off) != 0)
12969 {
12970 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12971 p += 4;
12972 }
12973 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12974 p += 4;
12975 bfd_put_32 (s->owner, MTCTR_R12, p);
12976 p += 4;
12977 bfd_put_32 (s->owner, BCTR, p);
12978 break;
12979 }
12980 return TRUE;
12981 }
12982
12983 /* Build all the stubs associated with the current output file.
12984 The stubs are kept in a hash table attached to the main linker
12985 hash table. This function is called via gldelf64ppc_finish. */
12986
12987 bfd_boolean
12988 ppc64_elf_build_stubs (struct bfd_link_info *info,
12989 char **stats)
12990 {
12991 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12992 struct map_stub *group;
12993 asection *stub_sec;
12994 bfd_byte *p;
12995 int stub_sec_count = 0;
12996
12997 if (htab == NULL)
12998 return FALSE;
12999
13000 /* Allocate memory to hold the linker stubs. */
13001 for (stub_sec = htab->params->stub_bfd->sections;
13002 stub_sec != NULL;
13003 stub_sec = stub_sec->next)
13004 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13005 && stub_sec->size != 0)
13006 {
13007 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13008 if (stub_sec->contents == NULL)
13009 return FALSE;
13010 stub_sec->size = 0;
13011 }
13012
13013 if (htab->glink != NULL && htab->glink->size != 0)
13014 {
13015 unsigned int indx;
13016 bfd_vma plt0;
13017
13018 /* Build the .glink plt call stub. */
13019 if (htab->params->emit_stub_syms)
13020 {
13021 struct elf_link_hash_entry *h;
13022 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13023 TRUE, FALSE, FALSE);
13024 if (h == NULL)
13025 return FALSE;
13026 if (h->root.type == bfd_link_hash_new)
13027 {
13028 h->root.type = bfd_link_hash_defined;
13029 h->root.u.def.section = htab->glink;
13030 h->root.u.def.value = 8;
13031 h->ref_regular = 1;
13032 h->def_regular = 1;
13033 h->ref_regular_nonweak = 1;
13034 h->forced_local = 1;
13035 h->non_elf = 0;
13036 h->root.linker_def = 1;
13037 }
13038 }
13039 plt0 = (htab->elf.splt->output_section->vma
13040 + htab->elf.splt->output_offset
13041 - 16);
13042 if (info->emitrelocations)
13043 {
13044 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13045 if (r == NULL)
13046 return FALSE;
13047 r->r_offset = (htab->glink->output_offset
13048 + htab->glink->output_section->vma);
13049 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13050 r->r_addend = plt0;
13051 }
13052 p = htab->glink->contents;
13053 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13054 bfd_put_64 (htab->glink->owner, plt0, p);
13055 p += 8;
13056 if (htab->opd_abi)
13057 {
13058 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13059 p += 4;
13060 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13061 p += 4;
13062 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13063 p += 4;
13064 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13065 p += 4;
13066 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13067 p += 4;
13068 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13069 p += 4;
13070 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13071 p += 4;
13072 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13073 p += 4;
13074 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13075 p += 4;
13076 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13077 p += 4;
13078 }
13079 else
13080 {
13081 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13082 p += 4;
13083 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13084 p += 4;
13085 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13086 p += 4;
13087 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13088 p += 4;
13089 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13090 p += 4;
13091 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13092 p += 4;
13093 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13094 p += 4;
13095 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13096 p += 4;
13097 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13098 p += 4;
13099 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13100 p += 4;
13101 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13102 p += 4;
13103 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13104 p += 4;
13105 }
13106 bfd_put_32 (htab->glink->owner, BCTR, p);
13107 p += 4;
13108 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13109 {
13110 bfd_put_32 (htab->glink->owner, NOP, p);
13111 p += 4;
13112 }
13113
13114 /* Build the .glink lazy link call stubs. */
13115 indx = 0;
13116 while (p < htab->glink->contents + htab->glink->rawsize)
13117 {
13118 if (htab->opd_abi)
13119 {
13120 if (indx < 0x8000)
13121 {
13122 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13123 p += 4;
13124 }
13125 else
13126 {
13127 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13128 p += 4;
13129 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13130 p);
13131 p += 4;
13132 }
13133 }
13134 bfd_put_32 (htab->glink->owner,
13135 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13136 indx++;
13137 p += 4;
13138 }
13139
13140 /* Build .glink global entry stubs. */
13141 if (htab->glink->size > htab->glink->rawsize)
13142 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13143 }
13144
13145 if (htab->brlt != NULL && htab->brlt->size != 0)
13146 {
13147 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13148 htab->brlt->size);
13149 if (htab->brlt->contents == NULL)
13150 return FALSE;
13151 }
13152 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13153 {
13154 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13155 htab->relbrlt->size);
13156 if (htab->relbrlt->contents == NULL)
13157 return FALSE;
13158 }
13159
13160 /* Build the stubs as directed by the stub hash table. */
13161 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13162
13163 for (group = htab->group; group != NULL; group = group->next)
13164 if (group->needs_save_res)
13165 {
13166 stub_sec = group->stub_sec;
13167 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13168 htab->sfpr->size);
13169 if (htab->params->emit_stub_syms)
13170 {
13171 unsigned int i;
13172
13173 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13174 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13175 return FALSE;
13176 }
13177 stub_sec->size += htab->sfpr->size;
13178 }
13179
13180 if (htab->relbrlt != NULL)
13181 htab->relbrlt->reloc_count = 0;
13182
13183 if (htab->params->plt_stub_align != 0)
13184 for (stub_sec = htab->params->stub_bfd->sections;
13185 stub_sec != NULL;
13186 stub_sec = stub_sec->next)
13187 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13188 stub_sec->size = ((stub_sec->size
13189 + (1 << htab->params->plt_stub_align) - 1)
13190 & -(1 << htab->params->plt_stub_align));
13191
13192 for (stub_sec = htab->params->stub_bfd->sections;
13193 stub_sec != NULL;
13194 stub_sec = stub_sec->next)
13195 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13196 {
13197 stub_sec_count += 1;
13198 if (stub_sec->rawsize != stub_sec->size
13199 && (htab->stub_iteration <= STUB_SHRINK_ITER
13200 || stub_sec->rawsize < stub_sec->size))
13201 break;
13202 }
13203
13204 /* Note that the glink_eh_frame check here is not only testing that
13205 the generated size matched the calculated size but also that
13206 bfd_elf_discard_info didn't make any changes to the section. */
13207 if (stub_sec != NULL
13208 || (htab->glink_eh_frame != NULL
13209 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13210 {
13211 htab->stub_error = TRUE;
13212 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13213 }
13214
13215 if (htab->stub_error)
13216 return FALSE;
13217
13218 if (stats != NULL)
13219 {
13220 *stats = bfd_malloc (500);
13221 if (*stats == NULL)
13222 return FALSE;
13223
13224 sprintf (*stats, _("linker stubs in %u group%s\n"
13225 " branch %lu\n"
13226 " toc adjust %lu\n"
13227 " long branch %lu\n"
13228 " long toc adj %lu\n"
13229 " plt call %lu\n"
13230 " plt call toc %lu\n"
13231 " global entry %lu"),
13232 stub_sec_count,
13233 stub_sec_count == 1 ? "" : "s",
13234 htab->stub_count[ppc_stub_long_branch - 1],
13235 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13236 htab->stub_count[ppc_stub_plt_branch - 1],
13237 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13238 htab->stub_count[ppc_stub_plt_call - 1],
13239 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13240 htab->stub_count[ppc_stub_global_entry - 1]);
13241 }
13242 return TRUE;
13243 }
13244
13245 /* This function undoes the changes made by add_symbol_adjust. */
13246
13247 static bfd_boolean
13248 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13249 {
13250 struct ppc_link_hash_entry *eh;
13251
13252 if (h->root.type == bfd_link_hash_indirect)
13253 return TRUE;
13254
13255 eh = (struct ppc_link_hash_entry *) h;
13256 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13257 return TRUE;
13258
13259 eh->elf.root.type = bfd_link_hash_undefined;
13260 return TRUE;
13261 }
13262
13263 void
13264 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13265 {
13266 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13267
13268 if (htab != NULL)
13269 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13270 }
13271
13272 /* What to do when ld finds relocations against symbols defined in
13273 discarded sections. */
13274
13275 static unsigned int
13276 ppc64_elf_action_discarded (asection *sec)
13277 {
13278 if (strcmp (".opd", sec->name) == 0)
13279 return 0;
13280
13281 if (strcmp (".toc", sec->name) == 0)
13282 return 0;
13283
13284 if (strcmp (".toc1", sec->name) == 0)
13285 return 0;
13286
13287 return _bfd_elf_default_action_discarded (sec);
13288 }
13289
13290 /* The RELOCATE_SECTION function is called by the ELF backend linker
13291 to handle the relocations for a section.
13292
13293 The relocs are always passed as Rela structures; if the section
13294 actually uses Rel structures, the r_addend field will always be
13295 zero.
13296
13297 This function is responsible for adjust the section contents as
13298 necessary, and (if using Rela relocs and generating a
13299 relocatable output file) adjusting the reloc addend as
13300 necessary.
13301
13302 This function does not have to worry about setting the reloc
13303 address or the reloc symbol index.
13304
13305 LOCAL_SYMS is a pointer to the swapped in local symbols.
13306
13307 LOCAL_SECTIONS is an array giving the section in the input file
13308 corresponding to the st_shndx field of each local symbol.
13309
13310 The global hash table entry for the global symbols can be found
13311 via elf_sym_hashes (input_bfd).
13312
13313 When generating relocatable output, this function must handle
13314 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13315 going to be the section symbol corresponding to the output
13316 section, which means that the addend must be adjusted
13317 accordingly. */
13318
13319 static bfd_boolean
13320 ppc64_elf_relocate_section (bfd *output_bfd,
13321 struct bfd_link_info *info,
13322 bfd *input_bfd,
13323 asection *input_section,
13324 bfd_byte *contents,
13325 Elf_Internal_Rela *relocs,
13326 Elf_Internal_Sym *local_syms,
13327 asection **local_sections)
13328 {
13329 struct ppc_link_hash_table *htab;
13330 Elf_Internal_Shdr *symtab_hdr;
13331 struct elf_link_hash_entry **sym_hashes;
13332 Elf_Internal_Rela *rel;
13333 Elf_Internal_Rela *wrel;
13334 Elf_Internal_Rela *relend;
13335 Elf_Internal_Rela outrel;
13336 bfd_byte *loc;
13337 struct got_entry **local_got_ents;
13338 bfd_vma TOCstart;
13339 bfd_boolean ret = TRUE;
13340 bfd_boolean is_opd;
13341 /* Assume 'at' branch hints. */
13342 bfd_boolean is_isa_v2 = TRUE;
13343 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13344
13345 /* Initialize howto table if needed. */
13346 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13347 ppc_howto_init ();
13348
13349 htab = ppc_hash_table (info);
13350 if (htab == NULL)
13351 return FALSE;
13352
13353 /* Don't relocate stub sections. */
13354 if (input_section->owner == htab->params->stub_bfd)
13355 return TRUE;
13356
13357 BFD_ASSERT (is_ppc64_elf (input_bfd));
13358
13359 local_got_ents = elf_local_got_ents (input_bfd);
13360 TOCstart = elf_gp (output_bfd);
13361 symtab_hdr = &elf_symtab_hdr (input_bfd);
13362 sym_hashes = elf_sym_hashes (input_bfd);
13363 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13364
13365 rel = wrel = relocs;
13366 relend = relocs + input_section->reloc_count;
13367 for (; rel < relend; wrel++, rel++)
13368 {
13369 enum elf_ppc64_reloc_type r_type;
13370 bfd_vma addend;
13371 bfd_reloc_status_type r;
13372 Elf_Internal_Sym *sym;
13373 asection *sec;
13374 struct elf_link_hash_entry *h_elf;
13375 struct ppc_link_hash_entry *h;
13376 struct ppc_link_hash_entry *fdh;
13377 const char *sym_name;
13378 unsigned long r_symndx, toc_symndx;
13379 bfd_vma toc_addend;
13380 unsigned char tls_mask, tls_gd, tls_type;
13381 unsigned char sym_type;
13382 bfd_vma relocation;
13383 bfd_boolean unresolved_reloc;
13384 bfd_boolean warned;
13385 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13386 unsigned int insn;
13387 unsigned int mask;
13388 struct ppc_stub_hash_entry *stub_entry;
13389 bfd_vma max_br_offset;
13390 bfd_vma from;
13391 Elf_Internal_Rela orig_rel;
13392 reloc_howto_type *howto;
13393 struct reloc_howto_struct alt_howto;
13394
13395 again:
13396 orig_rel = *rel;
13397
13398 r_type = ELF64_R_TYPE (rel->r_info);
13399 r_symndx = ELF64_R_SYM (rel->r_info);
13400
13401 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13402 symbol of the previous ADDR64 reloc. The symbol gives us the
13403 proper TOC base to use. */
13404 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13405 && wrel != relocs
13406 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13407 && is_opd)
13408 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13409
13410 sym = NULL;
13411 sec = NULL;
13412 h_elf = NULL;
13413 sym_name = NULL;
13414 unresolved_reloc = FALSE;
13415 warned = FALSE;
13416
13417 if (r_symndx < symtab_hdr->sh_info)
13418 {
13419 /* It's a local symbol. */
13420 struct _opd_sec_data *opd;
13421
13422 sym = local_syms + r_symndx;
13423 sec = local_sections[r_symndx];
13424 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13425 sym_type = ELF64_ST_TYPE (sym->st_info);
13426 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13427 opd = get_opd_info (sec);
13428 if (opd != NULL && opd->adjust != NULL)
13429 {
13430 long adjust = opd->adjust[OPD_NDX (sym->st_value
13431 + rel->r_addend)];
13432 if (adjust == -1)
13433 relocation = 0;
13434 else
13435 {
13436 /* If this is a relocation against the opd section sym
13437 and we have edited .opd, adjust the reloc addend so
13438 that ld -r and ld --emit-relocs output is correct.
13439 If it is a reloc against some other .opd symbol,
13440 then the symbol value will be adjusted later. */
13441 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13442 rel->r_addend += adjust;
13443 else
13444 relocation += adjust;
13445 }
13446 }
13447 }
13448 else
13449 {
13450 bfd_boolean ignored;
13451
13452 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13453 r_symndx, symtab_hdr, sym_hashes,
13454 h_elf, sec, relocation,
13455 unresolved_reloc, warned, ignored);
13456 sym_name = h_elf->root.root.string;
13457 sym_type = h_elf->type;
13458 if (sec != NULL
13459 && sec->owner == output_bfd
13460 && strcmp (sec->name, ".opd") == 0)
13461 {
13462 /* This is a symbol defined in a linker script. All
13463 such are defined in output sections, even those
13464 defined by simple assignment from a symbol defined in
13465 an input section. Transfer the symbol to an
13466 appropriate input .opd section, so that a branch to
13467 this symbol will be mapped to the location specified
13468 by the opd entry. */
13469 struct bfd_link_order *lo;
13470 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13471 if (lo->type == bfd_indirect_link_order)
13472 {
13473 asection *isec = lo->u.indirect.section;
13474 if (h_elf->root.u.def.value >= isec->output_offset
13475 && h_elf->root.u.def.value < (isec->output_offset
13476 + isec->size))
13477 {
13478 h_elf->root.u.def.value -= isec->output_offset;
13479 h_elf->root.u.def.section = isec;
13480 sec = isec;
13481 break;
13482 }
13483 }
13484 }
13485 }
13486 h = (struct ppc_link_hash_entry *) h_elf;
13487
13488 if (sec != NULL && discarded_section (sec))
13489 {
13490 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13491 input_bfd, input_section,
13492 contents + rel->r_offset);
13493 wrel->r_offset = rel->r_offset;
13494 wrel->r_info = 0;
13495 wrel->r_addend = 0;
13496
13497 /* For ld -r, remove relocations in debug sections against
13498 sections defined in discarded sections. Not done for
13499 non-debug to preserve relocs in .eh_frame which the
13500 eh_frame editing code expects to be present. */
13501 if (bfd_link_relocatable (info)
13502 && (input_section->flags & SEC_DEBUGGING))
13503 wrel--;
13504
13505 continue;
13506 }
13507
13508 if (bfd_link_relocatable (info))
13509 goto copy_reloc;
13510
13511 if (h != NULL && &h->elf == htab->elf.hgot)
13512 {
13513 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13514 sec = bfd_abs_section_ptr;
13515 unresolved_reloc = FALSE;
13516 }
13517
13518 /* TLS optimizations. Replace instruction sequences and relocs
13519 based on information we collected in tls_optimize. We edit
13520 RELOCS so that --emit-relocs will output something sensible
13521 for the final instruction stream. */
13522 tls_mask = 0;
13523 tls_gd = 0;
13524 toc_symndx = 0;
13525 if (h != NULL)
13526 tls_mask = h->tls_mask;
13527 else if (local_got_ents != NULL)
13528 {
13529 struct plt_entry **local_plt = (struct plt_entry **)
13530 (local_got_ents + symtab_hdr->sh_info);
13531 unsigned char *lgot_masks = (unsigned char *)
13532 (local_plt + symtab_hdr->sh_info);
13533 tls_mask = lgot_masks[r_symndx];
13534 }
13535 if (tls_mask == 0
13536 && (r_type == R_PPC64_TLS
13537 || r_type == R_PPC64_TLSGD
13538 || r_type == R_PPC64_TLSLD))
13539 {
13540 /* Check for toc tls entries. */
13541 unsigned char *toc_tls;
13542
13543 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13544 &local_syms, rel, input_bfd))
13545 return FALSE;
13546
13547 if (toc_tls)
13548 tls_mask = *toc_tls;
13549 }
13550
13551 /* Check that tls relocs are used with tls syms, and non-tls
13552 relocs are used with non-tls syms. */
13553 if (r_symndx != STN_UNDEF
13554 && r_type != R_PPC64_NONE
13555 && (h == NULL
13556 || h->elf.root.type == bfd_link_hash_defined
13557 || h->elf.root.type == bfd_link_hash_defweak)
13558 && (IS_PPC64_TLS_RELOC (r_type)
13559 != (sym_type == STT_TLS
13560 || (sym_type == STT_SECTION
13561 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13562 {
13563 if (tls_mask != 0
13564 && (r_type == R_PPC64_TLS
13565 || r_type == R_PPC64_TLSGD
13566 || r_type == R_PPC64_TLSLD))
13567 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13568 ;
13569 else
13570 info->callbacks->einfo
13571 (!IS_PPC64_TLS_RELOC (r_type)
13572 /* xgettext:c-format */
13573 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13574 /* xgettext:c-format */
13575 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13576 input_bfd, input_section, rel->r_offset,
13577 ppc64_elf_howto_table[r_type]->name,
13578 sym_name);
13579 }
13580
13581 /* Ensure reloc mapping code below stays sane. */
13582 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13583 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13584 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13585 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13586 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13587 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13588 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13589 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13590 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13591 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13592 abort ();
13593
13594 switch (r_type)
13595 {
13596 default:
13597 break;
13598
13599 case R_PPC64_LO_DS_OPT:
13600 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13601 if ((insn & (0x3f << 26)) != 58u << 26)
13602 abort ();
13603 insn += (14u << 26) - (58u << 26);
13604 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13605 r_type = R_PPC64_TOC16_LO;
13606 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13607 break;
13608
13609 case R_PPC64_TOC16:
13610 case R_PPC64_TOC16_LO:
13611 case R_PPC64_TOC16_DS:
13612 case R_PPC64_TOC16_LO_DS:
13613 {
13614 /* Check for toc tls entries. */
13615 unsigned char *toc_tls;
13616 int retval;
13617
13618 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13619 &local_syms, rel, input_bfd);
13620 if (retval == 0)
13621 return FALSE;
13622
13623 if (toc_tls)
13624 {
13625 tls_mask = *toc_tls;
13626 if (r_type == R_PPC64_TOC16_DS
13627 || r_type == R_PPC64_TOC16_LO_DS)
13628 {
13629 if (tls_mask != 0
13630 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13631 goto toctprel;
13632 }
13633 else
13634 {
13635 /* If we found a GD reloc pair, then we might be
13636 doing a GD->IE transition. */
13637 if (retval == 2)
13638 {
13639 tls_gd = TLS_TPRELGD;
13640 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13641 goto tls_ldgd_opt;
13642 }
13643 else if (retval == 3)
13644 {
13645 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13646 goto tls_ldgd_opt;
13647 }
13648 }
13649 }
13650 }
13651 break;
13652
13653 case R_PPC64_GOT_TPREL16_HI:
13654 case R_PPC64_GOT_TPREL16_HA:
13655 if (tls_mask != 0
13656 && (tls_mask & TLS_TPREL) == 0)
13657 {
13658 rel->r_offset -= d_offset;
13659 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13660 r_type = R_PPC64_NONE;
13661 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13662 }
13663 break;
13664
13665 case R_PPC64_GOT_TPREL16_DS:
13666 case R_PPC64_GOT_TPREL16_LO_DS:
13667 if (tls_mask != 0
13668 && (tls_mask & TLS_TPREL) == 0)
13669 {
13670 toctprel:
13671 insn = bfd_get_32 (input_bfd,
13672 contents + rel->r_offset - d_offset);
13673 insn &= 31 << 21;
13674 insn |= 0x3c0d0000; /* addis 0,13,0 */
13675 bfd_put_32 (input_bfd, insn,
13676 contents + rel->r_offset - d_offset);
13677 r_type = R_PPC64_TPREL16_HA;
13678 if (toc_symndx != 0)
13679 {
13680 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13681 rel->r_addend = toc_addend;
13682 /* We changed the symbol. Start over in order to
13683 get h, sym, sec etc. right. */
13684 goto again;
13685 }
13686 else
13687 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13688 }
13689 break;
13690
13691 case R_PPC64_TLS:
13692 if (tls_mask != 0
13693 && (tls_mask & TLS_TPREL) == 0)
13694 {
13695 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13696 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13697 if (insn == 0)
13698 abort ();
13699 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13700 /* Was PPC64_TLS which sits on insn boundary, now
13701 PPC64_TPREL16_LO which is at low-order half-word. */
13702 rel->r_offset += d_offset;
13703 r_type = R_PPC64_TPREL16_LO;
13704 if (toc_symndx != 0)
13705 {
13706 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13707 rel->r_addend = toc_addend;
13708 /* We changed the symbol. Start over in order to
13709 get h, sym, sec etc. right. */
13710 goto again;
13711 }
13712 else
13713 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13714 }
13715 break;
13716
13717 case R_PPC64_GOT_TLSGD16_HI:
13718 case R_PPC64_GOT_TLSGD16_HA:
13719 tls_gd = TLS_TPRELGD;
13720 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13721 goto tls_gdld_hi;
13722 break;
13723
13724 case R_PPC64_GOT_TLSLD16_HI:
13725 case R_PPC64_GOT_TLSLD16_HA:
13726 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13727 {
13728 tls_gdld_hi:
13729 if ((tls_mask & tls_gd) != 0)
13730 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13731 + R_PPC64_GOT_TPREL16_DS);
13732 else
13733 {
13734 rel->r_offset -= d_offset;
13735 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13736 r_type = R_PPC64_NONE;
13737 }
13738 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13739 }
13740 break;
13741
13742 case R_PPC64_GOT_TLSGD16:
13743 case R_PPC64_GOT_TLSGD16_LO:
13744 tls_gd = TLS_TPRELGD;
13745 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13746 goto tls_ldgd_opt;
13747 break;
13748
13749 case R_PPC64_GOT_TLSLD16:
13750 case R_PPC64_GOT_TLSLD16_LO:
13751 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13752 {
13753 unsigned int insn1, insn2, insn3;
13754 bfd_vma offset;
13755
13756 tls_ldgd_opt:
13757 offset = (bfd_vma) -1;
13758 /* If not using the newer R_PPC64_TLSGD/LD to mark
13759 __tls_get_addr calls, we must trust that the call
13760 stays with its arg setup insns, ie. that the next
13761 reloc is the __tls_get_addr call associated with
13762 the current reloc. Edit both insns. */
13763 if (input_section->has_tls_get_addr_call
13764 && rel + 1 < relend
13765 && branch_reloc_hash_match (input_bfd, rel + 1,
13766 htab->tls_get_addr,
13767 htab->tls_get_addr_fd))
13768 offset = rel[1].r_offset;
13769 /* We read the low GOT_TLS (or TOC16) insn because we
13770 need to keep the destination reg. It may be
13771 something other than the usual r3, and moved to r3
13772 before the call by intervening code. */
13773 insn1 = bfd_get_32 (input_bfd,
13774 contents + rel->r_offset - d_offset);
13775 if ((tls_mask & tls_gd) != 0)
13776 {
13777 /* IE */
13778 insn1 &= (0x1f << 21) | (0x1f << 16);
13779 insn1 |= 58 << 26; /* ld */
13780 insn2 = 0x7c636a14; /* add 3,3,13 */
13781 if (offset != (bfd_vma) -1)
13782 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13783 if ((tls_mask & TLS_EXPLICIT) == 0)
13784 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13785 + R_PPC64_GOT_TPREL16_DS);
13786 else
13787 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13788 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13789 }
13790 else
13791 {
13792 /* LE */
13793 insn1 &= 0x1f << 21;
13794 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13795 insn2 = 0x38630000; /* addi 3,3,0 */
13796 if (tls_gd == 0)
13797 {
13798 /* Was an LD reloc. */
13799 if (toc_symndx)
13800 sec = local_sections[toc_symndx];
13801 for (r_symndx = 0;
13802 r_symndx < symtab_hdr->sh_info;
13803 r_symndx++)
13804 if (local_sections[r_symndx] == sec)
13805 break;
13806 if (r_symndx >= symtab_hdr->sh_info)
13807 r_symndx = STN_UNDEF;
13808 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13809 if (r_symndx != STN_UNDEF)
13810 rel->r_addend -= (local_syms[r_symndx].st_value
13811 + sec->output_offset
13812 + sec->output_section->vma);
13813 }
13814 else if (toc_symndx != 0)
13815 {
13816 r_symndx = toc_symndx;
13817 rel->r_addend = toc_addend;
13818 }
13819 r_type = R_PPC64_TPREL16_HA;
13820 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13821 if (offset != (bfd_vma) -1)
13822 {
13823 rel[1].r_info = ELF64_R_INFO (r_symndx,
13824 R_PPC64_TPREL16_LO);
13825 rel[1].r_offset = offset + d_offset;
13826 rel[1].r_addend = rel->r_addend;
13827 }
13828 }
13829 bfd_put_32 (input_bfd, insn1,
13830 contents + rel->r_offset - d_offset);
13831 if (offset != (bfd_vma) -1)
13832 {
13833 insn3 = bfd_get_32 (input_bfd,
13834 contents + offset + 4);
13835 if (insn3 == NOP
13836 || insn3 == CROR_151515 || insn3 == CROR_313131)
13837 {
13838 rel[1].r_offset += 4;
13839 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13840 insn2 = NOP;
13841 }
13842 bfd_put_32 (input_bfd, insn2, contents + offset);
13843 }
13844 if ((tls_mask & tls_gd) == 0
13845 && (tls_gd == 0 || toc_symndx != 0))
13846 {
13847 /* We changed the symbol. Start over in order
13848 to get h, sym, sec etc. right. */
13849 goto again;
13850 }
13851 }
13852 break;
13853
13854 case R_PPC64_TLSGD:
13855 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13856 {
13857 unsigned int insn2, insn3;
13858 bfd_vma offset = rel->r_offset;
13859
13860 if ((tls_mask & TLS_TPRELGD) != 0)
13861 {
13862 /* IE */
13863 r_type = R_PPC64_NONE;
13864 insn2 = 0x7c636a14; /* add 3,3,13 */
13865 }
13866 else
13867 {
13868 /* LE */
13869 if (toc_symndx != 0)
13870 {
13871 r_symndx = toc_symndx;
13872 rel->r_addend = toc_addend;
13873 }
13874 r_type = R_PPC64_TPREL16_LO;
13875 rel->r_offset = offset + d_offset;
13876 insn2 = 0x38630000; /* addi 3,3,0 */
13877 }
13878 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13879 /* Zap the reloc on the _tls_get_addr call too. */
13880 BFD_ASSERT (offset == rel[1].r_offset);
13881 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13882 insn3 = bfd_get_32 (input_bfd,
13883 contents + offset + 4);
13884 if (insn3 == NOP
13885 || insn3 == CROR_151515 || insn3 == CROR_313131)
13886 {
13887 rel->r_offset += 4;
13888 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13889 insn2 = NOP;
13890 }
13891 bfd_put_32 (input_bfd, insn2, contents + offset);
13892 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13893 goto again;
13894 }
13895 break;
13896
13897 case R_PPC64_TLSLD:
13898 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13899 {
13900 unsigned int insn2, insn3;
13901 bfd_vma offset = rel->r_offset;
13902
13903 if (toc_symndx)
13904 sec = local_sections[toc_symndx];
13905 for (r_symndx = 0;
13906 r_symndx < symtab_hdr->sh_info;
13907 r_symndx++)
13908 if (local_sections[r_symndx] == sec)
13909 break;
13910 if (r_symndx >= symtab_hdr->sh_info)
13911 r_symndx = STN_UNDEF;
13912 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13913 if (r_symndx != STN_UNDEF)
13914 rel->r_addend -= (local_syms[r_symndx].st_value
13915 + sec->output_offset
13916 + sec->output_section->vma);
13917
13918 r_type = R_PPC64_TPREL16_LO;
13919 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13920 rel->r_offset = offset + d_offset;
13921 /* Zap the reloc on the _tls_get_addr call too. */
13922 BFD_ASSERT (offset == rel[1].r_offset);
13923 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13924 insn2 = 0x38630000; /* addi 3,3,0 */
13925 insn3 = bfd_get_32 (input_bfd,
13926 contents + offset + 4);
13927 if (insn3 == NOP
13928 || insn3 == CROR_151515 || insn3 == CROR_313131)
13929 {
13930 rel->r_offset += 4;
13931 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13932 insn2 = NOP;
13933 }
13934 bfd_put_32 (input_bfd, insn2, contents + offset);
13935 goto again;
13936 }
13937 break;
13938
13939 case R_PPC64_DTPMOD64:
13940 if (rel + 1 < relend
13941 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13942 && rel[1].r_offset == rel->r_offset + 8)
13943 {
13944 if ((tls_mask & TLS_GD) == 0)
13945 {
13946 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13947 if ((tls_mask & TLS_TPRELGD) != 0)
13948 r_type = R_PPC64_TPREL64;
13949 else
13950 {
13951 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13952 r_type = R_PPC64_NONE;
13953 }
13954 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13955 }
13956 }
13957 else
13958 {
13959 if ((tls_mask & TLS_LD) == 0)
13960 {
13961 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13962 r_type = R_PPC64_NONE;
13963 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13964 }
13965 }
13966 break;
13967
13968 case R_PPC64_TPREL64:
13969 if ((tls_mask & TLS_TPREL) == 0)
13970 {
13971 r_type = R_PPC64_NONE;
13972 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13973 }
13974 break;
13975
13976 case R_PPC64_ENTRY:
13977 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13978 if (!bfd_link_pic (info)
13979 && !info->traditional_format
13980 && relocation + 0x80008000 <= 0xffffffff)
13981 {
13982 unsigned int insn1, insn2;
13983
13984 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13985 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13986 if ((insn1 & ~0xfffc) == LD_R2_0R12
13987 && insn2 == ADD_R2_R2_R12)
13988 {
13989 bfd_put_32 (input_bfd,
13990 LIS_R2 + PPC_HA (relocation),
13991 contents + rel->r_offset);
13992 bfd_put_32 (input_bfd,
13993 ADDI_R2_R2 + PPC_LO (relocation),
13994 contents + rel->r_offset + 4);
13995 }
13996 }
13997 else
13998 {
13999 relocation -= (rel->r_offset
14000 + input_section->output_offset
14001 + input_section->output_section->vma);
14002 if (relocation + 0x80008000 <= 0xffffffff)
14003 {
14004 unsigned int insn1, insn2;
14005
14006 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14007 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14008 if ((insn1 & ~0xfffc) == LD_R2_0R12
14009 && insn2 == ADD_R2_R2_R12)
14010 {
14011 bfd_put_32 (input_bfd,
14012 ADDIS_R2_R12 + PPC_HA (relocation),
14013 contents + rel->r_offset);
14014 bfd_put_32 (input_bfd,
14015 ADDI_R2_R2 + PPC_LO (relocation),
14016 contents + rel->r_offset + 4);
14017 }
14018 }
14019 }
14020 break;
14021
14022 case R_PPC64_REL16_HA:
14023 /* If we are generating a non-PIC executable, edit
14024 . 0: addis 2,12,.TOC.-0b@ha
14025 . addi 2,2,.TOC.-0b@l
14026 used by ELFv2 global entry points to set up r2, to
14027 . lis 2,.TOC.@ha
14028 . addi 2,2,.TOC.@l
14029 if .TOC. is in range. */
14030 if (!bfd_link_pic (info)
14031 && !info->traditional_format
14032 && !htab->opd_abi
14033 && rel->r_addend == d_offset
14034 && h != NULL && &h->elf == htab->elf.hgot
14035 && rel + 1 < relend
14036 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14037 && rel[1].r_offset == rel->r_offset + 4
14038 && rel[1].r_addend == rel->r_addend + 4
14039 && relocation + 0x80008000 <= 0xffffffff)
14040 {
14041 unsigned int insn1, insn2;
14042 bfd_vma offset = rel->r_offset - d_offset;
14043 insn1 = bfd_get_32 (input_bfd, contents + offset);
14044 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14045 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14046 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14047 {
14048 r_type = R_PPC64_ADDR16_HA;
14049 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14050 rel->r_addend -= d_offset;
14051 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14052 rel[1].r_addend -= d_offset + 4;
14053 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14054 }
14055 }
14056 break;
14057 }
14058
14059 /* Handle other relocations that tweak non-addend part of insn. */
14060 insn = 0;
14061 max_br_offset = 1 << 25;
14062 addend = rel->r_addend;
14063 reloc_dest = DEST_NORMAL;
14064 switch (r_type)
14065 {
14066 default:
14067 break;
14068
14069 case R_PPC64_TOCSAVE:
14070 if (relocation + addend == (rel->r_offset
14071 + input_section->output_offset
14072 + input_section->output_section->vma)
14073 && tocsave_find (htab, NO_INSERT,
14074 &local_syms, rel, input_bfd))
14075 {
14076 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14077 if (insn == NOP
14078 || insn == CROR_151515 || insn == CROR_313131)
14079 bfd_put_32 (input_bfd,
14080 STD_R2_0R1 + STK_TOC (htab),
14081 contents + rel->r_offset);
14082 }
14083 break;
14084
14085 /* Branch taken prediction relocations. */
14086 case R_PPC64_ADDR14_BRTAKEN:
14087 case R_PPC64_REL14_BRTAKEN:
14088 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14089 /* Fall through. */
14090
14091 /* Branch not taken prediction relocations. */
14092 case R_PPC64_ADDR14_BRNTAKEN:
14093 case R_PPC64_REL14_BRNTAKEN:
14094 insn |= bfd_get_32 (input_bfd,
14095 contents + rel->r_offset) & ~(0x01 << 21);
14096 /* Fall through. */
14097
14098 case R_PPC64_REL14:
14099 max_br_offset = 1 << 15;
14100 /* Fall through. */
14101
14102 case R_PPC64_REL24:
14103 /* Calls to functions with a different TOC, such as calls to
14104 shared objects, need to alter the TOC pointer. This is
14105 done using a linkage stub. A REL24 branching to these
14106 linkage stubs needs to be followed by a nop, as the nop
14107 will be replaced with an instruction to restore the TOC
14108 base pointer. */
14109 fdh = h;
14110 if (h != NULL
14111 && h->oh != NULL
14112 && h->oh->is_func_descriptor)
14113 fdh = ppc_follow_link (h->oh);
14114 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14115 htab);
14116 if (stub_entry != NULL
14117 && (stub_entry->stub_type == ppc_stub_plt_call
14118 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14119 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14120 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14121 {
14122 bfd_boolean can_plt_call = FALSE;
14123
14124 /* All of these stubs will modify r2, so there must be a
14125 branch and link followed by a nop. The nop is
14126 replaced by an insn to restore r2. */
14127 if (rel->r_offset + 8 <= input_section->size)
14128 {
14129 unsigned long br;
14130
14131 br = bfd_get_32 (input_bfd,
14132 contents + rel->r_offset);
14133 if ((br & 1) != 0)
14134 {
14135 unsigned long nop;
14136
14137 nop = bfd_get_32 (input_bfd,
14138 contents + rel->r_offset + 4);
14139 if (nop == NOP
14140 || nop == CROR_151515 || nop == CROR_313131)
14141 {
14142 if (h != NULL
14143 && (h == htab->tls_get_addr_fd
14144 || h == htab->tls_get_addr)
14145 && htab->params->tls_get_addr_opt)
14146 {
14147 /* Special stub used, leave nop alone. */
14148 }
14149 else
14150 bfd_put_32 (input_bfd,
14151 LD_R2_0R1 + STK_TOC (htab),
14152 contents + rel->r_offset + 4);
14153 can_plt_call = TRUE;
14154 }
14155 }
14156 }
14157
14158 if (!can_plt_call && h != NULL)
14159 {
14160 const char *name = h->elf.root.root.string;
14161
14162 if (*name == '.')
14163 ++name;
14164
14165 if (strncmp (name, "__libc_start_main", 17) == 0
14166 && (name[17] == 0 || name[17] == '@'))
14167 {
14168 /* Allow crt1 branch to go via a toc adjusting
14169 stub. Other calls that never return could do
14170 the same, if we could detect such. */
14171 can_plt_call = TRUE;
14172 }
14173 }
14174
14175 if (!can_plt_call)
14176 {
14177 /* g++ as of 20130507 emits self-calls without a
14178 following nop. This is arguably wrong since we
14179 have conflicting information. On the one hand a
14180 global symbol and on the other a local call
14181 sequence, but don't error for this special case.
14182 It isn't possible to cheaply verify we have
14183 exactly such a call. Allow all calls to the same
14184 section. */
14185 asection *code_sec = sec;
14186
14187 if (get_opd_info (sec) != NULL)
14188 {
14189 bfd_vma off = (relocation + addend
14190 - sec->output_section->vma
14191 - sec->output_offset);
14192
14193 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14194 }
14195 if (code_sec == input_section)
14196 can_plt_call = TRUE;
14197 }
14198
14199 if (!can_plt_call)
14200 {
14201 if (stub_entry->stub_type == ppc_stub_plt_call
14202 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14203 info->callbacks->einfo
14204 /* xgettext:c-format */
14205 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14206 "recompile with -fPIC\n"),
14207 input_bfd, input_section, rel->r_offset, sym_name);
14208 else
14209 info->callbacks->einfo
14210 /* xgettext:c-format */
14211 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14212 "(-mcmodel=small toc adjust stub)\n"),
14213 input_bfd, input_section, rel->r_offset, sym_name);
14214
14215 bfd_set_error (bfd_error_bad_value);
14216 ret = FALSE;
14217 }
14218
14219 if (can_plt_call
14220 && (stub_entry->stub_type == ppc_stub_plt_call
14221 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14222 unresolved_reloc = FALSE;
14223 }
14224
14225 if ((stub_entry == NULL
14226 || stub_entry->stub_type == ppc_stub_long_branch
14227 || stub_entry->stub_type == ppc_stub_plt_branch)
14228 && get_opd_info (sec) != NULL)
14229 {
14230 /* The branch destination is the value of the opd entry. */
14231 bfd_vma off = (relocation + addend
14232 - sec->output_section->vma
14233 - sec->output_offset);
14234 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14235 if (dest != (bfd_vma) -1)
14236 {
14237 relocation = dest;
14238 addend = 0;
14239 reloc_dest = DEST_OPD;
14240 }
14241 }
14242
14243 /* If the branch is out of reach we ought to have a long
14244 branch stub. */
14245 from = (rel->r_offset
14246 + input_section->output_offset
14247 + input_section->output_section->vma);
14248
14249 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14250 ? fdh->elf.other
14251 : sym->st_other);
14252
14253 if (stub_entry != NULL
14254 && (stub_entry->stub_type == ppc_stub_long_branch
14255 || stub_entry->stub_type == ppc_stub_plt_branch)
14256 && (r_type == R_PPC64_ADDR14_BRTAKEN
14257 || r_type == R_PPC64_ADDR14_BRNTAKEN
14258 || (relocation + addend - from + max_br_offset
14259 < 2 * max_br_offset)))
14260 /* Don't use the stub if this branch is in range. */
14261 stub_entry = NULL;
14262
14263 if (stub_entry != NULL)
14264 {
14265 /* Munge up the value and addend so that we call the stub
14266 rather than the procedure directly. */
14267 asection *stub_sec = stub_entry->group->stub_sec;
14268
14269 if (stub_entry->stub_type == ppc_stub_save_res)
14270 relocation += (stub_sec->output_offset
14271 + stub_sec->output_section->vma
14272 + stub_sec->size - htab->sfpr->size
14273 - htab->sfpr->output_offset
14274 - htab->sfpr->output_section->vma);
14275 else
14276 relocation = (stub_entry->stub_offset
14277 + stub_sec->output_offset
14278 + stub_sec->output_section->vma);
14279 addend = 0;
14280 reloc_dest = DEST_STUB;
14281
14282 if ((stub_entry->stub_type == ppc_stub_plt_call
14283 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14284 && (ALWAYS_EMIT_R2SAVE
14285 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14286 && rel + 1 < relend
14287 && rel[1].r_offset == rel->r_offset + 4
14288 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14289 relocation += 4;
14290 }
14291
14292 if (insn != 0)
14293 {
14294 if (is_isa_v2)
14295 {
14296 /* Set 'a' bit. This is 0b00010 in BO field for branch
14297 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14298 for branch on CTR insns (BO == 1a00t or 1a01t). */
14299 if ((insn & (0x14 << 21)) == (0x04 << 21))
14300 insn |= 0x02 << 21;
14301 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14302 insn |= 0x08 << 21;
14303 else
14304 break;
14305 }
14306 else
14307 {
14308 /* Invert 'y' bit if not the default. */
14309 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14310 insn ^= 0x01 << 21;
14311 }
14312
14313 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14314 }
14315
14316 /* NOP out calls to undefined weak functions.
14317 We can thus call a weak function without first
14318 checking whether the function is defined. */
14319 else if (h != NULL
14320 && h->elf.root.type == bfd_link_hash_undefweak
14321 && h->elf.dynindx == -1
14322 && r_type == R_PPC64_REL24
14323 && relocation == 0
14324 && addend == 0)
14325 {
14326 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14327 goto copy_reloc;
14328 }
14329 break;
14330 }
14331
14332 /* Set `addend'. */
14333 tls_type = 0;
14334 switch (r_type)
14335 {
14336 default:
14337 info->callbacks->einfo
14338 /* xgettext:c-format */
14339 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14340 input_bfd, (int) r_type, sym_name);
14341
14342 bfd_set_error (bfd_error_bad_value);
14343 ret = FALSE;
14344 goto copy_reloc;
14345
14346 case R_PPC64_NONE:
14347 case R_PPC64_TLS:
14348 case R_PPC64_TLSGD:
14349 case R_PPC64_TLSLD:
14350 case R_PPC64_TOCSAVE:
14351 case R_PPC64_GNU_VTINHERIT:
14352 case R_PPC64_GNU_VTENTRY:
14353 case R_PPC64_ENTRY:
14354 goto copy_reloc;
14355
14356 /* GOT16 relocations. Like an ADDR16 using the symbol's
14357 address in the GOT as relocation value instead of the
14358 symbol's value itself. Also, create a GOT entry for the
14359 symbol and put the symbol value there. */
14360 case R_PPC64_GOT_TLSGD16:
14361 case R_PPC64_GOT_TLSGD16_LO:
14362 case R_PPC64_GOT_TLSGD16_HI:
14363 case R_PPC64_GOT_TLSGD16_HA:
14364 tls_type = TLS_TLS | TLS_GD;
14365 goto dogot;
14366
14367 case R_PPC64_GOT_TLSLD16:
14368 case R_PPC64_GOT_TLSLD16_LO:
14369 case R_PPC64_GOT_TLSLD16_HI:
14370 case R_PPC64_GOT_TLSLD16_HA:
14371 tls_type = TLS_TLS | TLS_LD;
14372 goto dogot;
14373
14374 case R_PPC64_GOT_TPREL16_DS:
14375 case R_PPC64_GOT_TPREL16_LO_DS:
14376 case R_PPC64_GOT_TPREL16_HI:
14377 case R_PPC64_GOT_TPREL16_HA:
14378 tls_type = TLS_TLS | TLS_TPREL;
14379 goto dogot;
14380
14381 case R_PPC64_GOT_DTPREL16_DS:
14382 case R_PPC64_GOT_DTPREL16_LO_DS:
14383 case R_PPC64_GOT_DTPREL16_HI:
14384 case R_PPC64_GOT_DTPREL16_HA:
14385 tls_type = TLS_TLS | TLS_DTPREL;
14386 goto dogot;
14387
14388 case R_PPC64_GOT16:
14389 case R_PPC64_GOT16_LO:
14390 case R_PPC64_GOT16_HI:
14391 case R_PPC64_GOT16_HA:
14392 case R_PPC64_GOT16_DS:
14393 case R_PPC64_GOT16_LO_DS:
14394 dogot:
14395 {
14396 /* Relocation is to the entry for this symbol in the global
14397 offset table. */
14398 asection *got;
14399 bfd_vma *offp;
14400 bfd_vma off;
14401 unsigned long indx = 0;
14402 struct got_entry *ent;
14403
14404 if (tls_type == (TLS_TLS | TLS_LD)
14405 && (h == NULL
14406 || !h->elf.def_dynamic))
14407 ent = ppc64_tlsld_got (input_bfd);
14408 else
14409 {
14410
14411 if (h != NULL)
14412 {
14413 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14414 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14415 &h->elf)
14416 || (bfd_link_pic (info)
14417 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14418 /* This is actually a static link, or it is a
14419 -Bsymbolic link and the symbol is defined
14420 locally, or the symbol was forced to be local
14421 because of a version file. */
14422 ;
14423 else
14424 {
14425 BFD_ASSERT (h->elf.dynindx != -1);
14426 indx = h->elf.dynindx;
14427 unresolved_reloc = FALSE;
14428 }
14429 ent = h->elf.got.glist;
14430 }
14431 else
14432 {
14433 if (local_got_ents == NULL)
14434 abort ();
14435 ent = local_got_ents[r_symndx];
14436 }
14437
14438 for (; ent != NULL; ent = ent->next)
14439 if (ent->addend == orig_rel.r_addend
14440 && ent->owner == input_bfd
14441 && ent->tls_type == tls_type)
14442 break;
14443 }
14444
14445 if (ent == NULL)
14446 abort ();
14447 if (ent->is_indirect)
14448 ent = ent->got.ent;
14449 offp = &ent->got.offset;
14450 got = ppc64_elf_tdata (ent->owner)->got;
14451 if (got == NULL)
14452 abort ();
14453
14454 /* The offset must always be a multiple of 8. We use the
14455 least significant bit to record whether we have already
14456 processed this entry. */
14457 off = *offp;
14458 if ((off & 1) != 0)
14459 off &= ~1;
14460 else
14461 {
14462 /* Generate relocs for the dynamic linker, except in
14463 the case of TLSLD where we'll use one entry per
14464 module. */
14465 asection *relgot;
14466 bfd_boolean ifunc;
14467
14468 *offp = off | 1;
14469 relgot = NULL;
14470 ifunc = (h != NULL
14471 ? h->elf.type == STT_GNU_IFUNC
14472 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14473 if (ifunc)
14474 relgot = htab->elf.irelplt;
14475 else if ((bfd_link_pic (info) || indx != 0)
14476 && (h == NULL
14477 || (tls_type == (TLS_TLS | TLS_LD)
14478 && !h->elf.def_dynamic)
14479 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14480 || h->elf.root.type != bfd_link_hash_undefweak))
14481 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14482 if (relgot != NULL)
14483 {
14484 outrel.r_offset = (got->output_section->vma
14485 + got->output_offset
14486 + off);
14487 outrel.r_addend = addend;
14488 if (tls_type & (TLS_LD | TLS_GD))
14489 {
14490 outrel.r_addend = 0;
14491 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14492 if (tls_type == (TLS_TLS | TLS_GD))
14493 {
14494 loc = relgot->contents;
14495 loc += (relgot->reloc_count++
14496 * sizeof (Elf64_External_Rela));
14497 bfd_elf64_swap_reloca_out (output_bfd,
14498 &outrel, loc);
14499 outrel.r_offset += 8;
14500 outrel.r_addend = addend;
14501 outrel.r_info
14502 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14503 }
14504 }
14505 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14506 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14507 else if (tls_type == (TLS_TLS | TLS_TPREL))
14508 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14509 else if (indx != 0)
14510 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14511 else
14512 {
14513 if (ifunc)
14514 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14515 else
14516 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14517
14518 /* Write the .got section contents for the sake
14519 of prelink. */
14520 loc = got->contents + off;
14521 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14522 loc);
14523 }
14524
14525 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14526 {
14527 outrel.r_addend += relocation;
14528 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14529 {
14530 if (htab->elf.tls_sec == NULL)
14531 outrel.r_addend = 0;
14532 else
14533 outrel.r_addend -= htab->elf.tls_sec->vma;
14534 }
14535 }
14536 loc = relgot->contents;
14537 loc += (relgot->reloc_count++
14538 * sizeof (Elf64_External_Rela));
14539 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14540 }
14541
14542 /* Init the .got section contents here if we're not
14543 emitting a reloc. */
14544 else
14545 {
14546 relocation += addend;
14547 if (tls_type == (TLS_TLS | TLS_LD))
14548 relocation = 1;
14549 else if (tls_type != 0)
14550 {
14551 if (htab->elf.tls_sec == NULL)
14552 relocation = 0;
14553 else
14554 {
14555 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14556 if (tls_type == (TLS_TLS | TLS_TPREL))
14557 relocation += DTP_OFFSET - TP_OFFSET;
14558 }
14559
14560 if (tls_type == (TLS_TLS | TLS_GD))
14561 {
14562 bfd_put_64 (output_bfd, relocation,
14563 got->contents + off + 8);
14564 relocation = 1;
14565 }
14566 }
14567
14568 bfd_put_64 (output_bfd, relocation,
14569 got->contents + off);
14570 }
14571 }
14572
14573 if (off >= (bfd_vma) -2)
14574 abort ();
14575
14576 relocation = got->output_section->vma + got->output_offset + off;
14577 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14578 }
14579 break;
14580
14581 case R_PPC64_PLT16_HA:
14582 case R_PPC64_PLT16_HI:
14583 case R_PPC64_PLT16_LO:
14584 case R_PPC64_PLT32:
14585 case R_PPC64_PLT64:
14586 /* Relocation is to the entry for this symbol in the
14587 procedure linkage table. */
14588 {
14589 struct plt_entry **plt_list = NULL;
14590 if (h != NULL)
14591 plt_list = &h->elf.plt.plist;
14592 else if (local_got_ents != NULL)
14593 {
14594 struct plt_entry **local_plt = (struct plt_entry **)
14595 (local_got_ents + symtab_hdr->sh_info);
14596 unsigned char *local_got_tls_masks = (unsigned char *)
14597 (local_plt + symtab_hdr->sh_info);
14598 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14599 plt_list = local_plt + r_symndx;
14600 }
14601 if (plt_list)
14602 {
14603 struct plt_entry *ent;
14604
14605 for (ent = *plt_list; ent != NULL; ent = ent->next)
14606 if (ent->plt.offset != (bfd_vma) -1
14607 && ent->addend == orig_rel.r_addend)
14608 {
14609 asection *plt;
14610
14611 plt = htab->elf.splt;
14612 if (!htab->elf.dynamic_sections_created
14613 || h == NULL
14614 || h->elf.dynindx == -1)
14615 plt = htab->elf.iplt;
14616 relocation = (plt->output_section->vma
14617 + plt->output_offset
14618 + ent->plt.offset);
14619 addend = 0;
14620 unresolved_reloc = FALSE;
14621 break;
14622 }
14623 }
14624 }
14625 break;
14626
14627 case R_PPC64_TOC:
14628 /* Relocation value is TOC base. */
14629 relocation = TOCstart;
14630 if (r_symndx == STN_UNDEF)
14631 relocation += htab->sec_info[input_section->id].toc_off;
14632 else if (unresolved_reloc)
14633 ;
14634 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14635 relocation += htab->sec_info[sec->id].toc_off;
14636 else
14637 unresolved_reloc = TRUE;
14638 goto dodyn;
14639
14640 /* TOC16 relocs. We want the offset relative to the TOC base,
14641 which is the address of the start of the TOC plus 0x8000.
14642 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14643 in this order. */
14644 case R_PPC64_TOC16:
14645 case R_PPC64_TOC16_LO:
14646 case R_PPC64_TOC16_HI:
14647 case R_PPC64_TOC16_DS:
14648 case R_PPC64_TOC16_LO_DS:
14649 case R_PPC64_TOC16_HA:
14650 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14651 break;
14652
14653 /* Relocate against the beginning of the section. */
14654 case R_PPC64_SECTOFF:
14655 case R_PPC64_SECTOFF_LO:
14656 case R_PPC64_SECTOFF_HI:
14657 case R_PPC64_SECTOFF_DS:
14658 case R_PPC64_SECTOFF_LO_DS:
14659 case R_PPC64_SECTOFF_HA:
14660 if (sec != NULL)
14661 addend -= sec->output_section->vma;
14662 break;
14663
14664 case R_PPC64_REL16:
14665 case R_PPC64_REL16_LO:
14666 case R_PPC64_REL16_HI:
14667 case R_PPC64_REL16_HA:
14668 case R_PPC64_REL16DX_HA:
14669 break;
14670
14671 case R_PPC64_REL14:
14672 case R_PPC64_REL14_BRNTAKEN:
14673 case R_PPC64_REL14_BRTAKEN:
14674 case R_PPC64_REL24:
14675 break;
14676
14677 case R_PPC64_TPREL16:
14678 case R_PPC64_TPREL16_LO:
14679 case R_PPC64_TPREL16_HI:
14680 case R_PPC64_TPREL16_HA:
14681 case R_PPC64_TPREL16_DS:
14682 case R_PPC64_TPREL16_LO_DS:
14683 case R_PPC64_TPREL16_HIGH:
14684 case R_PPC64_TPREL16_HIGHA:
14685 case R_PPC64_TPREL16_HIGHER:
14686 case R_PPC64_TPREL16_HIGHERA:
14687 case R_PPC64_TPREL16_HIGHEST:
14688 case R_PPC64_TPREL16_HIGHESTA:
14689 if (h != NULL
14690 && h->elf.root.type == bfd_link_hash_undefweak
14691 && h->elf.dynindx == -1)
14692 {
14693 /* Make this relocation against an undefined weak symbol
14694 resolve to zero. This is really just a tweak, since
14695 code using weak externs ought to check that they are
14696 defined before using them. */
14697 bfd_byte *p = contents + rel->r_offset - d_offset;
14698
14699 insn = bfd_get_32 (input_bfd, p);
14700 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14701 if (insn != 0)
14702 bfd_put_32 (input_bfd, insn, p);
14703 break;
14704 }
14705 if (htab->elf.tls_sec != NULL)
14706 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14707 if (bfd_link_pic (info))
14708 /* The TPREL16 relocs shouldn't really be used in shared
14709 libs as they will result in DT_TEXTREL being set, but
14710 support them anyway. */
14711 goto dodyn;
14712 break;
14713
14714 case R_PPC64_DTPREL16:
14715 case R_PPC64_DTPREL16_LO:
14716 case R_PPC64_DTPREL16_HI:
14717 case R_PPC64_DTPREL16_HA:
14718 case R_PPC64_DTPREL16_DS:
14719 case R_PPC64_DTPREL16_LO_DS:
14720 case R_PPC64_DTPREL16_HIGH:
14721 case R_PPC64_DTPREL16_HIGHA:
14722 case R_PPC64_DTPREL16_HIGHER:
14723 case R_PPC64_DTPREL16_HIGHERA:
14724 case R_PPC64_DTPREL16_HIGHEST:
14725 case R_PPC64_DTPREL16_HIGHESTA:
14726 if (htab->elf.tls_sec != NULL)
14727 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14728 break;
14729
14730 case R_PPC64_ADDR64_LOCAL:
14731 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14732 ? h->elf.other
14733 : sym->st_other);
14734 break;
14735
14736 case R_PPC64_DTPMOD64:
14737 relocation = 1;
14738 addend = 0;
14739 goto dodyn;
14740
14741 case R_PPC64_TPREL64:
14742 if (htab->elf.tls_sec != NULL)
14743 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14744 goto dodyn;
14745
14746 case R_PPC64_DTPREL64:
14747 if (htab->elf.tls_sec != NULL)
14748 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14749 /* Fall through. */
14750
14751 /* Relocations that may need to be propagated if this is a
14752 dynamic object. */
14753 case R_PPC64_REL30:
14754 case R_PPC64_REL32:
14755 case R_PPC64_REL64:
14756 case R_PPC64_ADDR14:
14757 case R_PPC64_ADDR14_BRNTAKEN:
14758 case R_PPC64_ADDR14_BRTAKEN:
14759 case R_PPC64_ADDR16:
14760 case R_PPC64_ADDR16_DS:
14761 case R_PPC64_ADDR16_HA:
14762 case R_PPC64_ADDR16_HI:
14763 case R_PPC64_ADDR16_HIGH:
14764 case R_PPC64_ADDR16_HIGHA:
14765 case R_PPC64_ADDR16_HIGHER:
14766 case R_PPC64_ADDR16_HIGHERA:
14767 case R_PPC64_ADDR16_HIGHEST:
14768 case R_PPC64_ADDR16_HIGHESTA:
14769 case R_PPC64_ADDR16_LO:
14770 case R_PPC64_ADDR16_LO_DS:
14771 case R_PPC64_ADDR24:
14772 case R_PPC64_ADDR32:
14773 case R_PPC64_ADDR64:
14774 case R_PPC64_UADDR16:
14775 case R_PPC64_UADDR32:
14776 case R_PPC64_UADDR64:
14777 dodyn:
14778 if ((input_section->flags & SEC_ALLOC) == 0)
14779 break;
14780
14781 if (NO_OPD_RELOCS && is_opd)
14782 break;
14783
14784 if (bfd_link_pic (info)
14785 ? ((h != NULL && pc_dynrelocs (h))
14786 || must_be_dyn_reloc (info, r_type))
14787 : (h != NULL
14788 ? h->dyn_relocs != NULL
14789 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14790 {
14791 bfd_boolean skip, relocate;
14792 asection *sreloc;
14793 bfd_vma out_off;
14794
14795 /* When generating a dynamic object, these relocations
14796 are copied into the output file to be resolved at run
14797 time. */
14798
14799 skip = FALSE;
14800 relocate = FALSE;
14801
14802 out_off = _bfd_elf_section_offset (output_bfd, info,
14803 input_section, rel->r_offset);
14804 if (out_off == (bfd_vma) -1)
14805 skip = TRUE;
14806 else if (out_off == (bfd_vma) -2)
14807 skip = TRUE, relocate = TRUE;
14808 out_off += (input_section->output_section->vma
14809 + input_section->output_offset);
14810 outrel.r_offset = out_off;
14811 outrel.r_addend = rel->r_addend;
14812
14813 /* Optimize unaligned reloc use. */
14814 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14815 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14816 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14817 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14818 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14819 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14820 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14821 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14822 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14823
14824 if (skip)
14825 memset (&outrel, 0, sizeof outrel);
14826 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14827 && !is_opd
14828 && r_type != R_PPC64_TOC)
14829 {
14830 BFD_ASSERT (h->elf.dynindx != -1);
14831 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14832 }
14833 else
14834 {
14835 /* This symbol is local, or marked to become local,
14836 or this is an opd section reloc which must point
14837 at a local function. */
14838 outrel.r_addend += relocation;
14839 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14840 {
14841 if (is_opd && h != NULL)
14842 {
14843 /* Lie about opd entries. This case occurs
14844 when building shared libraries and we
14845 reference a function in another shared
14846 lib. The same thing happens for a weak
14847 definition in an application that's
14848 overridden by a strong definition in a
14849 shared lib. (I believe this is a generic
14850 bug in binutils handling of weak syms.)
14851 In these cases we won't use the opd
14852 entry in this lib. */
14853 unresolved_reloc = FALSE;
14854 }
14855 if (!is_opd
14856 && r_type == R_PPC64_ADDR64
14857 && (h != NULL
14858 ? h->elf.type == STT_GNU_IFUNC
14859 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14860 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14861 else
14862 {
14863 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14864
14865 /* We need to relocate .opd contents for ld.so.
14866 Prelink also wants simple and consistent rules
14867 for relocs. This make all RELATIVE relocs have
14868 *r_offset equal to r_addend. */
14869 relocate = TRUE;
14870 }
14871 }
14872 else
14873 {
14874 long indx = 0;
14875
14876 if (h != NULL
14877 ? h->elf.type == STT_GNU_IFUNC
14878 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14879 {
14880 info->callbacks->einfo
14881 /* xgettext:c-format */
14882 (_("%P: %H: %s for indirect "
14883 "function `%T' unsupported\n"),
14884 input_bfd, input_section, rel->r_offset,
14885 ppc64_elf_howto_table[r_type]->name,
14886 sym_name);
14887 ret = FALSE;
14888 }
14889 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14890 ;
14891 else if (sec == NULL || sec->owner == NULL)
14892 {
14893 bfd_set_error (bfd_error_bad_value);
14894 return FALSE;
14895 }
14896 else
14897 {
14898 asection *osec;
14899
14900 osec = sec->output_section;
14901 indx = elf_section_data (osec)->dynindx;
14902
14903 if (indx == 0)
14904 {
14905 if ((osec->flags & SEC_READONLY) == 0
14906 && htab->elf.data_index_section != NULL)
14907 osec = htab->elf.data_index_section;
14908 else
14909 osec = htab->elf.text_index_section;
14910 indx = elf_section_data (osec)->dynindx;
14911 }
14912 BFD_ASSERT (indx != 0);
14913
14914 /* We are turning this relocation into one
14915 against a section symbol, so subtract out
14916 the output section's address but not the
14917 offset of the input section in the output
14918 section. */
14919 outrel.r_addend -= osec->vma;
14920 }
14921
14922 outrel.r_info = ELF64_R_INFO (indx, r_type);
14923 }
14924 }
14925
14926 sreloc = elf_section_data (input_section)->sreloc;
14927 if (h != NULL
14928 ? h->elf.type == STT_GNU_IFUNC
14929 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14930 sreloc = htab->elf.irelplt;
14931 if (sreloc == NULL)
14932 abort ();
14933
14934 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14935 >= sreloc->size)
14936 abort ();
14937 loc = sreloc->contents;
14938 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14939 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14940
14941 /* If this reloc is against an external symbol, it will
14942 be computed at runtime, so there's no need to do
14943 anything now. However, for the sake of prelink ensure
14944 that the section contents are a known value. */
14945 if (! relocate)
14946 {
14947 unresolved_reloc = FALSE;
14948 /* The value chosen here is quite arbitrary as ld.so
14949 ignores section contents except for the special
14950 case of .opd where the contents might be accessed
14951 before relocation. Choose zero, as that won't
14952 cause reloc overflow. */
14953 relocation = 0;
14954 addend = 0;
14955 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14956 to improve backward compatibility with older
14957 versions of ld. */
14958 if (r_type == R_PPC64_ADDR64)
14959 addend = outrel.r_addend;
14960 /* Adjust pc_relative relocs to have zero in *r_offset. */
14961 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14962 addend = (input_section->output_section->vma
14963 + input_section->output_offset
14964 + rel->r_offset);
14965 }
14966 }
14967 break;
14968
14969 case R_PPC64_COPY:
14970 case R_PPC64_GLOB_DAT:
14971 case R_PPC64_JMP_SLOT:
14972 case R_PPC64_JMP_IREL:
14973 case R_PPC64_RELATIVE:
14974 /* We shouldn't ever see these dynamic relocs in relocatable
14975 files. */
14976 /* Fall through. */
14977
14978 case R_PPC64_PLTGOT16:
14979 case R_PPC64_PLTGOT16_DS:
14980 case R_PPC64_PLTGOT16_HA:
14981 case R_PPC64_PLTGOT16_HI:
14982 case R_PPC64_PLTGOT16_LO:
14983 case R_PPC64_PLTGOT16_LO_DS:
14984 case R_PPC64_PLTREL32:
14985 case R_PPC64_PLTREL64:
14986 /* These ones haven't been implemented yet. */
14987
14988 info->callbacks->einfo
14989 /* xgettext:c-format */
14990 (_("%P: %B: %s is not supported for `%T'\n"),
14991 input_bfd,
14992 ppc64_elf_howto_table[r_type]->name, sym_name);
14993
14994 bfd_set_error (bfd_error_invalid_operation);
14995 ret = FALSE;
14996 goto copy_reloc;
14997 }
14998
14999 /* Multi-instruction sequences that access the TOC can be
15000 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15001 to nop; addi rb,r2,x; */
15002 switch (r_type)
15003 {
15004 default:
15005 break;
15006
15007 case R_PPC64_GOT_TLSLD16_HI:
15008 case R_PPC64_GOT_TLSGD16_HI:
15009 case R_PPC64_GOT_TPREL16_HI:
15010 case R_PPC64_GOT_DTPREL16_HI:
15011 case R_PPC64_GOT16_HI:
15012 case R_PPC64_TOC16_HI:
15013 /* These relocs would only be useful if building up an
15014 offset to later add to r2, perhaps in an indexed
15015 addressing mode instruction. Don't try to optimize.
15016 Unfortunately, the possibility of someone building up an
15017 offset like this or even with the HA relocs, means that
15018 we need to check the high insn when optimizing the low
15019 insn. */
15020 break;
15021
15022 case R_PPC64_GOT_TLSLD16_HA:
15023 case R_PPC64_GOT_TLSGD16_HA:
15024 case R_PPC64_GOT_TPREL16_HA:
15025 case R_PPC64_GOT_DTPREL16_HA:
15026 case R_PPC64_GOT16_HA:
15027 case R_PPC64_TOC16_HA:
15028 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15029 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15030 {
15031 bfd_byte *p = contents + (rel->r_offset & ~3);
15032 bfd_put_32 (input_bfd, NOP, p);
15033 }
15034 break;
15035
15036 case R_PPC64_GOT_TLSLD16_LO:
15037 case R_PPC64_GOT_TLSGD16_LO:
15038 case R_PPC64_GOT_TPREL16_LO_DS:
15039 case R_PPC64_GOT_DTPREL16_LO_DS:
15040 case R_PPC64_GOT16_LO:
15041 case R_PPC64_GOT16_LO_DS:
15042 case R_PPC64_TOC16_LO:
15043 case R_PPC64_TOC16_LO_DS:
15044 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15045 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15046 {
15047 bfd_byte *p = contents + (rel->r_offset & ~3);
15048 insn = bfd_get_32 (input_bfd, p);
15049 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15050 {
15051 /* Transform addic to addi when we change reg. */
15052 insn &= ~((0x3f << 26) | (0x1f << 16));
15053 insn |= (14u << 26) | (2 << 16);
15054 }
15055 else
15056 {
15057 insn &= ~(0x1f << 16);
15058 insn |= 2 << 16;
15059 }
15060 bfd_put_32 (input_bfd, insn, p);
15061 }
15062 break;
15063 }
15064
15065 /* Do any further special processing. */
15066 howto = ppc64_elf_howto_table[(int) r_type];
15067 switch (r_type)
15068 {
15069 default:
15070 break;
15071
15072 case R_PPC64_REL16_HA:
15073 case R_PPC64_REL16DX_HA:
15074 case R_PPC64_ADDR16_HA:
15075 case R_PPC64_ADDR16_HIGHA:
15076 case R_PPC64_ADDR16_HIGHERA:
15077 case R_PPC64_ADDR16_HIGHESTA:
15078 case R_PPC64_TOC16_HA:
15079 case R_PPC64_SECTOFF_HA:
15080 case R_PPC64_TPREL16_HA:
15081 case R_PPC64_TPREL16_HIGHA:
15082 case R_PPC64_TPREL16_HIGHERA:
15083 case R_PPC64_TPREL16_HIGHESTA:
15084 case R_PPC64_DTPREL16_HA:
15085 case R_PPC64_DTPREL16_HIGHA:
15086 case R_PPC64_DTPREL16_HIGHERA:
15087 case R_PPC64_DTPREL16_HIGHESTA:
15088 /* It's just possible that this symbol is a weak symbol
15089 that's not actually defined anywhere. In that case,
15090 'sec' would be NULL, and we should leave the symbol
15091 alone (it will be set to zero elsewhere in the link). */
15092 if (sec == NULL)
15093 break;
15094 /* Fall through. */
15095
15096 case R_PPC64_GOT16_HA:
15097 case R_PPC64_PLTGOT16_HA:
15098 case R_PPC64_PLT16_HA:
15099 case R_PPC64_GOT_TLSGD16_HA:
15100 case R_PPC64_GOT_TLSLD16_HA:
15101 case R_PPC64_GOT_TPREL16_HA:
15102 case R_PPC64_GOT_DTPREL16_HA:
15103 /* Add 0x10000 if sign bit in 0:15 is set.
15104 Bits 0:15 are not used. */
15105 addend += 0x8000;
15106 break;
15107
15108 case R_PPC64_ADDR16_DS:
15109 case R_PPC64_ADDR16_LO_DS:
15110 case R_PPC64_GOT16_DS:
15111 case R_PPC64_GOT16_LO_DS:
15112 case R_PPC64_PLT16_LO_DS:
15113 case R_PPC64_SECTOFF_DS:
15114 case R_PPC64_SECTOFF_LO_DS:
15115 case R_PPC64_TOC16_DS:
15116 case R_PPC64_TOC16_LO_DS:
15117 case R_PPC64_PLTGOT16_DS:
15118 case R_PPC64_PLTGOT16_LO_DS:
15119 case R_PPC64_GOT_TPREL16_DS:
15120 case R_PPC64_GOT_TPREL16_LO_DS:
15121 case R_PPC64_GOT_DTPREL16_DS:
15122 case R_PPC64_GOT_DTPREL16_LO_DS:
15123 case R_PPC64_TPREL16_DS:
15124 case R_PPC64_TPREL16_LO_DS:
15125 case R_PPC64_DTPREL16_DS:
15126 case R_PPC64_DTPREL16_LO_DS:
15127 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15128 mask = 3;
15129 /* If this reloc is against an lq, lxv, or stxv insn, then
15130 the value must be a multiple of 16. This is somewhat of
15131 a hack, but the "correct" way to do this by defining _DQ
15132 forms of all the _DS relocs bloats all reloc switches in
15133 this file. It doesn't make much sense to use these
15134 relocs in data, so testing the insn should be safe. */
15135 if ((insn & (0x3f << 26)) == (56u << 26)
15136 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15137 mask = 15;
15138 relocation += addend;
15139 addend = insn & (mask ^ 3);
15140 if ((relocation & mask) != 0)
15141 {
15142 relocation ^= relocation & mask;
15143 info->callbacks->einfo
15144 /* xgettext:c-format */
15145 (_("%P: %H: error: %s not a multiple of %u\n"),
15146 input_bfd, input_section, rel->r_offset,
15147 howto->name,
15148 mask + 1);
15149 bfd_set_error (bfd_error_bad_value);
15150 ret = FALSE;
15151 goto copy_reloc;
15152 }
15153 break;
15154 }
15155
15156 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15157 because such sections are not SEC_ALLOC and thus ld.so will
15158 not process them. */
15159 if (unresolved_reloc
15160 && !((input_section->flags & SEC_DEBUGGING) != 0
15161 && h->elf.def_dynamic)
15162 && _bfd_elf_section_offset (output_bfd, info, input_section,
15163 rel->r_offset) != (bfd_vma) -1)
15164 {
15165 info->callbacks->einfo
15166 /* xgettext:c-format */
15167 (_("%P: %H: unresolvable %s against `%T'\n"),
15168 input_bfd, input_section, rel->r_offset,
15169 howto->name,
15170 h->elf.root.root.string);
15171 ret = FALSE;
15172 }
15173
15174 /* 16-bit fields in insns mostly have signed values, but a
15175 few insns have 16-bit unsigned values. Really, we should
15176 have different reloc types. */
15177 if (howto->complain_on_overflow != complain_overflow_dont
15178 && howto->dst_mask == 0xffff
15179 && (input_section->flags & SEC_CODE) != 0)
15180 {
15181 enum complain_overflow complain = complain_overflow_signed;
15182
15183 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15184 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15185 complain = complain_overflow_bitfield;
15186 else if (howto->rightshift == 0
15187 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15188 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15189 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15190 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15191 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15192 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15193 complain = complain_overflow_unsigned;
15194 if (howto->complain_on_overflow != complain)
15195 {
15196 alt_howto = *howto;
15197 alt_howto.complain_on_overflow = complain;
15198 howto = &alt_howto;
15199 }
15200 }
15201
15202 if (r_type == R_PPC64_REL16DX_HA)
15203 {
15204 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15205 if (rel->r_offset + 4 > input_section->size)
15206 r = bfd_reloc_outofrange;
15207 else
15208 {
15209 relocation += addend;
15210 relocation -= (rel->r_offset
15211 + input_section->output_offset
15212 + input_section->output_section->vma);
15213 relocation = (bfd_signed_vma) relocation >> 16;
15214 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15215 insn &= ~0x1fffc1;
15216 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15217 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15218 r = bfd_reloc_ok;
15219 if (relocation + 0x8000 > 0xffff)
15220 r = bfd_reloc_overflow;
15221 }
15222 }
15223 else
15224 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15225 rel->r_offset, relocation, addend);
15226
15227 if (r != bfd_reloc_ok)
15228 {
15229 char *more_info = NULL;
15230 const char *reloc_name = howto->name;
15231
15232 if (reloc_dest != DEST_NORMAL)
15233 {
15234 more_info = bfd_malloc (strlen (reloc_name) + 8);
15235 if (more_info != NULL)
15236 {
15237 strcpy (more_info, reloc_name);
15238 strcat (more_info, (reloc_dest == DEST_OPD
15239 ? " (OPD)" : " (stub)"));
15240 reloc_name = more_info;
15241 }
15242 }
15243
15244 if (r == bfd_reloc_overflow)
15245 {
15246 /* On code like "if (foo) foo();" don't report overflow
15247 on a branch to zero when foo is undefined. */
15248 if (!warned
15249 && (reloc_dest == DEST_STUB
15250 || !(h != NULL
15251 && (h->elf.root.type == bfd_link_hash_undefweak
15252 || h->elf.root.type == bfd_link_hash_undefined)
15253 && is_branch_reloc (r_type))))
15254 info->callbacks->reloc_overflow (info, &h->elf.root,
15255 sym_name, reloc_name,
15256 orig_rel.r_addend,
15257 input_bfd, input_section,
15258 rel->r_offset);
15259 }
15260 else
15261 {
15262 info->callbacks->einfo
15263 /* xgettext:c-format */
15264 (_("%P: %H: %s against `%T': error %d\n"),
15265 input_bfd, input_section, rel->r_offset,
15266 reloc_name, sym_name, (int) r);
15267 ret = FALSE;
15268 }
15269 if (more_info != NULL)
15270 free (more_info);
15271 }
15272 copy_reloc:
15273 if (wrel != rel)
15274 *wrel = *rel;
15275 }
15276
15277 if (wrel != rel)
15278 {
15279 Elf_Internal_Shdr *rel_hdr;
15280 size_t deleted = rel - wrel;
15281
15282 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15283 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15284 if (rel_hdr->sh_size == 0)
15285 {
15286 /* It is too late to remove an empty reloc section. Leave
15287 one NONE reloc.
15288 ??? What is wrong with an empty section??? */
15289 rel_hdr->sh_size = rel_hdr->sh_entsize;
15290 deleted -= 1;
15291 }
15292 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15293 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15294 input_section->reloc_count -= deleted;
15295 }
15296
15297 /* If we're emitting relocations, then shortly after this function
15298 returns, reloc offsets and addends for this section will be
15299 adjusted. Worse, reloc symbol indices will be for the output
15300 file rather than the input. Save a copy of the relocs for
15301 opd_entry_value. */
15302 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15303 {
15304 bfd_size_type amt;
15305 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15306 rel = bfd_alloc (input_bfd, amt);
15307 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15308 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15309 if (rel == NULL)
15310 return FALSE;
15311 memcpy (rel, relocs, amt);
15312 }
15313 return ret;
15314 }
15315
15316 /* Adjust the value of any local symbols in opd sections. */
15317
15318 static int
15319 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15320 const char *name ATTRIBUTE_UNUSED,
15321 Elf_Internal_Sym *elfsym,
15322 asection *input_sec,
15323 struct elf_link_hash_entry *h)
15324 {
15325 struct _opd_sec_data *opd;
15326 long adjust;
15327 bfd_vma value;
15328
15329 if (h != NULL)
15330 return 1;
15331
15332 opd = get_opd_info (input_sec);
15333 if (opd == NULL || opd->adjust == NULL)
15334 return 1;
15335
15336 value = elfsym->st_value - input_sec->output_offset;
15337 if (!bfd_link_relocatable (info))
15338 value -= input_sec->output_section->vma;
15339
15340 adjust = opd->adjust[OPD_NDX (value)];
15341 if (adjust == -1)
15342 return 2;
15343
15344 elfsym->st_value += adjust;
15345 return 1;
15346 }
15347
15348 /* Finish up dynamic symbol handling. We set the contents of various
15349 dynamic sections here. */
15350
15351 static bfd_boolean
15352 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15353 struct bfd_link_info *info,
15354 struct elf_link_hash_entry *h,
15355 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15356 {
15357 struct ppc_link_hash_table *htab;
15358 struct plt_entry *ent;
15359 Elf_Internal_Rela rela;
15360 bfd_byte *loc;
15361
15362 htab = ppc_hash_table (info);
15363 if (htab == NULL)
15364 return FALSE;
15365
15366 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15367 if (ent->plt.offset != (bfd_vma) -1)
15368 {
15369 /* This symbol has an entry in the procedure linkage
15370 table. Set it up. */
15371 if (!htab->elf.dynamic_sections_created
15372 || h->dynindx == -1)
15373 {
15374 BFD_ASSERT (h->type == STT_GNU_IFUNC
15375 && h->def_regular
15376 && (h->root.type == bfd_link_hash_defined
15377 || h->root.type == bfd_link_hash_defweak));
15378 rela.r_offset = (htab->elf.iplt->output_section->vma
15379 + htab->elf.iplt->output_offset
15380 + ent->plt.offset);
15381 if (htab->opd_abi)
15382 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15383 else
15384 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15385 rela.r_addend = (h->root.u.def.value
15386 + h->root.u.def.section->output_offset
15387 + h->root.u.def.section->output_section->vma
15388 + ent->addend);
15389 loc = (htab->elf.irelplt->contents
15390 + (htab->elf.irelplt->reloc_count++
15391 * sizeof (Elf64_External_Rela)));
15392 }
15393 else
15394 {
15395 rela.r_offset = (htab->elf.splt->output_section->vma
15396 + htab->elf.splt->output_offset
15397 + ent->plt.offset);
15398 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15399 rela.r_addend = ent->addend;
15400 loc = (htab->elf.srelplt->contents
15401 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15402 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15403 }
15404 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15405
15406 if (!htab->opd_abi)
15407 {
15408 if (!h->def_regular)
15409 {
15410 /* Mark the symbol as undefined, rather than as
15411 defined in glink. Leave the value if there were
15412 any relocations where pointer equality matters
15413 (this is a clue for the dynamic linker, to make
15414 function pointer comparisons work between an
15415 application and shared library), otherwise set it
15416 to zero. */
15417 sym->st_shndx = SHN_UNDEF;
15418 if (!h->pointer_equality_needed)
15419 sym->st_value = 0;
15420 else if (!h->ref_regular_nonweak)
15421 {
15422 /* This breaks function pointer comparisons, but
15423 that is better than breaking tests for a NULL
15424 function pointer. */
15425 sym->st_value = 0;
15426 }
15427 }
15428 }
15429 }
15430
15431 if (h->needs_copy)
15432 {
15433 /* This symbol needs a copy reloc. Set it up. */
15434
15435 if (h->dynindx == -1
15436 || (h->root.type != bfd_link_hash_defined
15437 && h->root.type != bfd_link_hash_defweak)
15438 || htab->relbss == NULL)
15439 abort ();
15440
15441 rela.r_offset = (h->root.u.def.value
15442 + h->root.u.def.section->output_section->vma
15443 + h->root.u.def.section->output_offset);
15444 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15445 rela.r_addend = 0;
15446 loc = htab->relbss->contents;
15447 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15448 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15449 }
15450
15451 return TRUE;
15452 }
15453
15454 /* Used to decide how to sort relocs in an optimal manner for the
15455 dynamic linker, before writing them out. */
15456
15457 static enum elf_reloc_type_class
15458 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15459 const asection *rel_sec,
15460 const Elf_Internal_Rela *rela)
15461 {
15462 enum elf_ppc64_reloc_type r_type;
15463 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15464
15465 if (rel_sec == htab->elf.irelplt)
15466 return reloc_class_ifunc;
15467
15468 r_type = ELF64_R_TYPE (rela->r_info);
15469 switch (r_type)
15470 {
15471 case R_PPC64_RELATIVE:
15472 return reloc_class_relative;
15473 case R_PPC64_JMP_SLOT:
15474 return reloc_class_plt;
15475 case R_PPC64_COPY:
15476 return reloc_class_copy;
15477 default:
15478 return reloc_class_normal;
15479 }
15480 }
15481
15482 /* Finish up the dynamic sections. */
15483
15484 static bfd_boolean
15485 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15486 struct bfd_link_info *info)
15487 {
15488 struct ppc_link_hash_table *htab;
15489 bfd *dynobj;
15490 asection *sdyn;
15491
15492 htab = ppc_hash_table (info);
15493 if (htab == NULL)
15494 return FALSE;
15495
15496 dynobj = htab->elf.dynobj;
15497 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15498
15499 if (htab->elf.dynamic_sections_created)
15500 {
15501 Elf64_External_Dyn *dyncon, *dynconend;
15502
15503 if (sdyn == NULL || htab->elf.sgot == NULL)
15504 abort ();
15505
15506 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15507 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15508 for (; dyncon < dynconend; dyncon++)
15509 {
15510 Elf_Internal_Dyn dyn;
15511 asection *s;
15512
15513 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15514
15515 switch (dyn.d_tag)
15516 {
15517 default:
15518 continue;
15519
15520 case DT_PPC64_GLINK:
15521 s = htab->glink;
15522 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15523 /* We stupidly defined DT_PPC64_GLINK to be the start
15524 of glink rather than the first entry point, which is
15525 what ld.so needs, and now have a bigger stub to
15526 support automatic multiple TOCs. */
15527 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15528 break;
15529
15530 case DT_PPC64_OPD:
15531 s = bfd_get_section_by_name (output_bfd, ".opd");
15532 if (s == NULL)
15533 continue;
15534 dyn.d_un.d_ptr = s->vma;
15535 break;
15536
15537 case DT_PPC64_OPT:
15538 if (htab->do_multi_toc && htab->multi_toc_needed)
15539 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15540 break;
15541
15542 case DT_PPC64_OPDSZ:
15543 s = bfd_get_section_by_name (output_bfd, ".opd");
15544 if (s == NULL)
15545 continue;
15546 dyn.d_un.d_val = s->size;
15547 break;
15548
15549 case DT_PLTGOT:
15550 s = htab->elf.splt;
15551 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15552 break;
15553
15554 case DT_JMPREL:
15555 s = htab->elf.srelplt;
15556 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15557 break;
15558
15559 case DT_PLTRELSZ:
15560 dyn.d_un.d_val = htab->elf.srelplt->size;
15561 break;
15562 }
15563
15564 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15565 }
15566 }
15567
15568 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15569 {
15570 /* Fill in the first entry in the global offset table.
15571 We use it to hold the link-time TOCbase. */
15572 bfd_put_64 (output_bfd,
15573 elf_gp (output_bfd) + TOC_BASE_OFF,
15574 htab->elf.sgot->contents);
15575
15576 /* Set .got entry size. */
15577 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15578 }
15579
15580 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15581 {
15582 /* Set .plt entry size. */
15583 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15584 = PLT_ENTRY_SIZE (htab);
15585 }
15586
15587 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15588 brlt ourselves if emitrelocations. */
15589 if (htab->brlt != NULL
15590 && htab->brlt->reloc_count != 0
15591 && !_bfd_elf_link_output_relocs (output_bfd,
15592 htab->brlt,
15593 elf_section_data (htab->brlt)->rela.hdr,
15594 elf_section_data (htab->brlt)->relocs,
15595 NULL))
15596 return FALSE;
15597
15598 if (htab->glink != NULL
15599 && htab->glink->reloc_count != 0
15600 && !_bfd_elf_link_output_relocs (output_bfd,
15601 htab->glink,
15602 elf_section_data (htab->glink)->rela.hdr,
15603 elf_section_data (htab->glink)->relocs,
15604 NULL))
15605 return FALSE;
15606
15607 if (htab->glink_eh_frame != NULL
15608 && htab->glink_eh_frame->size != 0)
15609 {
15610 bfd_vma val;
15611 bfd_byte *p;
15612 asection *stub_sec;
15613
15614 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15615 for (stub_sec = htab->params->stub_bfd->sections;
15616 stub_sec != NULL;
15617 stub_sec = stub_sec->next)
15618 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15619 {
15620 /* FDE length. */
15621 p += 4;
15622 /* CIE pointer. */
15623 p += 4;
15624 /* Offset to stub section. */
15625 val = (stub_sec->output_section->vma
15626 + stub_sec->output_offset);
15627 val -= (htab->glink_eh_frame->output_section->vma
15628 + htab->glink_eh_frame->output_offset
15629 + (p - htab->glink_eh_frame->contents));
15630 if (val + 0x80000000 > 0xffffffff)
15631 {
15632 info->callbacks->einfo
15633 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15634 stub_sec->name);
15635 return FALSE;
15636 }
15637 bfd_put_32 (dynobj, val, p);
15638 p += 4;
15639 /* stub section size. */
15640 p += 4;
15641 /* Augmentation. */
15642 p += 1;
15643 /* Pad. */
15644 p += 7;
15645 }
15646 if (htab->glink != NULL && htab->glink->size != 0)
15647 {
15648 /* FDE length. */
15649 p += 4;
15650 /* CIE pointer. */
15651 p += 4;
15652 /* Offset to .glink. */
15653 val = (htab->glink->output_section->vma
15654 + htab->glink->output_offset
15655 + 8);
15656 val -= (htab->glink_eh_frame->output_section->vma
15657 + htab->glink_eh_frame->output_offset
15658 + (p - htab->glink_eh_frame->contents));
15659 if (val + 0x80000000 > 0xffffffff)
15660 {
15661 info->callbacks->einfo
15662 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15663 htab->glink->name);
15664 return FALSE;
15665 }
15666 bfd_put_32 (dynobj, val, p);
15667 p += 4;
15668 /* .glink size. */
15669 p += 4;
15670 /* Augmentation. */
15671 p += 1;
15672 /* Ops. */
15673 p += 7;
15674 }
15675
15676 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15677 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15678 htab->glink_eh_frame,
15679 htab->glink_eh_frame->contents))
15680 return FALSE;
15681 }
15682
15683 /* We need to handle writing out multiple GOT sections ourselves,
15684 since we didn't add them to DYNOBJ. We know dynobj is the first
15685 bfd. */
15686 while ((dynobj = dynobj->link.next) != NULL)
15687 {
15688 asection *s;
15689
15690 if (!is_ppc64_elf (dynobj))
15691 continue;
15692
15693 s = ppc64_elf_tdata (dynobj)->got;
15694 if (s != NULL
15695 && s->size != 0
15696 && s->output_section != bfd_abs_section_ptr
15697 && !bfd_set_section_contents (output_bfd, s->output_section,
15698 s->contents, s->output_offset,
15699 s->size))
15700 return FALSE;
15701 s = ppc64_elf_tdata (dynobj)->relgot;
15702 if (s != NULL
15703 && s->size != 0
15704 && s->output_section != bfd_abs_section_ptr
15705 && !bfd_set_section_contents (output_bfd, s->output_section,
15706 s->contents, s->output_offset,
15707 s->size))
15708 return FALSE;
15709 }
15710
15711 return TRUE;
15712 }
15713
15714 #include "elf64-target.h"
15715
15716 /* FreeBSD support */
15717
15718 #undef TARGET_LITTLE_SYM
15719 #undef TARGET_LITTLE_NAME
15720
15721 #undef TARGET_BIG_SYM
15722 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15723 #undef TARGET_BIG_NAME
15724 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15725
15726 #undef ELF_OSABI
15727 #define ELF_OSABI ELFOSABI_FREEBSD
15728
15729 #undef elf64_bed
15730 #define elf64_bed elf64_powerpc_fbsd_bed
15731
15732 #include "elf64-target.h"
15733