projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Put .dynbss and .rel.bss shortcuts in main elf hash table
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2016 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_dtrel_excludes_plt 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
91
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_before_check_relocs
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded ppc64_elf_action_discarded
115 #define elf_backend_relocate_section ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections ppc64_elf_special_sections
121 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
122 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
123
124 /* The name of the dynamic interpreter. This is put in the .interp
125 section. */
126 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
127
128 /* The size in bytes of an entry in the procedure linkage table. */
129 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
130
131 /* The initial size of the plt reserved for the dynamic linker. */
132 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
133
134 /* Offsets to some stack save slots. */
135 #define STK_LR 16
136 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
137 /* This one is dodgy. ELFv2 does not have a linker word, so use the
138 CR save slot. Used only by optimised __tls_get_addr call stub,
139 relying on __tls_get_addr_opt not saving CR.. */
140 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
141
142 /* TOC base pointers offset from start of TOC. */
143 #define TOC_BASE_OFF 0x8000
144 /* TOC base alignment. */
145 #define TOC_BASE_ALIGN 256
146
147 /* Offset of tp and dtp pointers from start of TLS block. */
148 #define TP_OFFSET 0x7000
149 #define DTP_OFFSET 0x8000
150
151 /* .plt call stub instructions. The normal stub is like this, but
152 sometimes the .plt entry crosses a 64k boundary and we need to
153 insert an addi to adjust r11. */
154 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
155 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
156 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
157 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
158 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
159 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
160 #define BCTR 0x4e800420 /* bctr */
161
162 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
163 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
164 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
165
166 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
167 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
168 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
169 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
170 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
171 #define BNECTR 0x4ca20420 /* bnectr+ */
172 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
173
174 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
175 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
176 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
177
178 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
179 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
180 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
181
182 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
183 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
184 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
185 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
186 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
187
188 /* glink call stub instructions. We enter with the index in R0. */
189 #define GLINK_CALL_STUB_SIZE (16*4)
190 /* 0: */
191 /* .quad plt0-1f */
192 /* __glink: */
193 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
194 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
195 /* 1: */
196 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
197 /* ld %2,(0b-1b)(%11) */
198 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
199 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
200 /* ld %12,0(%11) */
201 /* ld %2,8(%11) */
202 /* mtctr %12 */
203 /* ld %11,16(%11) */
204 /* bctr */
205 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
206 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
207 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
208 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
209 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
210
211 /* Pad with this. */
212 #define NOP 0x60000000
213
214 /* Some other nops. */
215 #define CROR_151515 0x4def7b82
216 #define CROR_313131 0x4ffffb82
217
218 /* .glink entries for the first 32k functions are two instructions. */
219 #define LI_R0_0 0x38000000 /* li %r0,0 */
220 #define B_DOT 0x48000000 /* b . */
221
222 /* After that, we need two instructions to load the index, followed by
223 a branch. */
224 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
225 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
226
227 /* Instructions used by the save and restore reg functions. */
228 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
229 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
230 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
231 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
232 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
233 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
234 #define LI_R12_0 0x39800000 /* li %r12,0 */
235 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
236 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
237 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
238 #define BLR 0x4e800020 /* blr */
239
240 /* Since .opd is an array of descriptors and each entry will end up
241 with identical R_PPC64_RELATIVE relocs, there is really no need to
242 propagate .opd relocs; The dynamic linker should be taught to
243 relocate .opd without reloc entries. */
244 #ifndef NO_OPD_RELOCS
245 #define NO_OPD_RELOCS 0
246 #endif
247
248 #ifndef ARRAY_SIZE
249 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
250 #endif
251
252 static inline int
253 abiversion (bfd *abfd)
254 {
255 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
256 }
257
258 static inline void
259 set_abiversion (bfd *abfd, int ver)
260 {
261 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
262 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
263 }
264 \f
265 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
266
267 /* Relocation HOWTO's. */
268 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
269
270 static reloc_howto_type ppc64_elf_howto_raw[] = {
271 /* This reloc does nothing. */
272 HOWTO (R_PPC64_NONE, /* type */
273 0, /* rightshift */
274 3, /* size (0 = byte, 1 = short, 2 = long) */
275 0, /* bitsize */
276 FALSE, /* pc_relative */
277 0, /* bitpos */
278 complain_overflow_dont, /* complain_on_overflow */
279 bfd_elf_generic_reloc, /* special_function */
280 "R_PPC64_NONE", /* name */
281 FALSE, /* partial_inplace */
282 0, /* src_mask */
283 0, /* dst_mask */
284 FALSE), /* pcrel_offset */
285
286 /* A standard 32 bit relocation. */
287 HOWTO (R_PPC64_ADDR32, /* type */
288 0, /* rightshift */
289 2, /* size (0 = byte, 1 = short, 2 = long) */
290 32, /* bitsize */
291 FALSE, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_bitfield, /* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_PPC64_ADDR32", /* name */
296 FALSE, /* partial_inplace */
297 0, /* src_mask */
298 0xffffffff, /* dst_mask */
299 FALSE), /* pcrel_offset */
300
301 /* An absolute 26 bit branch; the lower two bits must be zero.
302 FIXME: we don't check that, we just clear them. */
303 HOWTO (R_PPC64_ADDR24, /* type */
304 0, /* rightshift */
305 2, /* size (0 = byte, 1 = short, 2 = long) */
306 26, /* bitsize */
307 FALSE, /* pc_relative */
308 0, /* bitpos */
309 complain_overflow_bitfield, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_PPC64_ADDR24", /* name */
312 FALSE, /* partial_inplace */
313 0, /* src_mask */
314 0x03fffffc, /* dst_mask */
315 FALSE), /* pcrel_offset */
316
317 /* A standard 16 bit relocation. */
318 HOWTO (R_PPC64_ADDR16, /* type */
319 0, /* rightshift */
320 1, /* size (0 = byte, 1 = short, 2 = long) */
321 16, /* bitsize */
322 FALSE, /* pc_relative */
323 0, /* bitpos */
324 complain_overflow_bitfield, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_PPC64_ADDR16", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0xffff, /* dst_mask */
330 FALSE), /* pcrel_offset */
331
332 /* A 16 bit relocation without overflow. */
333 HOWTO (R_PPC64_ADDR16_LO, /* type */
334 0, /* rightshift */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
336 16, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_dont,/* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_PPC64_ADDR16_LO", /* name */
342 FALSE, /* partial_inplace */
343 0, /* src_mask */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 /* Bits 16-31 of an address. */
348 HOWTO (R_PPC64_ADDR16_HI, /* type */
349 16, /* rightshift */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 FALSE, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_signed, /* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_PPC64_ADDR16_HI", /* name */
357 FALSE, /* partial_inplace */
358 0, /* src_mask */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
361
362 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
363 bits, treated as a signed number, is negative. */
364 HOWTO (R_PPC64_ADDR16_HA, /* type */
365 16, /* rightshift */
366 1, /* size (0 = byte, 1 = short, 2 = long) */
367 16, /* bitsize */
368 FALSE, /* pc_relative */
369 0, /* bitpos */
370 complain_overflow_signed, /* complain_on_overflow */
371 ppc64_elf_ha_reloc, /* special_function */
372 "R_PPC64_ADDR16_HA", /* name */
373 FALSE, /* partial_inplace */
374 0, /* src_mask */
375 0xffff, /* dst_mask */
376 FALSE), /* pcrel_offset */
377
378 /* An absolute 16 bit branch; the lower two bits must be zero.
379 FIXME: we don't check that, we just clear them. */
380 HOWTO (R_PPC64_ADDR14, /* type */
381 0, /* rightshift */
382 2, /* size (0 = byte, 1 = short, 2 = long) */
383 16, /* bitsize */
384 FALSE, /* pc_relative */
385 0, /* bitpos */
386 complain_overflow_signed, /* complain_on_overflow */
387 ppc64_elf_branch_reloc, /* special_function */
388 "R_PPC64_ADDR14", /* name */
389 FALSE, /* partial_inplace */
390 0, /* src_mask */
391 0x0000fffc, /* dst_mask */
392 FALSE), /* pcrel_offset */
393
394 /* An absolute 16 bit branch, for which bit 10 should be set to
395 indicate that the branch is expected to be taken. The lower two
396 bits must be zero. */
397 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
398 0, /* rightshift */
399 2, /* size (0 = byte, 1 = short, 2 = long) */
400 16, /* bitsize */
401 FALSE, /* pc_relative */
402 0, /* bitpos */
403 complain_overflow_signed, /* complain_on_overflow */
404 ppc64_elf_brtaken_reloc, /* special_function */
405 "R_PPC64_ADDR14_BRTAKEN",/* name */
406 FALSE, /* partial_inplace */
407 0, /* src_mask */
408 0x0000fffc, /* dst_mask */
409 FALSE), /* pcrel_offset */
410
411 /* An absolute 16 bit branch, for which bit 10 should be set to
412 indicate that the branch is not expected to be taken. The lower
413 two bits must be zero. */
414 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
415 0, /* rightshift */
416 2, /* size (0 = byte, 1 = short, 2 = long) */
417 16, /* bitsize */
418 FALSE, /* pc_relative */
419 0, /* bitpos */
420 complain_overflow_signed, /* complain_on_overflow */
421 ppc64_elf_brtaken_reloc, /* special_function */
422 "R_PPC64_ADDR14_BRNTAKEN",/* name */
423 FALSE, /* partial_inplace */
424 0, /* src_mask */
425 0x0000fffc, /* dst_mask */
426 FALSE), /* pcrel_offset */
427
428 /* A relative 26 bit branch; the lower two bits must be zero. */
429 HOWTO (R_PPC64_REL24, /* type */
430 0, /* rightshift */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
432 26, /* bitsize */
433 TRUE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_signed, /* complain_on_overflow */
436 ppc64_elf_branch_reloc, /* special_function */
437 "R_PPC64_REL24", /* name */
438 FALSE, /* partial_inplace */
439 0, /* src_mask */
440 0x03fffffc, /* dst_mask */
441 TRUE), /* pcrel_offset */
442
443 /* A relative 16 bit branch; the lower two bits must be zero. */
444 HOWTO (R_PPC64_REL14, /* type */
445 0, /* rightshift */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
447 16, /* bitsize */
448 TRUE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_signed, /* complain_on_overflow */
451 ppc64_elf_branch_reloc, /* special_function */
452 "R_PPC64_REL14", /* name */
453 FALSE, /* partial_inplace */
454 0, /* src_mask */
455 0x0000fffc, /* dst_mask */
456 TRUE), /* pcrel_offset */
457
458 /* A relative 16 bit branch. Bit 10 should be set to indicate that
459 the branch is expected to be taken. The lower two bits must be
460 zero. */
461 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
462 0, /* rightshift */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
464 16, /* bitsize */
465 TRUE, /* pc_relative */
466 0, /* bitpos */
467 complain_overflow_signed, /* complain_on_overflow */
468 ppc64_elf_brtaken_reloc, /* special_function */
469 "R_PPC64_REL14_BRTAKEN", /* name */
470 FALSE, /* partial_inplace */
471 0, /* src_mask */
472 0x0000fffc, /* dst_mask */
473 TRUE), /* pcrel_offset */
474
475 /* A relative 16 bit branch. Bit 10 should be set to indicate that
476 the branch is not expected to be taken. The lower two bits must
477 be zero. */
478 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
479 0, /* rightshift */
480 2, /* size (0 = byte, 1 = short, 2 = long) */
481 16, /* bitsize */
482 TRUE, /* pc_relative */
483 0, /* bitpos */
484 complain_overflow_signed, /* complain_on_overflow */
485 ppc64_elf_brtaken_reloc, /* special_function */
486 "R_PPC64_REL14_BRNTAKEN",/* name */
487 FALSE, /* partial_inplace */
488 0, /* src_mask */
489 0x0000fffc, /* dst_mask */
490 TRUE), /* pcrel_offset */
491
492 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
493 symbol. */
494 HOWTO (R_PPC64_GOT16, /* type */
495 0, /* rightshift */
496 1, /* size (0 = byte, 1 = short, 2 = long) */
497 16, /* bitsize */
498 FALSE, /* pc_relative */
499 0, /* bitpos */
500 complain_overflow_signed, /* complain_on_overflow */
501 ppc64_elf_unhandled_reloc, /* special_function */
502 "R_PPC64_GOT16", /* name */
503 FALSE, /* partial_inplace */
504 0, /* src_mask */
505 0xffff, /* dst_mask */
506 FALSE), /* pcrel_offset */
507
508 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
509 the symbol. */
510 HOWTO (R_PPC64_GOT16_LO, /* type */
511 0, /* rightshift */
512 1, /* size (0 = byte, 1 = short, 2 = long) */
513 16, /* bitsize */
514 FALSE, /* pc_relative */
515 0, /* bitpos */
516 complain_overflow_dont, /* complain_on_overflow */
517 ppc64_elf_unhandled_reloc, /* special_function */
518 "R_PPC64_GOT16_LO", /* name */
519 FALSE, /* partial_inplace */
520 0, /* src_mask */
521 0xffff, /* dst_mask */
522 FALSE), /* pcrel_offset */
523
524 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
525 the symbol. */
526 HOWTO (R_PPC64_GOT16_HI, /* type */
527 16, /* rightshift */
528 1, /* size (0 = byte, 1 = short, 2 = long) */
529 16, /* bitsize */
530 FALSE, /* pc_relative */
531 0, /* bitpos */
532 complain_overflow_signed,/* complain_on_overflow */
533 ppc64_elf_unhandled_reloc, /* special_function */
534 "R_PPC64_GOT16_HI", /* name */
535 FALSE, /* partial_inplace */
536 0, /* src_mask */
537 0xffff, /* dst_mask */
538 FALSE), /* pcrel_offset */
539
540 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
541 the symbol. */
542 HOWTO (R_PPC64_GOT16_HA, /* type */
543 16, /* rightshift */
544 1, /* size (0 = byte, 1 = short, 2 = long) */
545 16, /* bitsize */
546 FALSE, /* pc_relative */
547 0, /* bitpos */
548 complain_overflow_signed,/* complain_on_overflow */
549 ppc64_elf_unhandled_reloc, /* special_function */
550 "R_PPC64_GOT16_HA", /* name */
551 FALSE, /* partial_inplace */
552 0, /* src_mask */
553 0xffff, /* dst_mask */
554 FALSE), /* pcrel_offset */
555
556 /* This is used only by the dynamic linker. The symbol should exist
557 both in the object being run and in some shared library. The
558 dynamic linker copies the data addressed by the symbol from the
559 shared library into the object, because the object being
560 run has to have the data at some particular address. */
561 HOWTO (R_PPC64_COPY, /* type */
562 0, /* rightshift */
563 0, /* this one is variable size */
564 0, /* bitsize */
565 FALSE, /* pc_relative */
566 0, /* bitpos */
567 complain_overflow_dont, /* complain_on_overflow */
568 ppc64_elf_unhandled_reloc, /* special_function */
569 "R_PPC64_COPY", /* name */
570 FALSE, /* partial_inplace */
571 0, /* src_mask */
572 0, /* dst_mask */
573 FALSE), /* pcrel_offset */
574
575 /* Like R_PPC64_ADDR64, but used when setting global offset table
576 entries. */
577 HOWTO (R_PPC64_GLOB_DAT, /* type */
578 0, /* rightshift */
579 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
580 64, /* bitsize */
581 FALSE, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_dont, /* complain_on_overflow */
584 ppc64_elf_unhandled_reloc, /* special_function */
585 "R_PPC64_GLOB_DAT", /* name */
586 FALSE, /* partial_inplace */
587 0, /* src_mask */
588 ONES (64), /* dst_mask */
589 FALSE), /* pcrel_offset */
590
591 /* Created by the link editor. Marks a procedure linkage table
592 entry for a symbol. */
593 HOWTO (R_PPC64_JMP_SLOT, /* type */
594 0, /* rightshift */
595 0, /* size (0 = byte, 1 = short, 2 = long) */
596 0, /* bitsize */
597 FALSE, /* pc_relative */
598 0, /* bitpos */
599 complain_overflow_dont, /* complain_on_overflow */
600 ppc64_elf_unhandled_reloc, /* special_function */
601 "R_PPC64_JMP_SLOT", /* name */
602 FALSE, /* partial_inplace */
603 0, /* src_mask */
604 0, /* dst_mask */
605 FALSE), /* pcrel_offset */
606
607 /* Used only by the dynamic linker. When the object is run, this
608 doubleword64 is set to the load address of the object, plus the
609 addend. */
610 HOWTO (R_PPC64_RELATIVE, /* type */
611 0, /* rightshift */
612 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
613 64, /* bitsize */
614 FALSE, /* pc_relative */
615 0, /* bitpos */
616 complain_overflow_dont, /* complain_on_overflow */
617 bfd_elf_generic_reloc, /* special_function */
618 "R_PPC64_RELATIVE", /* name */
619 FALSE, /* partial_inplace */
620 0, /* src_mask */
621 ONES (64), /* dst_mask */
622 FALSE), /* pcrel_offset */
623
624 /* Like R_PPC64_ADDR32, but may be unaligned. */
625 HOWTO (R_PPC64_UADDR32, /* type */
626 0, /* rightshift */
627 2, /* size (0 = byte, 1 = short, 2 = long) */
628 32, /* bitsize */
629 FALSE, /* pc_relative */
630 0, /* bitpos */
631 complain_overflow_bitfield, /* complain_on_overflow */
632 bfd_elf_generic_reloc, /* special_function */
633 "R_PPC64_UADDR32", /* name */
634 FALSE, /* partial_inplace */
635 0, /* src_mask */
636 0xffffffff, /* dst_mask */
637 FALSE), /* pcrel_offset */
638
639 /* Like R_PPC64_ADDR16, but may be unaligned. */
640 HOWTO (R_PPC64_UADDR16, /* type */
641 0, /* rightshift */
642 1, /* size (0 = byte, 1 = short, 2 = long) */
643 16, /* bitsize */
644 FALSE, /* pc_relative */
645 0, /* bitpos */
646 complain_overflow_bitfield, /* complain_on_overflow */
647 bfd_elf_generic_reloc, /* special_function */
648 "R_PPC64_UADDR16", /* name */
649 FALSE, /* partial_inplace */
650 0, /* src_mask */
651 0xffff, /* dst_mask */
652 FALSE), /* pcrel_offset */
653
654 /* 32-bit PC relative. */
655 HOWTO (R_PPC64_REL32, /* type */
656 0, /* rightshift */
657 2, /* size (0 = byte, 1 = short, 2 = long) */
658 32, /* bitsize */
659 TRUE, /* pc_relative */
660 0, /* bitpos */
661 complain_overflow_signed, /* complain_on_overflow */
662 bfd_elf_generic_reloc, /* special_function */
663 "R_PPC64_REL32", /* name */
664 FALSE, /* partial_inplace */
665 0, /* src_mask */
666 0xffffffff, /* dst_mask */
667 TRUE), /* pcrel_offset */
668
669 /* 32-bit relocation to the symbol's procedure linkage table. */
670 HOWTO (R_PPC64_PLT32, /* type */
671 0, /* rightshift */
672 2, /* size (0 = byte, 1 = short, 2 = long) */
673 32, /* bitsize */
674 FALSE, /* pc_relative */
675 0, /* bitpos */
676 complain_overflow_bitfield, /* complain_on_overflow */
677 ppc64_elf_unhandled_reloc, /* special_function */
678 "R_PPC64_PLT32", /* name */
679 FALSE, /* partial_inplace */
680 0, /* src_mask */
681 0xffffffff, /* dst_mask */
682 FALSE), /* pcrel_offset */
683
684 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
685 FIXME: R_PPC64_PLTREL32 not supported. */
686 HOWTO (R_PPC64_PLTREL32, /* type */
687 0, /* rightshift */
688 2, /* size (0 = byte, 1 = short, 2 = long) */
689 32, /* bitsize */
690 TRUE, /* pc_relative */
691 0, /* bitpos */
692 complain_overflow_signed, /* complain_on_overflow */
693 ppc64_elf_unhandled_reloc, /* special_function */
694 "R_PPC64_PLTREL32", /* name */
695 FALSE, /* partial_inplace */
696 0, /* src_mask */
697 0xffffffff, /* dst_mask */
698 TRUE), /* pcrel_offset */
699
700 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
701 the symbol. */
702 HOWTO (R_PPC64_PLT16_LO, /* type */
703 0, /* rightshift */
704 1, /* size (0 = byte, 1 = short, 2 = long) */
705 16, /* bitsize */
706 FALSE, /* pc_relative */
707 0, /* bitpos */
708 complain_overflow_dont, /* complain_on_overflow */
709 ppc64_elf_unhandled_reloc, /* special_function */
710 "R_PPC64_PLT16_LO", /* name */
711 FALSE, /* partial_inplace */
712 0, /* src_mask */
713 0xffff, /* dst_mask */
714 FALSE), /* pcrel_offset */
715
716 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
717 the symbol. */
718 HOWTO (R_PPC64_PLT16_HI, /* type */
719 16, /* rightshift */
720 1, /* size (0 = byte, 1 = short, 2 = long) */
721 16, /* bitsize */
722 FALSE, /* pc_relative */
723 0, /* bitpos */
724 complain_overflow_signed, /* complain_on_overflow */
725 ppc64_elf_unhandled_reloc, /* special_function */
726 "R_PPC64_PLT16_HI", /* name */
727 FALSE, /* partial_inplace */
728 0, /* src_mask */
729 0xffff, /* dst_mask */
730 FALSE), /* pcrel_offset */
731
732 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
733 the symbol. */
734 HOWTO (R_PPC64_PLT16_HA, /* type */
735 16, /* rightshift */
736 1, /* size (0 = byte, 1 = short, 2 = long) */
737 16, /* bitsize */
738 FALSE, /* pc_relative */
739 0, /* bitpos */
740 complain_overflow_signed, /* complain_on_overflow */
741 ppc64_elf_unhandled_reloc, /* special_function */
742 "R_PPC64_PLT16_HA", /* name */
743 FALSE, /* partial_inplace */
744 0, /* src_mask */
745 0xffff, /* dst_mask */
746 FALSE), /* pcrel_offset */
747
748 /* 16-bit section relative relocation. */
749 HOWTO (R_PPC64_SECTOFF, /* type */
750 0, /* rightshift */
751 1, /* size (0 = byte, 1 = short, 2 = long) */
752 16, /* bitsize */
753 FALSE, /* pc_relative */
754 0, /* bitpos */
755 complain_overflow_signed, /* complain_on_overflow */
756 ppc64_elf_sectoff_reloc, /* special_function */
757 "R_PPC64_SECTOFF", /* name */
758 FALSE, /* partial_inplace */
759 0, /* src_mask */
760 0xffff, /* dst_mask */
761 FALSE), /* pcrel_offset */
762
763 /* Like R_PPC64_SECTOFF, but no overflow warning. */
764 HOWTO (R_PPC64_SECTOFF_LO, /* type */
765 0, /* rightshift */
766 1, /* size (0 = byte, 1 = short, 2 = long) */
767 16, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_dont, /* complain_on_overflow */
771 ppc64_elf_sectoff_reloc, /* special_function */
772 "R_PPC64_SECTOFF_LO", /* name */
773 FALSE, /* partial_inplace */
774 0, /* src_mask */
775 0xffff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 /* 16-bit upper half section relative relocation. */
779 HOWTO (R_PPC64_SECTOFF_HI, /* type */
780 16, /* rightshift */
781 1, /* size (0 = byte, 1 = short, 2 = long) */
782 16, /* bitsize */
783 FALSE, /* pc_relative */
784 0, /* bitpos */
785 complain_overflow_signed, /* complain_on_overflow */
786 ppc64_elf_sectoff_reloc, /* special_function */
787 "R_PPC64_SECTOFF_HI", /* name */
788 FALSE, /* partial_inplace */
789 0, /* src_mask */
790 0xffff, /* dst_mask */
791 FALSE), /* pcrel_offset */
792
793 /* 16-bit upper half adjusted section relative relocation. */
794 HOWTO (R_PPC64_SECTOFF_HA, /* type */
795 16, /* rightshift */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
797 16, /* bitsize */
798 FALSE, /* pc_relative */
799 0, /* bitpos */
800 complain_overflow_signed, /* complain_on_overflow */
801 ppc64_elf_sectoff_ha_reloc, /* special_function */
802 "R_PPC64_SECTOFF_HA", /* name */
803 FALSE, /* partial_inplace */
804 0, /* src_mask */
805 0xffff, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 /* Like R_PPC64_REL24 without touching the two least significant bits. */
809 HOWTO (R_PPC64_REL30, /* type */
810 2, /* rightshift */
811 2, /* size (0 = byte, 1 = short, 2 = long) */
812 30, /* bitsize */
813 TRUE, /* pc_relative */
814 0, /* bitpos */
815 complain_overflow_dont, /* complain_on_overflow */
816 bfd_elf_generic_reloc, /* special_function */
817 "R_PPC64_REL30", /* name */
818 FALSE, /* partial_inplace */
819 0, /* src_mask */
820 0xfffffffc, /* dst_mask */
821 TRUE), /* pcrel_offset */
822
823 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
824
825 /* A standard 64-bit relocation. */
826 HOWTO (R_PPC64_ADDR64, /* type */
827 0, /* rightshift */
828 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
829 64, /* bitsize */
830 FALSE, /* pc_relative */
831 0, /* bitpos */
832 complain_overflow_dont, /* complain_on_overflow */
833 bfd_elf_generic_reloc, /* special_function */
834 "R_PPC64_ADDR64", /* name */
835 FALSE, /* partial_inplace */
836 0, /* src_mask */
837 ONES (64), /* dst_mask */
838 FALSE), /* pcrel_offset */
839
840 /* The bits 32-47 of an address. */
841 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
842 32, /* rightshift */
843 1, /* size (0 = byte, 1 = short, 2 = long) */
844 16, /* bitsize */
845 FALSE, /* pc_relative */
846 0, /* bitpos */
847 complain_overflow_dont, /* complain_on_overflow */
848 bfd_elf_generic_reloc, /* special_function */
849 "R_PPC64_ADDR16_HIGHER", /* name */
850 FALSE, /* partial_inplace */
851 0, /* src_mask */
852 0xffff, /* dst_mask */
853 FALSE), /* pcrel_offset */
854
855 /* The bits 32-47 of an address, plus 1 if the contents of the low
856 16 bits, treated as a signed number, is negative. */
857 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
858 32, /* rightshift */
859 1, /* size (0 = byte, 1 = short, 2 = long) */
860 16, /* bitsize */
861 FALSE, /* pc_relative */
862 0, /* bitpos */
863 complain_overflow_dont, /* complain_on_overflow */
864 ppc64_elf_ha_reloc, /* special_function */
865 "R_PPC64_ADDR16_HIGHERA", /* name */
866 FALSE, /* partial_inplace */
867 0, /* src_mask */
868 0xffff, /* dst_mask */
869 FALSE), /* pcrel_offset */
870
871 /* The bits 48-63 of an address. */
872 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
873 48, /* rightshift */
874 1, /* size (0 = byte, 1 = short, 2 = long) */
875 16, /* bitsize */
876 FALSE, /* pc_relative */
877 0, /* bitpos */
878 complain_overflow_dont, /* complain_on_overflow */
879 bfd_elf_generic_reloc, /* special_function */
880 "R_PPC64_ADDR16_HIGHEST", /* name */
881 FALSE, /* partial_inplace */
882 0, /* src_mask */
883 0xffff, /* dst_mask */
884 FALSE), /* pcrel_offset */
885
886 /* The bits 48-63 of an address, plus 1 if the contents of the low
887 16 bits, treated as a signed number, is negative. */
888 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
889 48, /* rightshift */
890 1, /* size (0 = byte, 1 = short, 2 = long) */
891 16, /* bitsize */
892 FALSE, /* pc_relative */
893 0, /* bitpos */
894 complain_overflow_dont, /* complain_on_overflow */
895 ppc64_elf_ha_reloc, /* special_function */
896 "R_PPC64_ADDR16_HIGHESTA", /* name */
897 FALSE, /* partial_inplace */
898 0, /* src_mask */
899 0xffff, /* dst_mask */
900 FALSE), /* pcrel_offset */
901
902 /* Like ADDR64, but may be unaligned. */
903 HOWTO (R_PPC64_UADDR64, /* type */
904 0, /* rightshift */
905 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
906 64, /* bitsize */
907 FALSE, /* pc_relative */
908 0, /* bitpos */
909 complain_overflow_dont, /* complain_on_overflow */
910 bfd_elf_generic_reloc, /* special_function */
911 "R_PPC64_UADDR64", /* name */
912 FALSE, /* partial_inplace */
913 0, /* src_mask */
914 ONES (64), /* dst_mask */
915 FALSE), /* pcrel_offset */
916
917 /* 64-bit relative relocation. */
918 HOWTO (R_PPC64_REL64, /* type */
919 0, /* rightshift */
920 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
921 64, /* bitsize */
922 TRUE, /* pc_relative */
923 0, /* bitpos */
924 complain_overflow_dont, /* complain_on_overflow */
925 bfd_elf_generic_reloc, /* special_function */
926 "R_PPC64_REL64", /* name */
927 FALSE, /* partial_inplace */
928 0, /* src_mask */
929 ONES (64), /* dst_mask */
930 TRUE), /* pcrel_offset */
931
932 /* 64-bit relocation to the symbol's procedure linkage table. */
933 HOWTO (R_PPC64_PLT64, /* type */
934 0, /* rightshift */
935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
936 64, /* bitsize */
937 FALSE, /* pc_relative */
938 0, /* bitpos */
939 complain_overflow_dont, /* complain_on_overflow */
940 ppc64_elf_unhandled_reloc, /* special_function */
941 "R_PPC64_PLT64", /* name */
942 FALSE, /* partial_inplace */
943 0, /* src_mask */
944 ONES (64), /* dst_mask */
945 FALSE), /* pcrel_offset */
946
947 /* 64-bit PC relative relocation to the symbol's procedure linkage
948 table. */
949 /* FIXME: R_PPC64_PLTREL64 not supported. */
950 HOWTO (R_PPC64_PLTREL64, /* type */
951 0, /* rightshift */
952 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
953 64, /* bitsize */
954 TRUE, /* pc_relative */
955 0, /* bitpos */
956 complain_overflow_dont, /* complain_on_overflow */
957 ppc64_elf_unhandled_reloc, /* special_function */
958 "R_PPC64_PLTREL64", /* name */
959 FALSE, /* partial_inplace */
960 0, /* src_mask */
961 ONES (64), /* dst_mask */
962 TRUE), /* pcrel_offset */
963
964 /* 16 bit TOC-relative relocation. */
965
966 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
967 HOWTO (R_PPC64_TOC16, /* type */
968 0, /* rightshift */
969 1, /* size (0 = byte, 1 = short, 2 = long) */
970 16, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_signed, /* complain_on_overflow */
974 ppc64_elf_toc_reloc, /* special_function */
975 "R_PPC64_TOC16", /* name */
976 FALSE, /* partial_inplace */
977 0, /* src_mask */
978 0xffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980
981 /* 16 bit TOC-relative relocation without overflow. */
982
983 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
984 HOWTO (R_PPC64_TOC16_LO, /* type */
985 0, /* rightshift */
986 1, /* size (0 = byte, 1 = short, 2 = long) */
987 16, /* bitsize */
988 FALSE, /* pc_relative */
989 0, /* bitpos */
990 complain_overflow_dont, /* complain_on_overflow */
991 ppc64_elf_toc_reloc, /* special_function */
992 "R_PPC64_TOC16_LO", /* name */
993 FALSE, /* partial_inplace */
994 0, /* src_mask */
995 0xffff, /* dst_mask */
996 FALSE), /* pcrel_offset */
997
998 /* 16 bit TOC-relative relocation, high 16 bits. */
999
1000 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1001 HOWTO (R_PPC64_TOC16_HI, /* type */
1002 16, /* rightshift */
1003 1, /* size (0 = byte, 1 = short, 2 = long) */
1004 16, /* bitsize */
1005 FALSE, /* pc_relative */
1006 0, /* bitpos */
1007 complain_overflow_signed, /* complain_on_overflow */
1008 ppc64_elf_toc_reloc, /* special_function */
1009 "R_PPC64_TOC16_HI", /* name */
1010 FALSE, /* partial_inplace */
1011 0, /* src_mask */
1012 0xffff, /* dst_mask */
1013 FALSE), /* pcrel_offset */
1014
1015 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1016 contents of the low 16 bits, treated as a signed number, is
1017 negative. */
1018
1019 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1020 HOWTO (R_PPC64_TOC16_HA, /* type */
1021 16, /* rightshift */
1022 1, /* size (0 = byte, 1 = short, 2 = long) */
1023 16, /* bitsize */
1024 FALSE, /* pc_relative */
1025 0, /* bitpos */
1026 complain_overflow_signed, /* complain_on_overflow */
1027 ppc64_elf_toc_ha_reloc, /* special_function */
1028 "R_PPC64_TOC16_HA", /* name */
1029 FALSE, /* partial_inplace */
1030 0, /* src_mask */
1031 0xffff, /* dst_mask */
1032 FALSE), /* pcrel_offset */
1033
1034 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1035
1036 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1037 HOWTO (R_PPC64_TOC, /* type */
1038 0, /* rightshift */
1039 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1040 64, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_dont, /* complain_on_overflow */
1044 ppc64_elf_toc64_reloc, /* special_function */
1045 "R_PPC64_TOC", /* name */
1046 FALSE, /* partial_inplace */
1047 0, /* src_mask */
1048 ONES (64), /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Like R_PPC64_GOT16, but also informs the link editor that the
1052 value to relocate may (!) refer to a PLT entry which the link
1053 editor (a) may replace with the symbol value. If the link editor
1054 is unable to fully resolve the symbol, it may (b) create a PLT
1055 entry and store the address to the new PLT entry in the GOT.
1056 This permits lazy resolution of function symbols at run time.
1057 The link editor may also skip all of this and just (c) emit a
1058 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1059 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1060 HOWTO (R_PPC64_PLTGOT16, /* type */
1061 0, /* rightshift */
1062 1, /* size (0 = byte, 1 = short, 2 = long) */
1063 16, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_signed, /* complain_on_overflow */
1067 ppc64_elf_unhandled_reloc, /* special_function */
1068 "R_PPC64_PLTGOT16", /* name */
1069 FALSE, /* partial_inplace */
1070 0, /* src_mask */
1071 0xffff, /* dst_mask */
1072 FALSE), /* pcrel_offset */
1073
1074 /* Like R_PPC64_PLTGOT16, but without overflow. */
1075 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1076 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1077 0, /* rightshift */
1078 1, /* size (0 = byte, 1 = short, 2 = long) */
1079 16, /* bitsize */
1080 FALSE, /* pc_relative */
1081 0, /* bitpos */
1082 complain_overflow_dont, /* complain_on_overflow */
1083 ppc64_elf_unhandled_reloc, /* special_function */
1084 "R_PPC64_PLTGOT16_LO", /* name */
1085 FALSE, /* partial_inplace */
1086 0, /* src_mask */
1087 0xffff, /* dst_mask */
1088 FALSE), /* pcrel_offset */
1089
1090 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1091 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1092 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1093 16, /* rightshift */
1094 1, /* size (0 = byte, 1 = short, 2 = long) */
1095 16, /* bitsize */
1096 FALSE, /* pc_relative */
1097 0, /* bitpos */
1098 complain_overflow_signed, /* complain_on_overflow */
1099 ppc64_elf_unhandled_reloc, /* special_function */
1100 "R_PPC64_PLTGOT16_HI", /* name */
1101 FALSE, /* partial_inplace */
1102 0, /* src_mask */
1103 0xffff, /* dst_mask */
1104 FALSE), /* pcrel_offset */
1105
1106 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1107 1 if the contents of the low 16 bits, treated as a signed number,
1108 is negative. */
1109 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1110 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1111 16, /* rightshift */
1112 1, /* size (0 = byte, 1 = short, 2 = long) */
1113 16, /* bitsize */
1114 FALSE, /* pc_relative */
1115 0, /* bitpos */
1116 complain_overflow_signed, /* complain_on_overflow */
1117 ppc64_elf_unhandled_reloc, /* special_function */
1118 "R_PPC64_PLTGOT16_HA", /* name */
1119 FALSE, /* partial_inplace */
1120 0, /* src_mask */
1121 0xffff, /* dst_mask */
1122 FALSE), /* pcrel_offset */
1123
1124 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1125 HOWTO (R_PPC64_ADDR16_DS, /* type */
1126 0, /* rightshift */
1127 1, /* size (0 = byte, 1 = short, 2 = long) */
1128 16, /* bitsize */
1129 FALSE, /* pc_relative */
1130 0, /* bitpos */
1131 complain_overflow_signed, /* complain_on_overflow */
1132 bfd_elf_generic_reloc, /* special_function */
1133 "R_PPC64_ADDR16_DS", /* name */
1134 FALSE, /* partial_inplace */
1135 0, /* src_mask */
1136 0xfffc, /* dst_mask */
1137 FALSE), /* pcrel_offset */
1138
1139 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1140 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1141 0, /* rightshift */
1142 1, /* size (0 = byte, 1 = short, 2 = long) */
1143 16, /* bitsize */
1144 FALSE, /* pc_relative */
1145 0, /* bitpos */
1146 complain_overflow_dont,/* complain_on_overflow */
1147 bfd_elf_generic_reloc, /* special_function */
1148 "R_PPC64_ADDR16_LO_DS",/* name */
1149 FALSE, /* partial_inplace */
1150 0, /* src_mask */
1151 0xfffc, /* dst_mask */
1152 FALSE), /* pcrel_offset */
1153
1154 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1155 HOWTO (R_PPC64_GOT16_DS, /* type */
1156 0, /* rightshift */
1157 1, /* size (0 = byte, 1 = short, 2 = long) */
1158 16, /* bitsize */
1159 FALSE, /* pc_relative */
1160 0, /* bitpos */
1161 complain_overflow_signed, /* complain_on_overflow */
1162 ppc64_elf_unhandled_reloc, /* special_function */
1163 "R_PPC64_GOT16_DS", /* name */
1164 FALSE, /* partial_inplace */
1165 0, /* src_mask */
1166 0xfffc, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1168
1169 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1170 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1171 0, /* rightshift */
1172 1, /* size (0 = byte, 1 = short, 2 = long) */
1173 16, /* bitsize */
1174 FALSE, /* pc_relative */
1175 0, /* bitpos */
1176 complain_overflow_dont, /* complain_on_overflow */
1177 ppc64_elf_unhandled_reloc, /* special_function */
1178 "R_PPC64_GOT16_LO_DS", /* name */
1179 FALSE, /* partial_inplace */
1180 0, /* src_mask */
1181 0xfffc, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1183
1184 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1185 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1186 0, /* rightshift */
1187 1, /* size (0 = byte, 1 = short, 2 = long) */
1188 16, /* bitsize */
1189 FALSE, /* pc_relative */
1190 0, /* bitpos */
1191 complain_overflow_dont, /* complain_on_overflow */
1192 ppc64_elf_unhandled_reloc, /* special_function */
1193 "R_PPC64_PLT16_LO_DS", /* name */
1194 FALSE, /* partial_inplace */
1195 0, /* src_mask */
1196 0xfffc, /* dst_mask */
1197 FALSE), /* pcrel_offset */
1198
1199 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1200 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1201 0, /* rightshift */
1202 1, /* size (0 = byte, 1 = short, 2 = long) */
1203 16, /* bitsize */
1204 FALSE, /* pc_relative */
1205 0, /* bitpos */
1206 complain_overflow_signed, /* complain_on_overflow */
1207 ppc64_elf_sectoff_reloc, /* special_function */
1208 "R_PPC64_SECTOFF_DS", /* name */
1209 FALSE, /* partial_inplace */
1210 0, /* src_mask */
1211 0xfffc, /* dst_mask */
1212 FALSE), /* pcrel_offset */
1213
1214 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1215 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1216 0, /* rightshift */
1217 1, /* size (0 = byte, 1 = short, 2 = long) */
1218 16, /* bitsize */
1219 FALSE, /* pc_relative */
1220 0, /* bitpos */
1221 complain_overflow_dont, /* complain_on_overflow */
1222 ppc64_elf_sectoff_reloc, /* special_function */
1223 "R_PPC64_SECTOFF_LO_DS",/* name */
1224 FALSE, /* partial_inplace */
1225 0, /* src_mask */
1226 0xfffc, /* dst_mask */
1227 FALSE), /* pcrel_offset */
1228
1229 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1230 HOWTO (R_PPC64_TOC16_DS, /* type */
1231 0, /* rightshift */
1232 1, /* size (0 = byte, 1 = short, 2 = long) */
1233 16, /* bitsize */
1234 FALSE, /* pc_relative */
1235 0, /* bitpos */
1236 complain_overflow_signed, /* complain_on_overflow */
1237 ppc64_elf_toc_reloc, /* special_function */
1238 "R_PPC64_TOC16_DS", /* name */
1239 FALSE, /* partial_inplace */
1240 0, /* src_mask */
1241 0xfffc, /* dst_mask */
1242 FALSE), /* pcrel_offset */
1243
1244 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1245 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1246 0, /* rightshift */
1247 1, /* size (0 = byte, 1 = short, 2 = long) */
1248 16, /* bitsize */
1249 FALSE, /* pc_relative */
1250 0, /* bitpos */
1251 complain_overflow_dont, /* complain_on_overflow */
1252 ppc64_elf_toc_reloc, /* special_function */
1253 "R_PPC64_TOC16_LO_DS", /* name */
1254 FALSE, /* partial_inplace */
1255 0, /* src_mask */
1256 0xfffc, /* dst_mask */
1257 FALSE), /* pcrel_offset */
1258
1259 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1260 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1261 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1262 0, /* rightshift */
1263 1, /* size (0 = byte, 1 = short, 2 = long) */
1264 16, /* bitsize */
1265 FALSE, /* pc_relative */
1266 0, /* bitpos */
1267 complain_overflow_signed, /* complain_on_overflow */
1268 ppc64_elf_unhandled_reloc, /* special_function */
1269 "R_PPC64_PLTGOT16_DS", /* name */
1270 FALSE, /* partial_inplace */
1271 0, /* src_mask */
1272 0xfffc, /* dst_mask */
1273 FALSE), /* pcrel_offset */
1274
1275 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1276 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1277 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1278 0, /* rightshift */
1279 1, /* size (0 = byte, 1 = short, 2 = long) */
1280 16, /* bitsize */
1281 FALSE, /* pc_relative */
1282 0, /* bitpos */
1283 complain_overflow_dont, /* complain_on_overflow */
1284 ppc64_elf_unhandled_reloc, /* special_function */
1285 "R_PPC64_PLTGOT16_LO_DS",/* name */
1286 FALSE, /* partial_inplace */
1287 0, /* src_mask */
1288 0xfffc, /* dst_mask */
1289 FALSE), /* pcrel_offset */
1290
1291 /* Marker relocs for TLS. */
1292 HOWTO (R_PPC64_TLS,
1293 0, /* rightshift */
1294 2, /* size (0 = byte, 1 = short, 2 = long) */
1295 32, /* bitsize */
1296 FALSE, /* pc_relative */
1297 0, /* bitpos */
1298 complain_overflow_dont, /* complain_on_overflow */
1299 bfd_elf_generic_reloc, /* special_function */
1300 "R_PPC64_TLS", /* name */
1301 FALSE, /* partial_inplace */
1302 0, /* src_mask */
1303 0, /* dst_mask */
1304 FALSE), /* pcrel_offset */
1305
1306 HOWTO (R_PPC64_TLSGD,
1307 0, /* rightshift */
1308 2, /* size (0 = byte, 1 = short, 2 = long) */
1309 32, /* bitsize */
1310 FALSE, /* pc_relative */
1311 0, /* bitpos */
1312 complain_overflow_dont, /* complain_on_overflow */
1313 bfd_elf_generic_reloc, /* special_function */
1314 "R_PPC64_TLSGD", /* name */
1315 FALSE, /* partial_inplace */
1316 0, /* src_mask */
1317 0, /* dst_mask */
1318 FALSE), /* pcrel_offset */
1319
1320 HOWTO (R_PPC64_TLSLD,
1321 0, /* rightshift */
1322 2, /* size (0 = byte, 1 = short, 2 = long) */
1323 32, /* bitsize */
1324 FALSE, /* pc_relative */
1325 0, /* bitpos */
1326 complain_overflow_dont, /* complain_on_overflow */
1327 bfd_elf_generic_reloc, /* special_function */
1328 "R_PPC64_TLSLD", /* name */
1329 FALSE, /* partial_inplace */
1330 0, /* src_mask */
1331 0, /* dst_mask */
1332 FALSE), /* pcrel_offset */
1333
1334 HOWTO (R_PPC64_TOCSAVE,
1335 0, /* rightshift */
1336 2, /* size (0 = byte, 1 = short, 2 = long) */
1337 32, /* bitsize */
1338 FALSE, /* pc_relative */
1339 0, /* bitpos */
1340 complain_overflow_dont, /* complain_on_overflow */
1341 bfd_elf_generic_reloc, /* special_function */
1342 "R_PPC64_TOCSAVE", /* name */
1343 FALSE, /* partial_inplace */
1344 0, /* src_mask */
1345 0, /* dst_mask */
1346 FALSE), /* pcrel_offset */
1347
1348 /* Computes the load module index of the load module that contains the
1349 definition of its TLS sym. */
1350 HOWTO (R_PPC64_DTPMOD64,
1351 0, /* rightshift */
1352 4, /* size (0 = byte, 1 = short, 2 = long) */
1353 64, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 ppc64_elf_unhandled_reloc, /* special_function */
1358 "R_PPC64_DTPMOD64", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 ONES (64), /* dst_mask */
1362 FALSE), /* pcrel_offset */
1363
1364 /* Computes a dtv-relative displacement, the difference between the value
1365 of sym+add and the base address of the thread-local storage block that
1366 contains the definition of sym, minus 0x8000. */
1367 HOWTO (R_PPC64_DTPREL64,
1368 0, /* rightshift */
1369 4, /* size (0 = byte, 1 = short, 2 = long) */
1370 64, /* bitsize */
1371 FALSE, /* pc_relative */
1372 0, /* bitpos */
1373 complain_overflow_dont, /* complain_on_overflow */
1374 ppc64_elf_unhandled_reloc, /* special_function */
1375 "R_PPC64_DTPREL64", /* name */
1376 FALSE, /* partial_inplace */
1377 0, /* src_mask */
1378 ONES (64), /* dst_mask */
1379 FALSE), /* pcrel_offset */
1380
1381 /* A 16 bit dtprel reloc. */
1382 HOWTO (R_PPC64_DTPREL16,
1383 0, /* rightshift */
1384 1, /* size (0 = byte, 1 = short, 2 = long) */
1385 16, /* bitsize */
1386 FALSE, /* pc_relative */
1387 0, /* bitpos */
1388 complain_overflow_signed, /* complain_on_overflow */
1389 ppc64_elf_unhandled_reloc, /* special_function */
1390 "R_PPC64_DTPREL16", /* name */
1391 FALSE, /* partial_inplace */
1392 0, /* src_mask */
1393 0xffff, /* dst_mask */
1394 FALSE), /* pcrel_offset */
1395
1396 /* Like DTPREL16, but no overflow. */
1397 HOWTO (R_PPC64_DTPREL16_LO,
1398 0, /* rightshift */
1399 1, /* size (0 = byte, 1 = short, 2 = long) */
1400 16, /* bitsize */
1401 FALSE, /* pc_relative */
1402 0, /* bitpos */
1403 complain_overflow_dont, /* complain_on_overflow */
1404 ppc64_elf_unhandled_reloc, /* special_function */
1405 "R_PPC64_DTPREL16_LO", /* name */
1406 FALSE, /* partial_inplace */
1407 0, /* src_mask */
1408 0xffff, /* dst_mask */
1409 FALSE), /* pcrel_offset */
1410
1411 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1412 HOWTO (R_PPC64_DTPREL16_HI,
1413 16, /* rightshift */
1414 1, /* size (0 = byte, 1 = short, 2 = long) */
1415 16, /* bitsize */
1416 FALSE, /* pc_relative */
1417 0, /* bitpos */
1418 complain_overflow_signed, /* complain_on_overflow */
1419 ppc64_elf_unhandled_reloc, /* special_function */
1420 "R_PPC64_DTPREL16_HI", /* name */
1421 FALSE, /* partial_inplace */
1422 0, /* src_mask */
1423 0xffff, /* dst_mask */
1424 FALSE), /* pcrel_offset */
1425
1426 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1427 HOWTO (R_PPC64_DTPREL16_HA,
1428 16, /* rightshift */
1429 1, /* size (0 = byte, 1 = short, 2 = long) */
1430 16, /* bitsize */
1431 FALSE, /* pc_relative */
1432 0, /* bitpos */
1433 complain_overflow_signed, /* complain_on_overflow */
1434 ppc64_elf_unhandled_reloc, /* special_function */
1435 "R_PPC64_DTPREL16_HA", /* name */
1436 FALSE, /* partial_inplace */
1437 0, /* src_mask */
1438 0xffff, /* dst_mask */
1439 FALSE), /* pcrel_offset */
1440
1441 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1442 HOWTO (R_PPC64_DTPREL16_HIGHER,
1443 32, /* rightshift */
1444 1, /* size (0 = byte, 1 = short, 2 = long) */
1445 16, /* bitsize */
1446 FALSE, /* pc_relative */
1447 0, /* bitpos */
1448 complain_overflow_dont, /* complain_on_overflow */
1449 ppc64_elf_unhandled_reloc, /* special_function */
1450 "R_PPC64_DTPREL16_HIGHER", /* name */
1451 FALSE, /* partial_inplace */
1452 0, /* src_mask */
1453 0xffff, /* dst_mask */
1454 FALSE), /* pcrel_offset */
1455
1456 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1457 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1458 32, /* rightshift */
1459 1, /* size (0 = byte, 1 = short, 2 = long) */
1460 16, /* bitsize */
1461 FALSE, /* pc_relative */
1462 0, /* bitpos */
1463 complain_overflow_dont, /* complain_on_overflow */
1464 ppc64_elf_unhandled_reloc, /* special_function */
1465 "R_PPC64_DTPREL16_HIGHERA", /* name */
1466 FALSE, /* partial_inplace */
1467 0, /* src_mask */
1468 0xffff, /* dst_mask */
1469 FALSE), /* pcrel_offset */
1470
1471 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1472 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1473 48, /* rightshift */
1474 1, /* size (0 = byte, 1 = short, 2 = long) */
1475 16, /* bitsize */
1476 FALSE, /* pc_relative */
1477 0, /* bitpos */
1478 complain_overflow_dont, /* complain_on_overflow */
1479 ppc64_elf_unhandled_reloc, /* special_function */
1480 "R_PPC64_DTPREL16_HIGHEST", /* name */
1481 FALSE, /* partial_inplace */
1482 0, /* src_mask */
1483 0xffff, /* dst_mask */
1484 FALSE), /* pcrel_offset */
1485
1486 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1487 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1488 48, /* rightshift */
1489 1, /* size (0 = byte, 1 = short, 2 = long) */
1490 16, /* bitsize */
1491 FALSE, /* pc_relative */
1492 0, /* bitpos */
1493 complain_overflow_dont, /* complain_on_overflow */
1494 ppc64_elf_unhandled_reloc, /* special_function */
1495 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1496 FALSE, /* partial_inplace */
1497 0, /* src_mask */
1498 0xffff, /* dst_mask */
1499 FALSE), /* pcrel_offset */
1500
1501 /* Like DTPREL16, but for insns with a DS field. */
1502 HOWTO (R_PPC64_DTPREL16_DS,
1503 0, /* rightshift */
1504 1, /* size (0 = byte, 1 = short, 2 = long) */
1505 16, /* bitsize */
1506 FALSE, /* pc_relative */
1507 0, /* bitpos */
1508 complain_overflow_signed, /* complain_on_overflow */
1509 ppc64_elf_unhandled_reloc, /* special_function */
1510 "R_PPC64_DTPREL16_DS", /* name */
1511 FALSE, /* partial_inplace */
1512 0, /* src_mask */
1513 0xfffc, /* dst_mask */
1514 FALSE), /* pcrel_offset */
1515
1516 /* Like DTPREL16_DS, but no overflow. */
1517 HOWTO (R_PPC64_DTPREL16_LO_DS,
1518 0, /* rightshift */
1519 1, /* size (0 = byte, 1 = short, 2 = long) */
1520 16, /* bitsize */
1521 FALSE, /* pc_relative */
1522 0, /* bitpos */
1523 complain_overflow_dont, /* complain_on_overflow */
1524 ppc64_elf_unhandled_reloc, /* special_function */
1525 "R_PPC64_DTPREL16_LO_DS", /* name */
1526 FALSE, /* partial_inplace */
1527 0, /* src_mask */
1528 0xfffc, /* dst_mask */
1529 FALSE), /* pcrel_offset */
1530
1531 /* Computes a tp-relative displacement, the difference between the value of
1532 sym+add and the value of the thread pointer (r13). */
1533 HOWTO (R_PPC64_TPREL64,
1534 0, /* rightshift */
1535 4, /* size (0 = byte, 1 = short, 2 = long) */
1536 64, /* bitsize */
1537 FALSE, /* pc_relative */
1538 0, /* bitpos */
1539 complain_overflow_dont, /* complain_on_overflow */
1540 ppc64_elf_unhandled_reloc, /* special_function */
1541 "R_PPC64_TPREL64", /* name */
1542 FALSE, /* partial_inplace */
1543 0, /* src_mask */
1544 ONES (64), /* dst_mask */
1545 FALSE), /* pcrel_offset */
1546
1547 /* A 16 bit tprel reloc. */
1548 HOWTO (R_PPC64_TPREL16,
1549 0, /* rightshift */
1550 1, /* size (0 = byte, 1 = short, 2 = long) */
1551 16, /* bitsize */
1552 FALSE, /* pc_relative */
1553 0, /* bitpos */
1554 complain_overflow_signed, /* complain_on_overflow */
1555 ppc64_elf_unhandled_reloc, /* special_function */
1556 "R_PPC64_TPREL16", /* name */
1557 FALSE, /* partial_inplace */
1558 0, /* src_mask */
1559 0xffff, /* dst_mask */
1560 FALSE), /* pcrel_offset */
1561
1562 /* Like TPREL16, but no overflow. */
1563 HOWTO (R_PPC64_TPREL16_LO,
1564 0, /* rightshift */
1565 1, /* size (0 = byte, 1 = short, 2 = long) */
1566 16, /* bitsize */
1567 FALSE, /* pc_relative */
1568 0, /* bitpos */
1569 complain_overflow_dont, /* complain_on_overflow */
1570 ppc64_elf_unhandled_reloc, /* special_function */
1571 "R_PPC64_TPREL16_LO", /* name */
1572 FALSE, /* partial_inplace */
1573 0, /* src_mask */
1574 0xffff, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1576
1577 /* Like TPREL16_LO, but next higher group of 16 bits. */
1578 HOWTO (R_PPC64_TPREL16_HI,
1579 16, /* rightshift */
1580 1, /* size (0 = byte, 1 = short, 2 = long) */
1581 16, /* bitsize */
1582 FALSE, /* pc_relative */
1583 0, /* bitpos */
1584 complain_overflow_signed, /* complain_on_overflow */
1585 ppc64_elf_unhandled_reloc, /* special_function */
1586 "R_PPC64_TPREL16_HI", /* name */
1587 FALSE, /* partial_inplace */
1588 0, /* src_mask */
1589 0xffff, /* dst_mask */
1590 FALSE), /* pcrel_offset */
1591
1592 /* Like TPREL16_HI, but adjust for low 16 bits. */
1593 HOWTO (R_PPC64_TPREL16_HA,
1594 16, /* rightshift */
1595 1, /* size (0 = byte, 1 = short, 2 = long) */
1596 16, /* bitsize */
1597 FALSE, /* pc_relative */
1598 0, /* bitpos */
1599 complain_overflow_signed, /* complain_on_overflow */
1600 ppc64_elf_unhandled_reloc, /* special_function */
1601 "R_PPC64_TPREL16_HA", /* name */
1602 FALSE, /* partial_inplace */
1603 0, /* src_mask */
1604 0xffff, /* dst_mask */
1605 FALSE), /* pcrel_offset */
1606
1607 /* Like TPREL16_HI, but next higher group of 16 bits. */
1608 HOWTO (R_PPC64_TPREL16_HIGHER,
1609 32, /* rightshift */
1610 1, /* size (0 = byte, 1 = short, 2 = long) */
1611 16, /* bitsize */
1612 FALSE, /* pc_relative */
1613 0, /* bitpos */
1614 complain_overflow_dont, /* complain_on_overflow */
1615 ppc64_elf_unhandled_reloc, /* special_function */
1616 "R_PPC64_TPREL16_HIGHER", /* name */
1617 FALSE, /* partial_inplace */
1618 0, /* src_mask */
1619 0xffff, /* dst_mask */
1620 FALSE), /* pcrel_offset */
1621
1622 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1623 HOWTO (R_PPC64_TPREL16_HIGHERA,
1624 32, /* rightshift */
1625 1, /* size (0 = byte, 1 = short, 2 = long) */
1626 16, /* bitsize */
1627 FALSE, /* pc_relative */
1628 0, /* bitpos */
1629 complain_overflow_dont, /* complain_on_overflow */
1630 ppc64_elf_unhandled_reloc, /* special_function */
1631 "R_PPC64_TPREL16_HIGHERA", /* name */
1632 FALSE, /* partial_inplace */
1633 0, /* src_mask */
1634 0xffff, /* dst_mask */
1635 FALSE), /* pcrel_offset */
1636
1637 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1638 HOWTO (R_PPC64_TPREL16_HIGHEST,
1639 48, /* rightshift */
1640 1, /* size (0 = byte, 1 = short, 2 = long) */
1641 16, /* bitsize */
1642 FALSE, /* pc_relative */
1643 0, /* bitpos */
1644 complain_overflow_dont, /* complain_on_overflow */
1645 ppc64_elf_unhandled_reloc, /* special_function */
1646 "R_PPC64_TPREL16_HIGHEST", /* name */
1647 FALSE, /* partial_inplace */
1648 0, /* src_mask */
1649 0xffff, /* dst_mask */
1650 FALSE), /* pcrel_offset */
1651
1652 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1653 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1654 48, /* rightshift */
1655 1, /* size (0 = byte, 1 = short, 2 = long) */
1656 16, /* bitsize */
1657 FALSE, /* pc_relative */
1658 0, /* bitpos */
1659 complain_overflow_dont, /* complain_on_overflow */
1660 ppc64_elf_unhandled_reloc, /* special_function */
1661 "R_PPC64_TPREL16_HIGHESTA", /* name */
1662 FALSE, /* partial_inplace */
1663 0, /* src_mask */
1664 0xffff, /* dst_mask */
1665 FALSE), /* pcrel_offset */
1666
1667 /* Like TPREL16, but for insns with a DS field. */
1668 HOWTO (R_PPC64_TPREL16_DS,
1669 0, /* rightshift */
1670 1, /* size (0 = byte, 1 = short, 2 = long) */
1671 16, /* bitsize */
1672 FALSE, /* pc_relative */
1673 0, /* bitpos */
1674 complain_overflow_signed, /* complain_on_overflow */
1675 ppc64_elf_unhandled_reloc, /* special_function */
1676 "R_PPC64_TPREL16_DS", /* name */
1677 FALSE, /* partial_inplace */
1678 0, /* src_mask */
1679 0xfffc, /* dst_mask */
1680 FALSE), /* pcrel_offset */
1681
1682 /* Like TPREL16_DS, but no overflow. */
1683 HOWTO (R_PPC64_TPREL16_LO_DS,
1684 0, /* rightshift */
1685 1, /* size (0 = byte, 1 = short, 2 = long) */
1686 16, /* bitsize */
1687 FALSE, /* pc_relative */
1688 0, /* bitpos */
1689 complain_overflow_dont, /* complain_on_overflow */
1690 ppc64_elf_unhandled_reloc, /* special_function */
1691 "R_PPC64_TPREL16_LO_DS", /* name */
1692 FALSE, /* partial_inplace */
1693 0, /* src_mask */
1694 0xfffc, /* dst_mask */
1695 FALSE), /* pcrel_offset */
1696
1697 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1698 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1699 to the first entry relative to the TOC base (r2). */
1700 HOWTO (R_PPC64_GOT_TLSGD16,
1701 0, /* rightshift */
1702 1, /* size (0 = byte, 1 = short, 2 = long) */
1703 16, /* bitsize */
1704 FALSE, /* pc_relative */
1705 0, /* bitpos */
1706 complain_overflow_signed, /* complain_on_overflow */
1707 ppc64_elf_unhandled_reloc, /* special_function */
1708 "R_PPC64_GOT_TLSGD16", /* name */
1709 FALSE, /* partial_inplace */
1710 0, /* src_mask */
1711 0xffff, /* dst_mask */
1712 FALSE), /* pcrel_offset */
1713
1714 /* Like GOT_TLSGD16, but no overflow. */
1715 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1716 0, /* rightshift */
1717 1, /* size (0 = byte, 1 = short, 2 = long) */
1718 16, /* bitsize */
1719 FALSE, /* pc_relative */
1720 0, /* bitpos */
1721 complain_overflow_dont, /* complain_on_overflow */
1722 ppc64_elf_unhandled_reloc, /* special_function */
1723 "R_PPC64_GOT_TLSGD16_LO", /* name */
1724 FALSE, /* partial_inplace */
1725 0, /* src_mask */
1726 0xffff, /* dst_mask */
1727 FALSE), /* pcrel_offset */
1728
1729 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1730 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1731 16, /* rightshift */
1732 1, /* size (0 = byte, 1 = short, 2 = long) */
1733 16, /* bitsize */
1734 FALSE, /* pc_relative */
1735 0, /* bitpos */
1736 complain_overflow_signed, /* complain_on_overflow */
1737 ppc64_elf_unhandled_reloc, /* special_function */
1738 "R_PPC64_GOT_TLSGD16_HI", /* name */
1739 FALSE, /* partial_inplace */
1740 0, /* src_mask */
1741 0xffff, /* dst_mask */
1742 FALSE), /* pcrel_offset */
1743
1744 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1745 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1746 16, /* rightshift */
1747 1, /* size (0 = byte, 1 = short, 2 = long) */
1748 16, /* bitsize */
1749 FALSE, /* pc_relative */
1750 0, /* bitpos */
1751 complain_overflow_signed, /* complain_on_overflow */
1752 ppc64_elf_unhandled_reloc, /* special_function */
1753 "R_PPC64_GOT_TLSGD16_HA", /* name */
1754 FALSE, /* partial_inplace */
1755 0, /* src_mask */
1756 0xffff, /* dst_mask */
1757 FALSE), /* pcrel_offset */
1758
1759 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1760 with values (sym+add)@dtpmod and zero, and computes the offset to the
1761 first entry relative to the TOC base (r2). */
1762 HOWTO (R_PPC64_GOT_TLSLD16,
1763 0, /* rightshift */
1764 1, /* size (0 = byte, 1 = short, 2 = long) */
1765 16, /* bitsize */
1766 FALSE, /* pc_relative */
1767 0, /* bitpos */
1768 complain_overflow_signed, /* complain_on_overflow */
1769 ppc64_elf_unhandled_reloc, /* special_function */
1770 "R_PPC64_GOT_TLSLD16", /* name */
1771 FALSE, /* partial_inplace */
1772 0, /* src_mask */
1773 0xffff, /* dst_mask */
1774 FALSE), /* pcrel_offset */
1775
1776 /* Like GOT_TLSLD16, but no overflow. */
1777 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1778 0, /* rightshift */
1779 1, /* size (0 = byte, 1 = short, 2 = long) */
1780 16, /* bitsize */
1781 FALSE, /* pc_relative */
1782 0, /* bitpos */
1783 complain_overflow_dont, /* complain_on_overflow */
1784 ppc64_elf_unhandled_reloc, /* special_function */
1785 "R_PPC64_GOT_TLSLD16_LO", /* name */
1786 FALSE, /* partial_inplace */
1787 0, /* src_mask */
1788 0xffff, /* dst_mask */
1789 FALSE), /* pcrel_offset */
1790
1791 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1792 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1793 16, /* rightshift */
1794 1, /* size (0 = byte, 1 = short, 2 = long) */
1795 16, /* bitsize */
1796 FALSE, /* pc_relative */
1797 0, /* bitpos */
1798 complain_overflow_signed, /* complain_on_overflow */
1799 ppc64_elf_unhandled_reloc, /* special_function */
1800 "R_PPC64_GOT_TLSLD16_HI", /* name */
1801 FALSE, /* partial_inplace */
1802 0, /* src_mask */
1803 0xffff, /* dst_mask */
1804 FALSE), /* pcrel_offset */
1805
1806 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1807 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1808 16, /* rightshift */
1809 1, /* size (0 = byte, 1 = short, 2 = long) */
1810 16, /* bitsize */
1811 FALSE, /* pc_relative */
1812 0, /* bitpos */
1813 complain_overflow_signed, /* complain_on_overflow */
1814 ppc64_elf_unhandled_reloc, /* special_function */
1815 "R_PPC64_GOT_TLSLD16_HA", /* name */
1816 FALSE, /* partial_inplace */
1817 0, /* src_mask */
1818 0xffff, /* dst_mask */
1819 FALSE), /* pcrel_offset */
1820
1821 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1822 the offset to the entry relative to the TOC base (r2). */
1823 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1824 0, /* rightshift */
1825 1, /* size (0 = byte, 1 = short, 2 = long) */
1826 16, /* bitsize */
1827 FALSE, /* pc_relative */
1828 0, /* bitpos */
1829 complain_overflow_signed, /* complain_on_overflow */
1830 ppc64_elf_unhandled_reloc, /* special_function */
1831 "R_PPC64_GOT_DTPREL16_DS", /* name */
1832 FALSE, /* partial_inplace */
1833 0, /* src_mask */
1834 0xfffc, /* dst_mask */
1835 FALSE), /* pcrel_offset */
1836
1837 /* Like GOT_DTPREL16_DS, but no overflow. */
1838 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1839 0, /* rightshift */
1840 1, /* size (0 = byte, 1 = short, 2 = long) */
1841 16, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_dont, /* complain_on_overflow */
1845 ppc64_elf_unhandled_reloc, /* special_function */
1846 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1847 FALSE, /* partial_inplace */
1848 0, /* src_mask */
1849 0xfffc, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1853 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1854 16, /* rightshift */
1855 1, /* size (0 = byte, 1 = short, 2 = long) */
1856 16, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_signed, /* complain_on_overflow */
1860 ppc64_elf_unhandled_reloc, /* special_function */
1861 "R_PPC64_GOT_DTPREL16_HI", /* name */
1862 FALSE, /* partial_inplace */
1863 0, /* src_mask */
1864 0xffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1868 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1869 16, /* rightshift */
1870 1, /* size (0 = byte, 1 = short, 2 = long) */
1871 16, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 ppc64_elf_unhandled_reloc, /* special_function */
1876 "R_PPC64_GOT_DTPREL16_HA", /* name */
1877 FALSE, /* partial_inplace */
1878 0, /* src_mask */
1879 0xffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1883 offset to the entry relative to the TOC base (r2). */
1884 HOWTO (R_PPC64_GOT_TPREL16_DS,
1885 0, /* rightshift */
1886 1, /* size (0 = byte, 1 = short, 2 = long) */
1887 16, /* bitsize */
1888 FALSE, /* pc_relative */
1889 0, /* bitpos */
1890 complain_overflow_signed, /* complain_on_overflow */
1891 ppc64_elf_unhandled_reloc, /* special_function */
1892 "R_PPC64_GOT_TPREL16_DS", /* name */
1893 FALSE, /* partial_inplace */
1894 0, /* src_mask */
1895 0xfffc, /* dst_mask */
1896 FALSE), /* pcrel_offset */
1897
1898 /* Like GOT_TPREL16_DS, but no overflow. */
1899 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1900 0, /* rightshift */
1901 1, /* size (0 = byte, 1 = short, 2 = long) */
1902 16, /* bitsize */
1903 FALSE, /* pc_relative */
1904 0, /* bitpos */
1905 complain_overflow_dont, /* complain_on_overflow */
1906 ppc64_elf_unhandled_reloc, /* special_function */
1907 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1908 FALSE, /* partial_inplace */
1909 0, /* src_mask */
1910 0xfffc, /* dst_mask */
1911 FALSE), /* pcrel_offset */
1912
1913 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1914 HOWTO (R_PPC64_GOT_TPREL16_HI,
1915 16, /* rightshift */
1916 1, /* size (0 = byte, 1 = short, 2 = long) */
1917 16, /* bitsize */
1918 FALSE, /* pc_relative */
1919 0, /* bitpos */
1920 complain_overflow_signed, /* complain_on_overflow */
1921 ppc64_elf_unhandled_reloc, /* special_function */
1922 "R_PPC64_GOT_TPREL16_HI", /* name */
1923 FALSE, /* partial_inplace */
1924 0, /* src_mask */
1925 0xffff, /* dst_mask */
1926 FALSE), /* pcrel_offset */
1927
1928 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1929 HOWTO (R_PPC64_GOT_TPREL16_HA,
1930 16, /* rightshift */
1931 1, /* size (0 = byte, 1 = short, 2 = long) */
1932 16, /* bitsize */
1933 FALSE, /* pc_relative */
1934 0, /* bitpos */
1935 complain_overflow_signed, /* complain_on_overflow */
1936 ppc64_elf_unhandled_reloc, /* special_function */
1937 "R_PPC64_GOT_TPREL16_HA", /* name */
1938 FALSE, /* partial_inplace */
1939 0, /* src_mask */
1940 0xffff, /* dst_mask */
1941 FALSE), /* pcrel_offset */
1942
1943 HOWTO (R_PPC64_JMP_IREL, /* type */
1944 0, /* rightshift */
1945 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1946 0, /* bitsize */
1947 FALSE, /* pc_relative */
1948 0, /* bitpos */
1949 complain_overflow_dont, /* complain_on_overflow */
1950 ppc64_elf_unhandled_reloc, /* special_function */
1951 "R_PPC64_JMP_IREL", /* name */
1952 FALSE, /* partial_inplace */
1953 0, /* src_mask */
1954 0, /* dst_mask */
1955 FALSE), /* pcrel_offset */
1956
1957 HOWTO (R_PPC64_IRELATIVE, /* type */
1958 0, /* rightshift */
1959 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1960 64, /* bitsize */
1961 FALSE, /* pc_relative */
1962 0, /* bitpos */
1963 complain_overflow_dont, /* complain_on_overflow */
1964 bfd_elf_generic_reloc, /* special_function */
1965 "R_PPC64_IRELATIVE", /* name */
1966 FALSE, /* partial_inplace */
1967 0, /* src_mask */
1968 ONES (64), /* dst_mask */
1969 FALSE), /* pcrel_offset */
1970
1971 /* A 16 bit relative relocation. */
1972 HOWTO (R_PPC64_REL16, /* type */
1973 0, /* rightshift */
1974 1, /* size (0 = byte, 1 = short, 2 = long) */
1975 16, /* bitsize */
1976 TRUE, /* pc_relative */
1977 0, /* bitpos */
1978 complain_overflow_signed, /* complain_on_overflow */
1979 bfd_elf_generic_reloc, /* special_function */
1980 "R_PPC64_REL16", /* name */
1981 FALSE, /* partial_inplace */
1982 0, /* src_mask */
1983 0xffff, /* dst_mask */
1984 TRUE), /* pcrel_offset */
1985
1986 /* A 16 bit relative relocation without overflow. */
1987 HOWTO (R_PPC64_REL16_LO, /* type */
1988 0, /* rightshift */
1989 1, /* size (0 = byte, 1 = short, 2 = long) */
1990 16, /* bitsize */
1991 TRUE, /* pc_relative */
1992 0, /* bitpos */
1993 complain_overflow_dont,/* complain_on_overflow */
1994 bfd_elf_generic_reloc, /* special_function */
1995 "R_PPC64_REL16_LO", /* name */
1996 FALSE, /* partial_inplace */
1997 0, /* src_mask */
1998 0xffff, /* dst_mask */
1999 TRUE), /* pcrel_offset */
2000
2001 /* The high order 16 bits of a relative address. */
2002 HOWTO (R_PPC64_REL16_HI, /* type */
2003 16, /* rightshift */
2004 1, /* size (0 = byte, 1 = short, 2 = long) */
2005 16, /* bitsize */
2006 TRUE, /* pc_relative */
2007 0, /* bitpos */
2008 complain_overflow_signed, /* complain_on_overflow */
2009 bfd_elf_generic_reloc, /* special_function */
2010 "R_PPC64_REL16_HI", /* name */
2011 FALSE, /* partial_inplace */
2012 0, /* src_mask */
2013 0xffff, /* dst_mask */
2014 TRUE), /* pcrel_offset */
2015
2016 /* The high order 16 bits of a relative address, plus 1 if the contents of
2017 the low 16 bits, treated as a signed number, is negative. */
2018 HOWTO (R_PPC64_REL16_HA, /* type */
2019 16, /* rightshift */
2020 1, /* size (0 = byte, 1 = short, 2 = long) */
2021 16, /* bitsize */
2022 TRUE, /* pc_relative */
2023 0, /* bitpos */
2024 complain_overflow_signed, /* complain_on_overflow */
2025 ppc64_elf_ha_reloc, /* special_function */
2026 "R_PPC64_REL16_HA", /* name */
2027 FALSE, /* partial_inplace */
2028 0, /* src_mask */
2029 0xffff, /* dst_mask */
2030 TRUE), /* pcrel_offset */
2031
2032 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2033 HOWTO (R_PPC64_REL16DX_HA, /* type */
2034 16, /* rightshift */
2035 2, /* size (0 = byte, 1 = short, 2 = long) */
2036 16, /* bitsize */
2037 TRUE, /* pc_relative */
2038 0, /* bitpos */
2039 complain_overflow_signed, /* complain_on_overflow */
2040 ppc64_elf_ha_reloc, /* special_function */
2041 "R_PPC64_REL16DX_HA", /* name */
2042 FALSE, /* partial_inplace */
2043 0, /* src_mask */
2044 0x1fffc1, /* dst_mask */
2045 TRUE), /* pcrel_offset */
2046
2047 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2048 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2049 16, /* rightshift */
2050 1, /* size (0 = byte, 1 = short, 2 = long) */
2051 16, /* bitsize */
2052 FALSE, /* pc_relative */
2053 0, /* bitpos */
2054 complain_overflow_dont, /* complain_on_overflow */
2055 bfd_elf_generic_reloc, /* special_function */
2056 "R_PPC64_ADDR16_HIGH", /* name */
2057 FALSE, /* partial_inplace */
2058 0, /* src_mask */
2059 0xffff, /* dst_mask */
2060 FALSE), /* pcrel_offset */
2061
2062 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2063 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2064 16, /* rightshift */
2065 1, /* size (0 = byte, 1 = short, 2 = long) */
2066 16, /* bitsize */
2067 FALSE, /* pc_relative */
2068 0, /* bitpos */
2069 complain_overflow_dont, /* complain_on_overflow */
2070 ppc64_elf_ha_reloc, /* special_function */
2071 "R_PPC64_ADDR16_HIGHA", /* name */
2072 FALSE, /* partial_inplace */
2073 0, /* src_mask */
2074 0xffff, /* dst_mask */
2075 FALSE), /* pcrel_offset */
2076
2077 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2078 HOWTO (R_PPC64_DTPREL16_HIGH,
2079 16, /* rightshift */
2080 1, /* size (0 = byte, 1 = short, 2 = long) */
2081 16, /* bitsize */
2082 FALSE, /* pc_relative */
2083 0, /* bitpos */
2084 complain_overflow_dont, /* complain_on_overflow */
2085 ppc64_elf_unhandled_reloc, /* special_function */
2086 "R_PPC64_DTPREL16_HIGH", /* name */
2087 FALSE, /* partial_inplace */
2088 0, /* src_mask */
2089 0xffff, /* dst_mask */
2090 FALSE), /* pcrel_offset */
2091
2092 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2093 HOWTO (R_PPC64_DTPREL16_HIGHA,
2094 16, /* rightshift */
2095 1, /* size (0 = byte, 1 = short, 2 = long) */
2096 16, /* bitsize */
2097 FALSE, /* pc_relative */
2098 0, /* bitpos */
2099 complain_overflow_dont, /* complain_on_overflow */
2100 ppc64_elf_unhandled_reloc, /* special_function */
2101 "R_PPC64_DTPREL16_HIGHA", /* name */
2102 FALSE, /* partial_inplace */
2103 0, /* src_mask */
2104 0xffff, /* dst_mask */
2105 FALSE), /* pcrel_offset */
2106
2107 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2108 HOWTO (R_PPC64_TPREL16_HIGH,
2109 16, /* rightshift */
2110 1, /* size (0 = byte, 1 = short, 2 = long) */
2111 16, /* bitsize */
2112 FALSE, /* pc_relative */
2113 0, /* bitpos */
2114 complain_overflow_dont, /* complain_on_overflow */
2115 ppc64_elf_unhandled_reloc, /* special_function */
2116 "R_PPC64_TPREL16_HIGH", /* name */
2117 FALSE, /* partial_inplace */
2118 0, /* src_mask */
2119 0xffff, /* dst_mask */
2120 FALSE), /* pcrel_offset */
2121
2122 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2123 HOWTO (R_PPC64_TPREL16_HIGHA,
2124 16, /* rightshift */
2125 1, /* size (0 = byte, 1 = short, 2 = long) */
2126 16, /* bitsize */
2127 FALSE, /* pc_relative */
2128 0, /* bitpos */
2129 complain_overflow_dont, /* complain_on_overflow */
2130 ppc64_elf_unhandled_reloc, /* special_function */
2131 "R_PPC64_TPREL16_HIGHA", /* name */
2132 FALSE, /* partial_inplace */
2133 0, /* src_mask */
2134 0xffff, /* dst_mask */
2135 FALSE), /* pcrel_offset */
2136
2137 /* Marker reloc on ELFv2 large-model function entry. */
2138 HOWTO (R_PPC64_ENTRY,
2139 0, /* rightshift */
2140 2, /* size (0 = byte, 1 = short, 2 = long) */
2141 32, /* bitsize */
2142 FALSE, /* pc_relative */
2143 0, /* bitpos */
2144 complain_overflow_dont, /* complain_on_overflow */
2145 bfd_elf_generic_reloc, /* special_function */
2146 "R_PPC64_ENTRY", /* name */
2147 FALSE, /* partial_inplace */
2148 0, /* src_mask */
2149 0, /* dst_mask */
2150 FALSE), /* pcrel_offset */
2151
2152 /* Like ADDR64, but use local entry point of function. */
2153 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2154 0, /* rightshift */
2155 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2156 64, /* bitsize */
2157 FALSE, /* pc_relative */
2158 0, /* bitpos */
2159 complain_overflow_dont, /* complain_on_overflow */
2160 bfd_elf_generic_reloc, /* special_function */
2161 "R_PPC64_ADDR64_LOCAL", /* name */
2162 FALSE, /* partial_inplace */
2163 0, /* src_mask */
2164 ONES (64), /* dst_mask */
2165 FALSE), /* pcrel_offset */
2166
2167 /* GNU extension to record C++ vtable hierarchy. */
2168 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2169 0, /* rightshift */
2170 0, /* size (0 = byte, 1 = short, 2 = long) */
2171 0, /* bitsize */
2172 FALSE, /* pc_relative */
2173 0, /* bitpos */
2174 complain_overflow_dont, /* complain_on_overflow */
2175 NULL, /* special_function */
2176 "R_PPC64_GNU_VTINHERIT", /* name */
2177 FALSE, /* partial_inplace */
2178 0, /* src_mask */
2179 0, /* dst_mask */
2180 FALSE), /* pcrel_offset */
2181
2182 /* GNU extension to record C++ vtable member usage. */
2183 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2184 0, /* rightshift */
2185 0, /* size (0 = byte, 1 = short, 2 = long) */
2186 0, /* bitsize */
2187 FALSE, /* pc_relative */
2188 0, /* bitpos */
2189 complain_overflow_dont, /* complain_on_overflow */
2190 NULL, /* special_function */
2191 "R_PPC64_GNU_VTENTRY", /* name */
2192 FALSE, /* partial_inplace */
2193 0, /* src_mask */
2194 0, /* dst_mask */
2195 FALSE), /* pcrel_offset */
2196 };
2197
2198 \f
2199 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2200 be done. */
2201
2202 static void
2203 ppc_howto_init (void)
2204 {
2205 unsigned int i, type;
2206
2207 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2208 {
2209 type = ppc64_elf_howto_raw[i].type;
2210 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2211 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2212 }
2213 }
2214
2215 static reloc_howto_type *
2216 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2217 bfd_reloc_code_real_type code)
2218 {
2219 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2220
2221 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2222 /* Initialize howto table if needed. */
2223 ppc_howto_init ();
2224
2225 switch (code)
2226 {
2227 default:
2228 return NULL;
2229
2230 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2231 break;
2232 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2233 break;
2234 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2235 break;
2236 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2237 break;
2238 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2239 break;
2240 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2241 break;
2242 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2243 break;
2244 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2245 break;
2246 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2247 break;
2248 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2249 break;
2250 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2251 break;
2252 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2253 break;
2254 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2255 break;
2256 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2257 break;
2258 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2259 break;
2260 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2261 break;
2262 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2263 break;
2264 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2265 break;
2266 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2267 break;
2268 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2269 break;
2270 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2271 break;
2272 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2273 break;
2274 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2275 break;
2276 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2277 break;
2278 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2279 break;
2280 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2281 break;
2282 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2283 break;
2284 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2285 break;
2286 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2287 break;
2288 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2289 break;
2290 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2291 break;
2292 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2293 break;
2294 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2295 break;
2296 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2297 break;
2298 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2299 break;
2300 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2301 break;
2302 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2303 break;
2304 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2305 break;
2306 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2307 break;
2308 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2309 break;
2310 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2311 break;
2312 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2313 break;
2314 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2315 break;
2316 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2317 break;
2318 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2319 break;
2320 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2321 break;
2322 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2323 break;
2324 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2325 break;
2326 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2327 break;
2328 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2329 break;
2330 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2331 break;
2332 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2333 break;
2334 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2335 break;
2336 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2337 break;
2338 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2339 break;
2340 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2341 break;
2342 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2343 break;
2344 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2345 break;
2346 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2347 break;
2348 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2349 break;
2350 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2351 break;
2352 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2353 break;
2354 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2355 break;
2356 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2357 break;
2358 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2359 break;
2360 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2361 break;
2362 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2363 break;
2364 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2365 break;
2366 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2367 break;
2368 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2369 break;
2370 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2371 break;
2372 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2373 break;
2374 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2375 break;
2376 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2377 break;
2378 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2379 break;
2380 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2381 break;
2382 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2383 break;
2384 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2385 break;
2386 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2387 break;
2388 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2389 break;
2390 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2391 break;
2392 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2393 break;
2394 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2395 break;
2396 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2397 break;
2398 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2399 break;
2400 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2401 break;
2402 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2403 break;
2404 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2405 break;
2406 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2407 break;
2408 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2409 break;
2410 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2411 break;
2412 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2413 break;
2414 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2415 break;
2416 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2417 break;
2418 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2419 break;
2420 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2421 break;
2422 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2423 break;
2424 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2425 break;
2426 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2427 break;
2428 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2429 break;
2430 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2431 break;
2432 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2433 break;
2434 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2435 break;
2436 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2437 break;
2438 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2439 break;
2440 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2441 break;
2442 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2443 break;
2444 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2445 break;
2446 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2447 break;
2448 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2449 break;
2450 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2451 break;
2452 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2453 break;
2454 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2455 break;
2456 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2457 break;
2458 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2459 break;
2460 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2461 break;
2462 }
2463
2464 return ppc64_elf_howto_table[r];
2465 };
2466
2467 static reloc_howto_type *
2468 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2469 const char *r_name)
2470 {
2471 unsigned int i;
2472
2473 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2474 if (ppc64_elf_howto_raw[i].name != NULL
2475 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2476 return &ppc64_elf_howto_raw[i];
2477
2478 return NULL;
2479 }
2480
2481 /* Set the howto pointer for a PowerPC ELF reloc. */
2482
2483 static void
2484 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2485 Elf_Internal_Rela *dst)
2486 {
2487 unsigned int type;
2488
2489 /* Initialize howto table if needed. */
2490 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2491 ppc_howto_init ();
2492
2493 type = ELF64_R_TYPE (dst->r_info);
2494 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2495 {
2496 /* xgettext:c-format */
2497 _bfd_error_handler (_("%B: invalid relocation type %d"),
2498 abfd, (int) type);
2499 type = R_PPC64_NONE;
2500 }
2501 cache_ptr->howto = ppc64_elf_howto_table[type];
2502 }
2503
2504 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2505
2506 static bfd_reloc_status_type
2507 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2508 void *data, asection *input_section,
2509 bfd *output_bfd, char **error_message)
2510 {
2511 enum elf_ppc64_reloc_type r_type;
2512 long insn;
2513 bfd_size_type octets;
2514 bfd_vma value;
2515
2516 /* If this is a relocatable link (output_bfd test tells us), just
2517 call the generic function. Any adjustment will be done at final
2518 link time. */
2519 if (output_bfd != NULL)
2520 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2521 input_section, output_bfd, error_message);
2522
2523 /* Adjust the addend for sign extension of the low 16 bits.
2524 We won't actually be using the low 16 bits, so trashing them
2525 doesn't matter. */
2526 reloc_entry->addend += 0x8000;
2527 r_type = reloc_entry->howto->type;
2528 if (r_type != R_PPC64_REL16DX_HA)
2529 return bfd_reloc_continue;
2530
2531 value = 0;
2532 if (!bfd_is_com_section (symbol->section))
2533 value = symbol->value;
2534 value += (reloc_entry->addend
2535 + symbol->section->output_offset
2536 + symbol->section->output_section->vma);
2537 value -= (reloc_entry->address
2538 + input_section->output_offset
2539 + input_section->output_section->vma);
2540 value = (bfd_signed_vma) value >> 16;
2541
2542 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2543 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2544 insn &= ~0x1fffc1;
2545 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2546 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2547 if (value + 0x8000 > 0xffff)
2548 return bfd_reloc_overflow;
2549 return bfd_reloc_ok;
2550 }
2551
2552 static bfd_reloc_status_type
2553 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2554 void *data, asection *input_section,
2555 bfd *output_bfd, char **error_message)
2556 {
2557 if (output_bfd != NULL)
2558 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2559 input_section, output_bfd, error_message);
2560
2561 if (strcmp (symbol->section->name, ".opd") == 0
2562 && (symbol->section->owner->flags & DYNAMIC) == 0)
2563 {
2564 bfd_vma dest = opd_entry_value (symbol->section,
2565 symbol->value + reloc_entry->addend,
2566 NULL, NULL, FALSE);
2567 if (dest != (bfd_vma) -1)
2568 reloc_entry->addend = dest - (symbol->value
2569 + symbol->section->output_section->vma
2570 + symbol->section->output_offset);
2571 }
2572 else
2573 {
2574 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2575
2576 if (symbol->section->owner != abfd
2577 && symbol->section->owner != NULL
2578 && abiversion (symbol->section->owner) >= 2)
2579 {
2580 unsigned int i;
2581
2582 for (i = 0; i < symbol->section->owner->symcount; ++i)
2583 {
2584 asymbol *symdef = symbol->section->owner->outsymbols[i];
2585
2586 if (strcmp (symdef->name, symbol->name) == 0)
2587 {
2588 elfsym = (elf_symbol_type *) symdef;
2589 break;
2590 }
2591 }
2592 }
2593 reloc_entry->addend
2594 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2595 }
2596 return bfd_reloc_continue;
2597 }
2598
2599 static bfd_reloc_status_type
2600 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2601 void *data, asection *input_section,
2602 bfd *output_bfd, char **error_message)
2603 {
2604 long insn;
2605 enum elf_ppc64_reloc_type r_type;
2606 bfd_size_type octets;
2607 /* Assume 'at' branch hints. */
2608 bfd_boolean is_isa_v2 = TRUE;
2609
2610 /* If this is a relocatable link (output_bfd test tells us), just
2611 call the generic function. Any adjustment will be done at final
2612 link time. */
2613 if (output_bfd != NULL)
2614 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2615 input_section, output_bfd, error_message);
2616
2617 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2618 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2619 insn &= ~(0x01 << 21);
2620 r_type = reloc_entry->howto->type;
2621 if (r_type == R_PPC64_ADDR14_BRTAKEN
2622 || r_type == R_PPC64_REL14_BRTAKEN)
2623 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2624
2625 if (is_isa_v2)
2626 {
2627 /* Set 'a' bit. This is 0b00010 in BO field for branch
2628 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2629 for branch on CTR insns (BO == 1a00t or 1a01t). */
2630 if ((insn & (0x14 << 21)) == (0x04 << 21))
2631 insn |= 0x02 << 21;
2632 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2633 insn |= 0x08 << 21;
2634 else
2635 goto out;
2636 }
2637 else
2638 {
2639 bfd_vma target = 0;
2640 bfd_vma from;
2641
2642 if (!bfd_is_com_section (symbol->section))
2643 target = symbol->value;
2644 target += symbol->section->output_section->vma;
2645 target += symbol->section->output_offset;
2646 target += reloc_entry->addend;
2647
2648 from = (reloc_entry->address
2649 + input_section->output_offset
2650 + input_section->output_section->vma);
2651
2652 /* Invert 'y' bit if not the default. */
2653 if ((bfd_signed_vma) (target - from) < 0)
2654 insn ^= 0x01 << 21;
2655 }
2656 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2657 out:
2658 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2659 input_section, output_bfd, error_message);
2660 }
2661
2662 static bfd_reloc_status_type
2663 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2664 void *data, asection *input_section,
2665 bfd *output_bfd, char **error_message)
2666 {
2667 /* If this is a relocatable link (output_bfd test tells us), just
2668 call the generic function. Any adjustment will be done at final
2669 link time. */
2670 if (output_bfd != NULL)
2671 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2672 input_section, output_bfd, error_message);
2673
2674 /* Subtract the symbol section base address. */
2675 reloc_entry->addend -= symbol->section->output_section->vma;
2676 return bfd_reloc_continue;
2677 }
2678
2679 static bfd_reloc_status_type
2680 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2681 void *data, asection *input_section,
2682 bfd *output_bfd, char **error_message)
2683 {
2684 /* If this is a relocatable link (output_bfd test tells us), just
2685 call the generic function. Any adjustment will be done at final
2686 link time. */
2687 if (output_bfd != NULL)
2688 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2689 input_section, output_bfd, error_message);
2690
2691 /* Subtract the symbol section base address. */
2692 reloc_entry->addend -= symbol->section->output_section->vma;
2693
2694 /* Adjust the addend for sign extension of the low 16 bits. */
2695 reloc_entry->addend += 0x8000;
2696 return bfd_reloc_continue;
2697 }
2698
2699 static bfd_reloc_status_type
2700 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2701 void *data, asection *input_section,
2702 bfd *output_bfd, char **error_message)
2703 {
2704 bfd_vma TOCstart;
2705
2706 /* If this is a relocatable link (output_bfd test tells us), just
2707 call the generic function. Any adjustment will be done at final
2708 link time. */
2709 if (output_bfd != NULL)
2710 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2711 input_section, output_bfd, error_message);
2712
2713 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2714 if (TOCstart == 0)
2715 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2716
2717 /* Subtract the TOC base address. */
2718 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2719 return bfd_reloc_continue;
2720 }
2721
2722 static bfd_reloc_status_type
2723 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2724 void *data, asection *input_section,
2725 bfd *output_bfd, char **error_message)
2726 {
2727 bfd_vma TOCstart;
2728
2729 /* If this is a relocatable link (output_bfd test tells us), just
2730 call the generic function. Any adjustment will be done at final
2731 link time. */
2732 if (output_bfd != NULL)
2733 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2734 input_section, output_bfd, error_message);
2735
2736 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2737 if (TOCstart == 0)
2738 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2739
2740 /* Subtract the TOC base address. */
2741 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2742
2743 /* Adjust the addend for sign extension of the low 16 bits. */
2744 reloc_entry->addend += 0x8000;
2745 return bfd_reloc_continue;
2746 }
2747
2748 static bfd_reloc_status_type
2749 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2750 void *data, asection *input_section,
2751 bfd *output_bfd, char **error_message)
2752 {
2753 bfd_vma TOCstart;
2754 bfd_size_type octets;
2755
2756 /* If this is a relocatable link (output_bfd test tells us), just
2757 call the generic function. Any adjustment will be done at final
2758 link time. */
2759 if (output_bfd != NULL)
2760 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2761 input_section, output_bfd, error_message);
2762
2763 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2764 if (TOCstart == 0)
2765 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2766
2767 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2768 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2769 return bfd_reloc_ok;
2770 }
2771
2772 static bfd_reloc_status_type
2773 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2774 void *data, asection *input_section,
2775 bfd *output_bfd, char **error_message)
2776 {
2777 /* If this is a relocatable link (output_bfd test tells us), just
2778 call the generic function. Any adjustment will be done at final
2779 link time. */
2780 if (output_bfd != NULL)
2781 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2782 input_section, output_bfd, error_message);
2783
2784 if (error_message != NULL)
2785 {
2786 static char buf[60];
2787 sprintf (buf, "generic linker can't handle %s",
2788 reloc_entry->howto->name);
2789 *error_message = buf;
2790 }
2791 return bfd_reloc_dangerous;
2792 }
2793
2794 /* Track GOT entries needed for a given symbol. We might need more
2795 than one got entry per symbol. */
2796 struct got_entry
2797 {
2798 struct got_entry *next;
2799
2800 /* The symbol addend that we'll be placing in the GOT. */
2801 bfd_vma addend;
2802
2803 /* Unlike other ELF targets, we use separate GOT entries for the same
2804 symbol referenced from different input files. This is to support
2805 automatic multiple TOC/GOT sections, where the TOC base can vary
2806 from one input file to another. After partitioning into TOC groups
2807 we merge entries within the group.
2808
2809 Point to the BFD owning this GOT entry. */
2810 bfd *owner;
2811
2812 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2813 TLS_TPREL or TLS_DTPREL for tls entries. */
2814 unsigned char tls_type;
2815
2816 /* Non-zero if got.ent points to real entry. */
2817 unsigned char is_indirect;
2818
2819 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2820 union
2821 {
2822 bfd_signed_vma refcount;
2823 bfd_vma offset;
2824 struct got_entry *ent;
2825 } got;
2826 };
2827
2828 /* The same for PLT. */
2829 struct plt_entry
2830 {
2831 struct plt_entry *next;
2832
2833 bfd_vma addend;
2834
2835 union
2836 {
2837 bfd_signed_vma refcount;
2838 bfd_vma offset;
2839 } plt;
2840 };
2841
2842 struct ppc64_elf_obj_tdata
2843 {
2844 struct elf_obj_tdata elf;
2845
2846 /* Shortcuts to dynamic linker sections. */
2847 asection *got;
2848 asection *relgot;
2849
2850 /* Used during garbage collection. We attach global symbols defined
2851 on removed .opd entries to this section so that the sym is removed. */
2852 asection *deleted_section;
2853
2854 /* TLS local dynamic got entry handling. Support for multiple GOT
2855 sections means we potentially need one of these for each input bfd. */
2856 struct got_entry tlsld_got;
2857
2858 union {
2859 /* A copy of relocs before they are modified for --emit-relocs. */
2860 Elf_Internal_Rela *relocs;
2861
2862 /* Section contents. */
2863 bfd_byte *contents;
2864 } opd;
2865
2866 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2867 the reloc to be in the range -32768 to 32767. */
2868 unsigned int has_small_toc_reloc : 1;
2869
2870 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2871 instruction not one we handle. */
2872 unsigned int unexpected_toc_insn : 1;
2873 };
2874
2875 #define ppc64_elf_tdata(bfd) \
2876 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2877
2878 #define ppc64_tlsld_got(bfd) \
2879 (&ppc64_elf_tdata (bfd)->tlsld_got)
2880
2881 #define is_ppc64_elf(bfd) \
2882 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2883 && elf_object_id (bfd) == PPC64_ELF_DATA)
2884
2885 /* Override the generic function because we store some extras. */
2886
2887 static bfd_boolean
2888 ppc64_elf_mkobject (bfd *abfd)
2889 {
2890 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2891 PPC64_ELF_DATA);
2892 }
2893
2894 /* Fix bad default arch selected for a 64 bit input bfd when the
2895 default is 32 bit. Also select arch based on apuinfo. */
2896
2897 static bfd_boolean
2898 ppc64_elf_object_p (bfd *abfd)
2899 {
2900 if (!abfd->arch_info->the_default)
2901 return TRUE;
2902
2903 if (abfd->arch_info->bits_per_word == 32)
2904 {
2905 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2906
2907 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2908 {
2909 /* Relies on arch after 32 bit default being 64 bit default. */
2910 abfd->arch_info = abfd->arch_info->next;
2911 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2912 }
2913 }
2914 return _bfd_elf_ppc_set_arch (abfd);
2915 }
2916
2917 /* Support for core dump NOTE sections. */
2918
2919 static bfd_boolean
2920 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2921 {
2922 size_t offset, size;
2923
2924 if (note->descsz != 504)
2925 return FALSE;
2926
2927 /* pr_cursig */
2928 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2929
2930 /* pr_pid */
2931 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2932
2933 /* pr_reg */
2934 offset = 112;
2935 size = 384;
2936
2937 /* Make a ".reg/999" section. */
2938 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2939 size, note->descpos + offset);
2940 }
2941
2942 static bfd_boolean
2943 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2944 {
2945 if (note->descsz != 136)
2946 return FALSE;
2947
2948 elf_tdata (abfd)->core->pid
2949 = bfd_get_32 (abfd, note->descdata + 24);
2950 elf_tdata (abfd)->core->program
2951 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2952 elf_tdata (abfd)->core->command
2953 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2954
2955 return TRUE;
2956 }
2957
2958 static char *
2959 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2960 ...)
2961 {
2962 switch (note_type)
2963 {
2964 default:
2965 return NULL;
2966
2967 case NT_PRPSINFO:
2968 {
2969 char data[136];
2970 va_list ap;
2971
2972 va_start (ap, note_type);
2973 memset (data, 0, sizeof (data));
2974 strncpy (data + 40, va_arg (ap, const char *), 16);
2975 strncpy (data + 56, va_arg (ap, const char *), 80);
2976 va_end (ap);
2977 return elfcore_write_note (abfd, buf, bufsiz,
2978 "CORE", note_type, data, sizeof (data));
2979 }
2980
2981 case NT_PRSTATUS:
2982 {
2983 char data[504];
2984 va_list ap;
2985 long pid;
2986 int cursig;
2987 const void *greg;
2988
2989 va_start (ap, note_type);
2990 memset (data, 0, 112);
2991 pid = va_arg (ap, long);
2992 bfd_put_32 (abfd, pid, data + 32);
2993 cursig = va_arg (ap, int);
2994 bfd_put_16 (abfd, cursig, data + 12);
2995 greg = va_arg (ap, const void *);
2996 memcpy (data + 112, greg, 384);
2997 memset (data + 496, 0, 8);
2998 va_end (ap);
2999 return elfcore_write_note (abfd, buf, bufsiz,
3000 "CORE", note_type, data, sizeof (data));
3001 }
3002 }
3003 }
3004
3005 /* Add extra PPC sections. */
3006
3007 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3008 {
3009 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3010 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3011 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3012 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3013 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3014 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3015 { NULL, 0, 0, 0, 0 }
3016 };
3017
3018 enum _ppc64_sec_type {
3019 sec_normal = 0,
3020 sec_opd = 1,
3021 sec_toc = 2
3022 };
3023
3024 struct _ppc64_elf_section_data
3025 {
3026 struct bfd_elf_section_data elf;
3027
3028 union
3029 {
3030 /* An array with one entry for each opd function descriptor,
3031 and some spares since opd entries may be either 16 or 24 bytes. */
3032 #define OPD_NDX(OFF) ((OFF) >> 4)
3033 struct _opd_sec_data
3034 {
3035 /* Points to the function code section for local opd entries. */
3036 asection **func_sec;
3037
3038 /* After editing .opd, adjust references to opd local syms. */
3039 long *adjust;
3040 } opd;
3041
3042 /* An array for toc sections, indexed by offset/8. */
3043 struct _toc_sec_data
3044 {
3045 /* Specifies the relocation symbol index used at a given toc offset. */
3046 unsigned *symndx;
3047
3048 /* And the relocation addend. */
3049 bfd_vma *add;
3050 } toc;
3051 } u;
3052
3053 enum _ppc64_sec_type sec_type:2;
3054
3055 /* Flag set when small branches are detected. Used to
3056 select suitable defaults for the stub group size. */
3057 unsigned int has_14bit_branch:1;
3058 };
3059
3060 #define ppc64_elf_section_data(sec) \
3061 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3062
3063 static bfd_boolean
3064 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3065 {
3066 if (!sec->used_by_bfd)
3067 {
3068 struct _ppc64_elf_section_data *sdata;
3069 bfd_size_type amt = sizeof (*sdata);
3070
3071 sdata = bfd_zalloc (abfd, amt);
3072 if (sdata == NULL)
3073 return FALSE;
3074 sec->used_by_bfd = sdata;
3075 }
3076
3077 return _bfd_elf_new_section_hook (abfd, sec);
3078 }
3079
3080 static struct _opd_sec_data *
3081 get_opd_info (asection * sec)
3082 {
3083 if (sec != NULL
3084 && ppc64_elf_section_data (sec) != NULL
3085 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3086 return &ppc64_elf_section_data (sec)->u.opd;
3087 return NULL;
3088 }
3089 \f
3090 /* Parameters for the qsort hook. */
3091 static bfd_boolean synthetic_relocatable;
3092 static asection *synthetic_opd;
3093
3094 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3095
3096 static int
3097 compare_symbols (const void *ap, const void *bp)
3098 {
3099 const asymbol *a = * (const asymbol **) ap;
3100 const asymbol *b = * (const asymbol **) bp;
3101
3102 /* Section symbols first. */
3103 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3104 return -1;
3105 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3106 return 1;
3107
3108 /* then .opd symbols. */
3109 if (synthetic_opd != NULL)
3110 {
3111 if (strcmp (a->section->name, ".opd") == 0
3112 && strcmp (b->section->name, ".opd") != 0)
3113 return -1;
3114 if (strcmp (a->section->name, ".opd") != 0
3115 && strcmp (b->section->name, ".opd") == 0)
3116 return 1;
3117 }
3118
3119 /* then other code symbols. */
3120 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3121 == (SEC_CODE | SEC_ALLOC)
3122 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123 != (SEC_CODE | SEC_ALLOC))
3124 return -1;
3125
3126 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3127 != (SEC_CODE | SEC_ALLOC)
3128 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3129 == (SEC_CODE | SEC_ALLOC))
3130 return 1;
3131
3132 if (synthetic_relocatable)
3133 {
3134 if (a->section->id < b->section->id)
3135 return -1;
3136
3137 if (a->section->id > b->section->id)
3138 return 1;
3139 }
3140
3141 if (a->value + a->section->vma < b->value + b->section->vma)
3142 return -1;
3143
3144 if (a->value + a->section->vma > b->value + b->section->vma)
3145 return 1;
3146
3147 /* For syms with the same value, prefer strong dynamic global function
3148 syms over other syms. */
3149 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3150 return -1;
3151
3152 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3153 return 1;
3154
3155 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3156 return -1;
3157
3158 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3159 return 1;
3160
3161 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3162 return -1;
3163
3164 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3165 return 1;
3166
3167 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3168 return -1;
3169
3170 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3171 return 1;
3172
3173 return 0;
3174 }
3175
3176 /* Search SYMS for a symbol of the given VALUE. */
3177
3178 static asymbol *
3179 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3180 {
3181 long mid;
3182
3183 if (id == (unsigned) -1)
3184 {
3185 while (lo < hi)
3186 {
3187 mid = (lo + hi) >> 1;
3188 if (syms[mid]->value + syms[mid]->section->vma < value)
3189 lo = mid + 1;
3190 else if (syms[mid]->value + syms[mid]->section->vma > value)
3191 hi = mid;
3192 else
3193 return syms[mid];
3194 }
3195 }
3196 else
3197 {
3198 while (lo < hi)
3199 {
3200 mid = (lo + hi) >> 1;
3201 if (syms[mid]->section->id < id)
3202 lo = mid + 1;
3203 else if (syms[mid]->section->id > id)
3204 hi = mid;
3205 else if (syms[mid]->value < value)
3206 lo = mid + 1;
3207 else if (syms[mid]->value > value)
3208 hi = mid;
3209 else
3210 return syms[mid];
3211 }
3212 }
3213 return NULL;
3214 }
3215
3216 static bfd_boolean
3217 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3218 {
3219 bfd_vma vma = *(bfd_vma *) ptr;
3220 return ((section->flags & SEC_ALLOC) != 0
3221 && section->vma <= vma
3222 && vma < section->vma + section->size);
3223 }
3224
3225 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3226 entry syms. Also generate @plt symbols for the glink branch table.
3227 Returns count of synthetic symbols in RET or -1 on error. */
3228
3229 static long
3230 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3231 long static_count, asymbol **static_syms,
3232 long dyn_count, asymbol **dyn_syms,
3233 asymbol **ret)
3234 {
3235 asymbol *s;
3236 long i;
3237 long count;
3238 char *names;
3239 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3240 asection *opd = NULL;
3241 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3242 asymbol **syms;
3243 int abi = abiversion (abfd);
3244
3245 *ret = NULL;
3246
3247 if (abi < 2)
3248 {
3249 opd = bfd_get_section_by_name (abfd, ".opd");
3250 if (opd == NULL && abi == 1)
3251 return 0;
3252 }
3253
3254 symcount = static_count;
3255 if (!relocatable)
3256 symcount += dyn_count;
3257 if (symcount == 0)
3258 return 0;
3259
3260 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3261 if (syms == NULL)
3262 return -1;
3263
3264 if (!relocatable && static_count != 0 && dyn_count != 0)
3265 {
3266 /* Use both symbol tables. */
3267 memcpy (syms, static_syms, static_count * sizeof (*syms));
3268 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3269 }
3270 else if (!relocatable && static_count == 0)
3271 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3272 else
3273 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3274
3275 synthetic_relocatable = relocatable;
3276 synthetic_opd = opd;
3277 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3278
3279 if (!relocatable && symcount > 1)
3280 {
3281 long j;
3282 /* Trim duplicate syms, since we may have merged the normal and
3283 dynamic symbols. Actually, we only care about syms that have
3284 different values, so trim any with the same value. */
3285 for (i = 1, j = 1; i < symcount; ++i)
3286 if (syms[i - 1]->value + syms[i - 1]->section->vma
3287 != syms[i]->value + syms[i]->section->vma)
3288 syms[j++] = syms[i];
3289 symcount = j;
3290 }
3291
3292 i = 0;
3293 /* Note that here and in compare_symbols we can't compare opd and
3294 sym->section directly. With separate debug info files, the
3295 symbols will be extracted from the debug file while abfd passed
3296 to this function is the real binary. */
3297 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3298 ++i;
3299 codesecsym = i;
3300
3301 for (; i < symcount; ++i)
3302 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3303 != (SEC_CODE | SEC_ALLOC))
3304 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3305 break;
3306 codesecsymend = i;
3307
3308 for (; i < symcount; ++i)
3309 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3310 break;
3311 secsymend = i;
3312
3313 if (opd != NULL)
3314 for (; i < symcount; ++i)
3315 if (strcmp (syms[i]->section->name, ".opd") != 0)
3316 break;
3317 opdsymend = i;
3318
3319 for (; i < symcount; ++i)
3320 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3321 != (SEC_CODE | SEC_ALLOC))
3322 break;
3323 symcount = i;
3324
3325 count = 0;
3326
3327 if (relocatable)
3328 {
3329 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3330 arelent *r;
3331 size_t size;
3332 long relcount;
3333
3334 if (opdsymend == secsymend)
3335 goto done;
3336
3337 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3338 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3339 if (relcount == 0)
3340 goto done;
3341
3342 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3343 {
3344 count = -1;
3345 goto done;
3346 }
3347
3348 size = 0;
3349 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3350 {
3351 asymbol *sym;
3352
3353 while (r < opd->relocation + relcount
3354 && r->address < syms[i]->value + opd->vma)
3355 ++r;
3356
3357 if (r == opd->relocation + relcount)
3358 break;
3359
3360 if (r->address != syms[i]->value + opd->vma)
3361 continue;
3362
3363 if (r->howto->type != R_PPC64_ADDR64)
3364 continue;
3365
3366 sym = *r->sym_ptr_ptr;
3367 if (!sym_exists_at (syms, opdsymend, symcount,
3368 sym->section->id, sym->value + r->addend))
3369 {
3370 ++count;
3371 size += sizeof (asymbol);
3372 size += strlen (syms[i]->name) + 2;
3373 }
3374 }
3375
3376 if (size == 0)
3377 goto done;
3378 s = *ret = bfd_malloc (size);
3379 if (s == NULL)
3380 {
3381 count = -1;
3382 goto done;
3383 }
3384
3385 names = (char *) (s + count);
3386
3387 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3388 {
3389 asymbol *sym;
3390
3391 while (r < opd->relocation + relcount
3392 && r->address < syms[i]->value + opd->vma)
3393 ++r;
3394
3395 if (r == opd->relocation + relcount)
3396 break;
3397
3398 if (r->address != syms[i]->value + opd->vma)
3399 continue;
3400
3401 if (r->howto->type != R_PPC64_ADDR64)
3402 continue;
3403
3404 sym = *r->sym_ptr_ptr;
3405 if (!sym_exists_at (syms, opdsymend, symcount,
3406 sym->section->id, sym->value + r->addend))
3407 {
3408 size_t len;
3409
3410 *s = *syms[i];
3411 s->flags |= BSF_SYNTHETIC;
3412 s->section = sym->section;
3413 s->value = sym->value + r->addend;
3414 s->name = names;
3415 *names++ = '.';
3416 len = strlen (syms[i]->name);
3417 memcpy (names, syms[i]->name, len + 1);
3418 names += len + 1;
3419 /* Have udata.p point back to the original symbol this
3420 synthetic symbol was derived from. */
3421 s->udata.p = syms[i];
3422 s++;
3423 }
3424 }
3425 }
3426 else
3427 {
3428 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3429 bfd_byte *contents = NULL;
3430 size_t size;
3431 long plt_count = 0;
3432 bfd_vma glink_vma = 0, resolv_vma = 0;
3433 asection *dynamic, *glink = NULL, *relplt = NULL;
3434 arelent *p;
3435
3436 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3437 {
3438 free_contents_and_exit_err:
3439 count = -1;
3440 free_contents_and_exit:
3441 if (contents)
3442 free (contents);
3443 goto done;
3444 }
3445
3446 size = 0;
3447 for (i = secsymend; i < opdsymend; ++i)
3448 {
3449 bfd_vma ent;
3450
3451 /* Ignore bogus symbols. */
3452 if (syms[i]->value > opd->size - 8)
3453 continue;
3454
3455 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3456 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3457 {
3458 ++count;
3459 size += sizeof (asymbol);
3460 size += strlen (syms[i]->name) + 2;
3461 }
3462 }
3463
3464 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3465 if (dyn_count != 0
3466 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3467 {
3468 bfd_byte *dynbuf, *extdyn, *extdynend;
3469 size_t extdynsize;
3470 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3471
3472 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3473 goto free_contents_and_exit_err;
3474
3475 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3476 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3477
3478 extdyn = dynbuf;
3479 extdynend = extdyn + dynamic->size;
3480 for (; extdyn < extdynend; extdyn += extdynsize)
3481 {
3482 Elf_Internal_Dyn dyn;
3483 (*swap_dyn_in) (abfd, extdyn, &dyn);
3484
3485 if (dyn.d_tag == DT_NULL)
3486 break;
3487
3488 if (dyn.d_tag == DT_PPC64_GLINK)
3489 {
3490 /* The first glink stub starts at offset 32; see
3491 comment in ppc64_elf_finish_dynamic_sections. */
3492 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3493 /* The .glink section usually does not survive the final
3494 link; search for the section (usually .text) where the
3495 glink stubs now reside. */
3496 glink = bfd_sections_find_if (abfd, section_covers_vma,
3497 &glink_vma);
3498 break;
3499 }
3500 }
3501
3502 free (dynbuf);
3503 }
3504
3505 if (glink != NULL)
3506 {
3507 /* Determine __glink trampoline by reading the relative branch
3508 from the first glink stub. */
3509 bfd_byte buf[4];
3510 unsigned int off = 0;
3511
3512 while (bfd_get_section_contents (abfd, glink, buf,
3513 glink_vma + off - glink->vma, 4))
3514 {
3515 unsigned int insn = bfd_get_32 (abfd, buf);
3516 insn ^= B_DOT;
3517 if ((insn & ~0x3fffffc) == 0)
3518 {
3519 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3520 break;
3521 }
3522 off += 4;
3523 if (off > 4)
3524 break;
3525 }
3526
3527 if (resolv_vma)
3528 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3529
3530 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3531 if (relplt != NULL)
3532 {
3533 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3534 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3535 goto free_contents_and_exit_err;
3536
3537 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3538 size += plt_count * sizeof (asymbol);
3539
3540 p = relplt->relocation;
3541 for (i = 0; i < plt_count; i++, p++)
3542 {
3543 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3544 if (p->addend != 0)
3545 size += sizeof ("+0x") - 1 + 16;
3546 }
3547 }
3548 }
3549
3550 if (size == 0)
3551 goto free_contents_and_exit;
3552 s = *ret = bfd_malloc (size);
3553 if (s == NULL)
3554 goto free_contents_and_exit_err;
3555
3556 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3557
3558 for (i = secsymend; i < opdsymend; ++i)
3559 {
3560 bfd_vma ent;
3561
3562 if (syms[i]->value > opd->size - 8)
3563 continue;
3564
3565 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3566 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3567 {
3568 long lo, hi;
3569 size_t len;
3570 asection *sec = abfd->sections;
3571
3572 *s = *syms[i];
3573 lo = codesecsym;
3574 hi = codesecsymend;
3575 while (lo < hi)
3576 {
3577 long mid = (lo + hi) >> 1;
3578 if (syms[mid]->section->vma < ent)
3579 lo = mid + 1;
3580 else if (syms[mid]->section->vma > ent)
3581 hi = mid;
3582 else
3583 {
3584 sec = syms[mid]->section;
3585 break;
3586 }
3587 }
3588
3589 if (lo >= hi && lo > codesecsym)
3590 sec = syms[lo - 1]->section;
3591
3592 for (; sec != NULL; sec = sec->next)
3593 {
3594 if (sec->vma > ent)
3595 break;
3596 /* SEC_LOAD may not be set if SEC is from a separate debug
3597 info file. */
3598 if ((sec->flags & SEC_ALLOC) == 0)
3599 break;
3600 if ((sec->flags & SEC_CODE) != 0)
3601 s->section = sec;
3602 }
3603 s->flags |= BSF_SYNTHETIC;
3604 s->value = ent - s->section->vma;
3605 s->name = names;
3606 *names++ = '.';
3607 len = strlen (syms[i]->name);
3608 memcpy (names, syms[i]->name, len + 1);
3609 names += len + 1;
3610 /* Have udata.p point back to the original symbol this
3611 synthetic symbol was derived from. */
3612 s->udata.p = syms[i];
3613 s++;
3614 }
3615 }
3616 free (contents);
3617
3618 if (glink != NULL && relplt != NULL)
3619 {
3620 if (resolv_vma)
3621 {
3622 /* Add a symbol for the main glink trampoline. */
3623 memset (s, 0, sizeof *s);
3624 s->the_bfd = abfd;
3625 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3626 s->section = glink;
3627 s->value = resolv_vma - glink->vma;
3628 s->name = names;
3629 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3630 names += sizeof ("__glink_PLTresolve");
3631 s++;
3632 count++;
3633 }
3634
3635 /* FIXME: It would be very much nicer to put sym@plt on the
3636 stub rather than on the glink branch table entry. The
3637 objdump disassembler would then use a sensible symbol
3638 name on plt calls. The difficulty in doing so is
3639 a) finding the stubs, and,
3640 b) matching stubs against plt entries, and,
3641 c) there can be multiple stubs for a given plt entry.
3642
3643 Solving (a) could be done by code scanning, but older
3644 ppc64 binaries used different stubs to current code.
3645 (b) is the tricky one since you need to known the toc
3646 pointer for at least one function that uses a pic stub to
3647 be able to calculate the plt address referenced.
3648 (c) means gdb would need to set multiple breakpoints (or
3649 find the glink branch itself) when setting breakpoints
3650 for pending shared library loads. */
3651 p = relplt->relocation;
3652 for (i = 0; i < plt_count; i++, p++)
3653 {
3654 size_t len;
3655
3656 *s = **p->sym_ptr_ptr;
3657 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3658 we are defining a symbol, ensure one of them is set. */
3659 if ((s->flags & BSF_LOCAL) == 0)
3660 s->flags |= BSF_GLOBAL;
3661 s->flags |= BSF_SYNTHETIC;
3662 s->section = glink;
3663 s->value = glink_vma - glink->vma;
3664 s->name = names;
3665 s->udata.p = NULL;
3666 len = strlen ((*p->sym_ptr_ptr)->name);
3667 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3668 names += len;
3669 if (p->addend != 0)
3670 {
3671 memcpy (names, "+0x", sizeof ("+0x") - 1);
3672 names += sizeof ("+0x") - 1;
3673 bfd_sprintf_vma (abfd, names, p->addend);
3674 names += strlen (names);
3675 }
3676 memcpy (names, "@plt", sizeof ("@plt"));
3677 names += sizeof ("@plt");
3678 s++;
3679 if (abi < 2)
3680 {
3681 glink_vma += 8;
3682 if (i >= 0x8000)
3683 glink_vma += 4;
3684 }
3685 else
3686 glink_vma += 4;
3687 }
3688 count += plt_count;
3689 }
3690 }
3691
3692 done:
3693 free (syms);
3694 return count;
3695 }
3696 \f
3697 /* The following functions are specific to the ELF linker, while
3698 functions above are used generally. Those named ppc64_elf_* are
3699 called by the main ELF linker code. They appear in this file more
3700 or less in the order in which they are called. eg.
3701 ppc64_elf_check_relocs is called early in the link process,
3702 ppc64_elf_finish_dynamic_sections is one of the last functions
3703 called.
3704
3705 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3706 functions have both a function code symbol and a function descriptor
3707 symbol. A call to foo in a relocatable object file looks like:
3708
3709 . .text
3710 . x:
3711 . bl .foo
3712 . nop
3713
3714 The function definition in another object file might be:
3715
3716 . .section .opd
3717 . foo: .quad .foo
3718 . .quad .TOC.@tocbase
3719 . .quad 0
3720 .
3721 . .text
3722 . .foo: blr
3723
3724 When the linker resolves the call during a static link, the branch
3725 unsurprisingly just goes to .foo and the .opd information is unused.
3726 If the function definition is in a shared library, things are a little
3727 different: The call goes via a plt call stub, the opd information gets
3728 copied to the plt, and the linker patches the nop.
3729
3730 . x:
3731 . bl .foo_stub
3732 . ld 2,40(1)
3733 .
3734 .
3735 . .foo_stub:
3736 . std 2,40(1) # in practice, the call stub
3737 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3738 . addi 11,11,Lfoo@toc@l # this is the general idea
3739 . ld 12,0(11)
3740 . ld 2,8(11)
3741 . mtctr 12
3742 . ld 11,16(11)
3743 . bctr
3744 .
3745 . .section .plt
3746 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3747
3748 The "reloc ()" notation is supposed to indicate that the linker emits
3749 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3750 copying.
3751
3752 What are the difficulties here? Well, firstly, the relocations
3753 examined by the linker in check_relocs are against the function code
3754 sym .foo, while the dynamic relocation in the plt is emitted against
3755 the function descriptor symbol, foo. Somewhere along the line, we need
3756 to carefully copy dynamic link information from one symbol to the other.
3757 Secondly, the generic part of the elf linker will make .foo a dynamic
3758 symbol as is normal for most other backends. We need foo dynamic
3759 instead, at least for an application final link. However, when
3760 creating a shared library containing foo, we need to have both symbols
3761 dynamic so that references to .foo are satisfied during the early
3762 stages of linking. Otherwise the linker might decide to pull in a
3763 definition from some other object, eg. a static library.
3764
3765 Update: As of August 2004, we support a new convention. Function
3766 calls may use the function descriptor symbol, ie. "bl foo". This
3767 behaves exactly as "bl .foo". */
3768
3769 /* Of those relocs that might be copied as dynamic relocs, this function
3770 selects those that must be copied when linking a shared library,
3771 even when the symbol is local. */
3772
3773 static int
3774 must_be_dyn_reloc (struct bfd_link_info *info,
3775 enum elf_ppc64_reloc_type r_type)
3776 {
3777 switch (r_type)
3778 {
3779 default:
3780 return 1;
3781
3782 case R_PPC64_REL32:
3783 case R_PPC64_REL64:
3784 case R_PPC64_REL30:
3785 return 0;
3786
3787 case R_PPC64_TPREL16:
3788 case R_PPC64_TPREL16_LO:
3789 case R_PPC64_TPREL16_HI:
3790 case R_PPC64_TPREL16_HA:
3791 case R_PPC64_TPREL16_DS:
3792 case R_PPC64_TPREL16_LO_DS:
3793 case R_PPC64_TPREL16_HIGH:
3794 case R_PPC64_TPREL16_HIGHA:
3795 case R_PPC64_TPREL16_HIGHER:
3796 case R_PPC64_TPREL16_HIGHERA:
3797 case R_PPC64_TPREL16_HIGHEST:
3798 case R_PPC64_TPREL16_HIGHESTA:
3799 case R_PPC64_TPREL64:
3800 return !bfd_link_executable (info);
3801 }
3802 }
3803
3804 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3805 copying dynamic variables from a shared lib into an app's dynbss
3806 section, and instead use a dynamic relocation to point into the
3807 shared lib. With code that gcc generates, it's vital that this be
3808 enabled; In the PowerPC64 ABI, the address of a function is actually
3809 the address of a function descriptor, which resides in the .opd
3810 section. gcc uses the descriptor directly rather than going via the
3811 GOT as some other ABI's do, which means that initialized function
3812 pointers must reference the descriptor. Thus, a function pointer
3813 initialized to the address of a function in a shared library will
3814 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3815 redefines the function descriptor symbol to point to the copy. This
3816 presents a problem as a plt entry for that function is also
3817 initialized from the function descriptor symbol and the copy reloc
3818 may not be initialized first. */
3819 #define ELIMINATE_COPY_RELOCS 1
3820
3821 /* Section name for stubs is the associated section name plus this
3822 string. */
3823 #define STUB_SUFFIX ".stub"
3824
3825 /* Linker stubs.
3826 ppc_stub_long_branch:
3827 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3828 destination, but a 24 bit branch in a stub section will reach.
3829 . b dest
3830
3831 ppc_stub_plt_branch:
3832 Similar to the above, but a 24 bit branch in the stub section won't
3833 reach its destination.
3834 . addis %r11,%r2,xxx@toc@ha
3835 . ld %r12,xxx@toc@l(%r11)
3836 . mtctr %r12
3837 . bctr
3838
3839 ppc_stub_plt_call:
3840 Used to call a function in a shared library. If it so happens that
3841 the plt entry referenced crosses a 64k boundary, then an extra
3842 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3843 . std %r2,40(%r1)
3844 . addis %r11,%r2,xxx@toc@ha
3845 . ld %r12,xxx+0@toc@l(%r11)
3846 . mtctr %r12
3847 . ld %r2,xxx+8@toc@l(%r11)
3848 . ld %r11,xxx+16@toc@l(%r11)
3849 . bctr
3850
3851 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3852 code to adjust the value and save r2 to support multiple toc sections.
3853 A ppc_stub_long_branch with an r2 offset looks like:
3854 . std %r2,40(%r1)
3855 . addis %r2,%r2,off@ha
3856 . addi %r2,%r2,off@l
3857 . b dest
3858
3859 A ppc_stub_plt_branch with an r2 offset looks like:
3860 . std %r2,40(%r1)
3861 . addis %r11,%r2,xxx@toc@ha
3862 . ld %r12,xxx@toc@l(%r11)
3863 . addis %r2,%r2,off@ha
3864 . addi %r2,%r2,off@l
3865 . mtctr %r12
3866 . bctr
3867
3868 In cases where the "addis" instruction would add zero, the "addis" is
3869 omitted and following instructions modified slightly in some cases.
3870 */
3871
3872 enum ppc_stub_type {
3873 ppc_stub_none,
3874 ppc_stub_long_branch,
3875 ppc_stub_long_branch_r2off,
3876 ppc_stub_plt_branch,
3877 ppc_stub_plt_branch_r2off,
3878 ppc_stub_plt_call,
3879 ppc_stub_plt_call_r2save,
3880 ppc_stub_global_entry,
3881 ppc_stub_save_res
3882 };
3883
3884 /* Information on stub grouping. */
3885 struct map_stub
3886 {
3887 /* The stub section. */
3888 asection *stub_sec;
3889 /* This is the section to which stubs in the group will be attached. */
3890 asection *link_sec;
3891 /* Next group. */
3892 struct map_stub *next;
3893 /* Whether to emit a copy of register save/restore functions in this
3894 group. */
3895 int needs_save_res;
3896 };
3897
3898 struct ppc_stub_hash_entry {
3899
3900 /* Base hash table entry structure. */
3901 struct bfd_hash_entry root;
3902
3903 enum ppc_stub_type stub_type;
3904
3905 /* Group information. */
3906 struct map_stub *group;
3907
3908 /* Offset within stub_sec of the beginning of this stub. */
3909 bfd_vma stub_offset;
3910
3911 /* Given the symbol's value and its section we can determine its final
3912 value when building the stubs (so the stub knows where to jump. */
3913 bfd_vma target_value;
3914 asection *target_section;
3915
3916 /* The symbol table entry, if any, that this was derived from. */
3917 struct ppc_link_hash_entry *h;
3918 struct plt_entry *plt_ent;
3919
3920 /* Symbol st_other. */
3921 unsigned char other;
3922 };
3923
3924 struct ppc_branch_hash_entry {
3925
3926 /* Base hash table entry structure. */
3927 struct bfd_hash_entry root;
3928
3929 /* Offset within branch lookup table. */
3930 unsigned int offset;
3931
3932 /* Generation marker. */
3933 unsigned int iter;
3934 };
3935
3936 /* Used to track dynamic relocations for local symbols. */
3937 struct ppc_dyn_relocs
3938 {
3939 struct ppc_dyn_relocs *next;
3940
3941 /* The input section of the reloc. */
3942 asection *sec;
3943
3944 /* Total number of relocs copied for the input section. */
3945 unsigned int count : 31;
3946
3947 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3948 unsigned int ifunc : 1;
3949 };
3950
3951 struct ppc_link_hash_entry
3952 {
3953 struct elf_link_hash_entry elf;
3954
3955 union {
3956 /* A pointer to the most recently used stub hash entry against this
3957 symbol. */
3958 struct ppc_stub_hash_entry *stub_cache;
3959
3960 /* A pointer to the next symbol starting with a '.' */
3961 struct ppc_link_hash_entry *next_dot_sym;
3962 } u;
3963
3964 /* Track dynamic relocs copied for this symbol. */
3965 struct elf_dyn_relocs *dyn_relocs;
3966
3967 /* Chain of aliases referring to a weakdef. */
3968 struct ppc_link_hash_entry *weakref;
3969
3970 /* Link between function code and descriptor symbols. */
3971 struct ppc_link_hash_entry *oh;
3972
3973 /* Flag function code and descriptor symbols. */
3974 unsigned int is_func:1;
3975 unsigned int is_func_descriptor:1;
3976 unsigned int fake:1;
3977
3978 /* Whether global opd/toc sym has been adjusted or not.
3979 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3980 should be set for all globals defined in any opd/toc section. */
3981 unsigned int adjust_done:1;
3982
3983 /* Set if this is an out-of-line register save/restore function,
3984 with non-standard calling convention. */
3985 unsigned int save_res:1;
3986
3987 /* Contexts in which symbol is used in the GOT (or TOC).
3988 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3989 corresponding relocs are encountered during check_relocs.
3990 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3991 indicate the corresponding GOT entry type is not needed.
3992 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3993 a TPREL one. We use a separate flag rather than setting TPREL
3994 just for convenience in distinguishing the two cases. */
3995 #define TLS_GD 1 /* GD reloc. */
3996 #define TLS_LD 2 /* LD reloc. */
3997 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3998 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3999 #define TLS_TLS 16 /* Any TLS reloc. */
4000 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4001 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4002 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4003 unsigned char tls_mask;
4004 };
4005
4006 /* ppc64 ELF linker hash table. */
4007
4008 struct ppc_link_hash_table
4009 {
4010 struct elf_link_hash_table elf;
4011
4012 /* The stub hash table. */
4013 struct bfd_hash_table stub_hash_table;
4014
4015 /* Another hash table for plt_branch stubs. */
4016 struct bfd_hash_table branch_hash_table;
4017
4018 /* Hash table for function prologue tocsave. */
4019 htab_t tocsave_htab;
4020
4021 /* Various options and other info passed from the linker. */
4022 struct ppc64_elf_params *params;
4023
4024 /* The size of sec_info below. */
4025 unsigned int sec_info_arr_size;
4026
4027 /* Per-section array of extra section info. Done this way rather
4028 than as part of ppc64_elf_section_data so we have the info for
4029 non-ppc64 sections. */
4030 struct
4031 {
4032 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4033 bfd_vma toc_off;
4034
4035 union
4036 {
4037 /* The section group that this section belongs to. */
4038 struct map_stub *group;
4039 /* A temp section list pointer. */
4040 asection *list;
4041 } u;
4042 } *sec_info;
4043
4044 /* Linked list of groups. */
4045 struct map_stub *group;
4046
4047 /* Temp used when calculating TOC pointers. */
4048 bfd_vma toc_curr;
4049 bfd *toc_bfd;
4050 asection *toc_first_sec;
4051
4052 /* Used when adding symbols. */
4053 struct ppc_link_hash_entry *dot_syms;
4054
4055 /* Shortcuts to get to dynamic linker sections. */
4056 asection *glink;
4057 asection *sfpr;
4058 asection *brlt;
4059 asection *relbrlt;
4060 asection *glink_eh_frame;
4061
4062 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4063 struct ppc_link_hash_entry *tls_get_addr;
4064 struct ppc_link_hash_entry *tls_get_addr_fd;
4065
4066 /* The size of reliplt used by got entry relocs. */
4067 bfd_size_type got_reli_size;
4068
4069 /* Statistics. */
4070 unsigned long stub_count[ppc_stub_global_entry];
4071
4072 /* Number of stubs against global syms. */
4073 unsigned long stub_globals;
4074
4075 /* Set if we're linking code with function descriptors. */
4076 unsigned int opd_abi:1;
4077
4078 /* Support for multiple toc sections. */
4079 unsigned int do_multi_toc:1;
4080 unsigned int multi_toc_needed:1;
4081 unsigned int second_toc_pass:1;
4082 unsigned int do_toc_opt:1;
4083
4084 /* Set on error. */
4085 unsigned int stub_error:1;
4086
4087 /* Whether func_desc_adjust needs to be run over symbols. */
4088 unsigned int need_func_desc_adj:1;
4089
4090 /* Incremented every time we size stubs. */
4091 unsigned int stub_iteration;
4092
4093 /* Small local sym cache. */
4094 struct sym_cache sym_cache;
4095 };
4096
4097 /* Rename some of the generic section flags to better document how they
4098 are used here. */
4099
4100 /* Nonzero if this section has TLS related relocations. */
4101 #define has_tls_reloc sec_flg0
4102
4103 /* Nonzero if this section has a call to __tls_get_addr. */
4104 #define has_tls_get_addr_call sec_flg1
4105
4106 /* Nonzero if this section has any toc or got relocs. */
4107 #define has_toc_reloc sec_flg2
4108
4109 /* Nonzero if this section has a call to another section that uses
4110 the toc or got. */
4111 #define makes_toc_func_call sec_flg3
4112
4113 /* Recursion protection when determining above flag. */
4114 #define call_check_in_progress sec_flg4
4115 #define call_check_done sec_flg5
4116
4117 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4118
4119 #define ppc_hash_table(p) \
4120 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4121 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4122
4123 #define ppc_stub_hash_lookup(table, string, create, copy) \
4124 ((struct ppc_stub_hash_entry *) \
4125 bfd_hash_lookup ((table), (string), (create), (copy)))
4126
4127 #define ppc_branch_hash_lookup(table, string, create, copy) \
4128 ((struct ppc_branch_hash_entry *) \
4129 bfd_hash_lookup ((table), (string), (create), (copy)))
4130
4131 /* Create an entry in the stub hash table. */
4132
4133 static struct bfd_hash_entry *
4134 stub_hash_newfunc (struct bfd_hash_entry *entry,
4135 struct bfd_hash_table *table,
4136 const char *string)
4137 {
4138 /* Allocate the structure if it has not already been allocated by a
4139 subclass. */
4140 if (entry == NULL)
4141 {
4142 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4143 if (entry == NULL)
4144 return entry;
4145 }
4146
4147 /* Call the allocation method of the superclass. */
4148 entry = bfd_hash_newfunc (entry, table, string);
4149 if (entry != NULL)
4150 {
4151 struct ppc_stub_hash_entry *eh;
4152
4153 /* Initialize the local fields. */
4154 eh = (struct ppc_stub_hash_entry *) entry;
4155 eh->stub_type = ppc_stub_none;
4156 eh->group = NULL;
4157 eh->stub_offset = 0;
4158 eh->target_value = 0;
4159 eh->target_section = NULL;
4160 eh->h = NULL;
4161 eh->plt_ent = NULL;
4162 eh->other = 0;
4163 }
4164
4165 return entry;
4166 }
4167
4168 /* Create an entry in the branch hash table. */
4169
4170 static struct bfd_hash_entry *
4171 branch_hash_newfunc (struct bfd_hash_entry *entry,
4172 struct bfd_hash_table *table,
4173 const char *string)
4174 {
4175 /* Allocate the structure if it has not already been allocated by a
4176 subclass. */
4177 if (entry == NULL)
4178 {
4179 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4180 if (entry == NULL)
4181 return entry;
4182 }
4183
4184 /* Call the allocation method of the superclass. */
4185 entry = bfd_hash_newfunc (entry, table, string);
4186 if (entry != NULL)
4187 {
4188 struct ppc_branch_hash_entry *eh;
4189
4190 /* Initialize the local fields. */
4191 eh = (struct ppc_branch_hash_entry *) entry;
4192 eh->offset = 0;
4193 eh->iter = 0;
4194 }
4195
4196 return entry;
4197 }
4198
4199 /* Create an entry in a ppc64 ELF linker hash table. */
4200
4201 static struct bfd_hash_entry *
4202 link_hash_newfunc (struct bfd_hash_entry *entry,
4203 struct bfd_hash_table *table,
4204 const char *string)
4205 {
4206 /* Allocate the structure if it has not already been allocated by a
4207 subclass. */
4208 if (entry == NULL)
4209 {
4210 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4211 if (entry == NULL)
4212 return entry;
4213 }
4214
4215 /* Call the allocation method of the superclass. */
4216 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4217 if (entry != NULL)
4218 {
4219 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4220
4221 memset (&eh->u.stub_cache, 0,
4222 (sizeof (struct ppc_link_hash_entry)
4223 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4224
4225 /* When making function calls, old ABI code references function entry
4226 points (dot symbols), while new ABI code references the function
4227 descriptor symbol. We need to make any combination of reference and
4228 definition work together, without breaking archive linking.
4229
4230 For a defined function "foo" and an undefined call to "bar":
4231 An old object defines "foo" and ".foo", references ".bar" (possibly
4232 "bar" too).
4233 A new object defines "foo" and references "bar".
4234
4235 A new object thus has no problem with its undefined symbols being
4236 satisfied by definitions in an old object. On the other hand, the
4237 old object won't have ".bar" satisfied by a new object.
4238
4239 Keep a list of newly added dot-symbols. */
4240
4241 if (string[0] == '.')
4242 {
4243 struct ppc_link_hash_table *htab;
4244
4245 htab = (struct ppc_link_hash_table *) table;
4246 eh->u.next_dot_sym = htab->dot_syms;
4247 htab->dot_syms = eh;
4248 }
4249 }
4250
4251 return entry;
4252 }
4253
4254 struct tocsave_entry {
4255 asection *sec;
4256 bfd_vma offset;
4257 };
4258
4259 static hashval_t
4260 tocsave_htab_hash (const void *p)
4261 {
4262 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4263 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4264 }
4265
4266 static int
4267 tocsave_htab_eq (const void *p1, const void *p2)
4268 {
4269 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4270 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4271 return e1->sec == e2->sec && e1->offset == e2->offset;
4272 }
4273
4274 /* Destroy a ppc64 ELF linker hash table. */
4275
4276 static void
4277 ppc64_elf_link_hash_table_free (bfd *obfd)
4278 {
4279 struct ppc_link_hash_table *htab;
4280
4281 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4282 if (htab->tocsave_htab)
4283 htab_delete (htab->tocsave_htab);
4284 bfd_hash_table_free (&htab->branch_hash_table);
4285 bfd_hash_table_free (&htab->stub_hash_table);
4286 _bfd_elf_link_hash_table_free (obfd);
4287 }
4288
4289 /* Create a ppc64 ELF linker hash table. */
4290
4291 static struct bfd_link_hash_table *
4292 ppc64_elf_link_hash_table_create (bfd *abfd)
4293 {
4294 struct ppc_link_hash_table *htab;
4295 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4296
4297 htab = bfd_zmalloc (amt);
4298 if (htab == NULL)
4299 return NULL;
4300
4301 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4302 sizeof (struct ppc_link_hash_entry),
4303 PPC64_ELF_DATA))
4304 {
4305 free (htab);
4306 return NULL;
4307 }
4308
4309 /* Init the stub hash table too. */
4310 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4311 sizeof (struct ppc_stub_hash_entry)))
4312 {
4313 _bfd_elf_link_hash_table_free (abfd);
4314 return NULL;
4315 }
4316
4317 /* And the branch hash table. */
4318 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4319 sizeof (struct ppc_branch_hash_entry)))
4320 {
4321 bfd_hash_table_free (&htab->stub_hash_table);
4322 _bfd_elf_link_hash_table_free (abfd);
4323 return NULL;
4324 }
4325
4326 htab->tocsave_htab = htab_try_create (1024,
4327 tocsave_htab_hash,
4328 tocsave_htab_eq,
4329 NULL);
4330 if (htab->tocsave_htab == NULL)
4331 {
4332 ppc64_elf_link_hash_table_free (abfd);
4333 return NULL;
4334 }
4335 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4336
4337 /* Initializing two fields of the union is just cosmetic. We really
4338 only care about glist, but when compiled on a 32-bit host the
4339 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4340 debugger inspection of these fields look nicer. */
4341 htab->elf.init_got_refcount.refcount = 0;
4342 htab->elf.init_got_refcount.glist = NULL;
4343 htab->elf.init_plt_refcount.refcount = 0;
4344 htab->elf.init_plt_refcount.glist = NULL;
4345 htab->elf.init_got_offset.offset = 0;
4346 htab->elf.init_got_offset.glist = NULL;
4347 htab->elf.init_plt_offset.offset = 0;
4348 htab->elf.init_plt_offset.glist = NULL;
4349
4350 return &htab->elf.root;
4351 }
4352
4353 /* Create sections for linker generated code. */
4354
4355 static bfd_boolean
4356 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4357 {
4358 struct ppc_link_hash_table *htab;
4359 flagword flags;
4360
4361 htab = ppc_hash_table (info);
4362
4363 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4364 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4365 if (htab->params->save_restore_funcs)
4366 {
4367 /* Create .sfpr for code to save and restore fp regs. */
4368 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4369 flags);
4370 if (htab->sfpr == NULL
4371 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4372 return FALSE;
4373 }
4374
4375 if (bfd_link_relocatable (info))
4376 return TRUE;
4377
4378 /* Create .glink for lazy dynamic linking support. */
4379 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4380 flags);
4381 if (htab->glink == NULL
4382 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4383 return FALSE;
4384
4385 if (!info->no_ld_generated_unwind_info)
4386 {
4387 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4388 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4389 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4390 ".eh_frame",
4391 flags);
4392 if (htab->glink_eh_frame == NULL
4393 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4394 return FALSE;
4395 }
4396
4397 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4398 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4399 if (htab->elf.iplt == NULL
4400 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4401 return FALSE;
4402
4403 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4404 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4405 htab->elf.irelplt
4406 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4407 if (htab->elf.irelplt == NULL
4408 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4409 return FALSE;
4410
4411 /* Create branch lookup table for plt_branch stubs. */
4412 flags = (SEC_ALLOC | SEC_LOAD
4413 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4414 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4415 flags);
4416 if (htab->brlt == NULL
4417 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4418 return FALSE;
4419
4420 if (!bfd_link_pic (info))
4421 return TRUE;
4422
4423 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4424 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4425 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4426 ".rela.branch_lt",
4427 flags);
4428 if (htab->relbrlt == NULL
4429 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4430 return FALSE;
4431
4432 return TRUE;
4433 }
4434
4435 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4436
4437 bfd_boolean
4438 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4439 struct ppc64_elf_params *params)
4440 {
4441 struct ppc_link_hash_table *htab;
4442
4443 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4444
4445 /* Always hook our dynamic sections into the first bfd, which is the
4446 linker created stub bfd. This ensures that the GOT header is at
4447 the start of the output TOC section. */
4448 htab = ppc_hash_table (info);
4449 htab->elf.dynobj = params->stub_bfd;
4450 htab->params = params;
4451
4452 return create_linkage_sections (htab->elf.dynobj, info);
4453 }
4454
4455 /* Build a name for an entry in the stub hash table. */
4456
4457 static char *
4458 ppc_stub_name (const asection *input_section,
4459 const asection *sym_sec,
4460 const struct ppc_link_hash_entry *h,
4461 const Elf_Internal_Rela *rel)
4462 {
4463 char *stub_name;
4464 ssize_t len;
4465
4466 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4467 offsets from a sym as a branch target? In fact, we could
4468 probably assume the addend is always zero. */
4469 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4470
4471 if (h)
4472 {
4473 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4474 stub_name = bfd_malloc (len);
4475 if (stub_name == NULL)
4476 return stub_name;
4477
4478 len = sprintf (stub_name, "%08x.%s+%x",
4479 input_section->id & 0xffffffff,
4480 h->elf.root.root.string,
4481 (int) rel->r_addend & 0xffffffff);
4482 }
4483 else
4484 {
4485 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4486 stub_name = bfd_malloc (len);
4487 if (stub_name == NULL)
4488 return stub_name;
4489
4490 len = sprintf (stub_name, "%08x.%x:%x+%x",
4491 input_section->id & 0xffffffff,
4492 sym_sec->id & 0xffffffff,
4493 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4494 (int) rel->r_addend & 0xffffffff);
4495 }
4496 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4497 stub_name[len - 2] = 0;
4498 return stub_name;
4499 }
4500
4501 /* Look up an entry in the stub hash. Stub entries are cached because
4502 creating the stub name takes a bit of time. */
4503
4504 static struct ppc_stub_hash_entry *
4505 ppc_get_stub_entry (const asection *input_section,
4506 const asection *sym_sec,
4507 struct ppc_link_hash_entry *h,
4508 const Elf_Internal_Rela *rel,
4509 struct ppc_link_hash_table *htab)
4510 {
4511 struct ppc_stub_hash_entry *stub_entry;
4512 struct map_stub *group;
4513
4514 /* If this input section is part of a group of sections sharing one
4515 stub section, then use the id of the first section in the group.
4516 Stub names need to include a section id, as there may well be
4517 more than one stub used to reach say, printf, and we need to
4518 distinguish between them. */
4519 group = htab->sec_info[input_section->id].u.group;
4520 if (group == NULL)
4521 return NULL;
4522
4523 if (h != NULL && h->u.stub_cache != NULL
4524 && h->u.stub_cache->h == h
4525 && h->u.stub_cache->group == group)
4526 {
4527 stub_entry = h->u.stub_cache;
4528 }
4529 else
4530 {
4531 char *stub_name;
4532
4533 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4534 if (stub_name == NULL)
4535 return NULL;
4536
4537 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4538 stub_name, FALSE, FALSE);
4539 if (h != NULL)
4540 h->u.stub_cache = stub_entry;
4541
4542 free (stub_name);
4543 }
4544
4545 return stub_entry;
4546 }
4547
4548 /* Add a new stub entry to the stub hash. Not all fields of the new
4549 stub entry are initialised. */
4550
4551 static struct ppc_stub_hash_entry *
4552 ppc_add_stub (const char *stub_name,
4553 asection *section,
4554 struct bfd_link_info *info)
4555 {
4556 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4557 struct map_stub *group;
4558 asection *link_sec;
4559 asection *stub_sec;
4560 struct ppc_stub_hash_entry *stub_entry;
4561
4562 group = htab->sec_info[section->id].u.group;
4563 link_sec = group->link_sec;
4564 stub_sec = group->stub_sec;
4565 if (stub_sec == NULL)
4566 {
4567 size_t namelen;
4568 bfd_size_type len;
4569 char *s_name;
4570
4571 namelen = strlen (link_sec->name);
4572 len = namelen + sizeof (STUB_SUFFIX);
4573 s_name = bfd_alloc (htab->params->stub_bfd, len);
4574 if (s_name == NULL)
4575 return NULL;
4576
4577 memcpy (s_name, link_sec->name, namelen);
4578 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4579 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4580 if (stub_sec == NULL)
4581 return NULL;
4582 group->stub_sec = stub_sec;
4583 }
4584
4585 /* Enter this entry into the linker stub hash table. */
4586 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4587 TRUE, FALSE);
4588 if (stub_entry == NULL)
4589 {
4590 /* xgettext:c-format */
4591 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4592 section->owner, stub_name);
4593 return NULL;
4594 }
4595
4596 stub_entry->group = group;
4597 stub_entry->stub_offset = 0;
4598 return stub_entry;
4599 }
4600
4601 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4602 not already done. */
4603
4604 static bfd_boolean
4605 create_got_section (bfd *abfd, struct bfd_link_info *info)
4606 {
4607 asection *got, *relgot;
4608 flagword flags;
4609 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4610
4611 if (!is_ppc64_elf (abfd))
4612 return FALSE;
4613 if (htab == NULL)
4614 return FALSE;
4615
4616 if (!htab->elf.sgot
4617 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4618 return FALSE;
4619
4620 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4621 | SEC_LINKER_CREATED);
4622
4623 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4624 if (!got
4625 || !bfd_set_section_alignment (abfd, got, 3))
4626 return FALSE;
4627
4628 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4629 flags | SEC_READONLY);
4630 if (!relgot
4631 || ! bfd_set_section_alignment (abfd, relgot, 3))
4632 return FALSE;
4633
4634 ppc64_elf_tdata (abfd)->got = got;
4635 ppc64_elf_tdata (abfd)->relgot = relgot;
4636 return TRUE;
4637 }
4638
4639 /* Follow indirect and warning symbol links. */
4640
4641 static inline struct bfd_link_hash_entry *
4642 follow_link (struct bfd_link_hash_entry *h)
4643 {
4644 while (h->type == bfd_link_hash_indirect
4645 || h->type == bfd_link_hash_warning)
4646 h = h->u.i.link;
4647 return h;
4648 }
4649
4650 static inline struct elf_link_hash_entry *
4651 elf_follow_link (struct elf_link_hash_entry *h)
4652 {
4653 return (struct elf_link_hash_entry *) follow_link (&h->root);
4654 }
4655
4656 static inline struct ppc_link_hash_entry *
4657 ppc_follow_link (struct ppc_link_hash_entry *h)
4658 {
4659 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4660 }
4661
4662 /* Merge PLT info on FROM with that on TO. */
4663
4664 static void
4665 move_plt_plist (struct ppc_link_hash_entry *from,
4666 struct ppc_link_hash_entry *to)
4667 {
4668 if (from->elf.plt.plist != NULL)
4669 {
4670 if (to->elf.plt.plist != NULL)
4671 {
4672 struct plt_entry **entp;
4673 struct plt_entry *ent;
4674
4675 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4676 {
4677 struct plt_entry *dent;
4678
4679 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4680 if (dent->addend == ent->addend)
4681 {
4682 dent->plt.refcount += ent->plt.refcount;
4683 *entp = ent->next;
4684 break;
4685 }
4686 if (dent == NULL)
4687 entp = &ent->next;
4688 }
4689 *entp = to->elf.plt.plist;
4690 }
4691
4692 to->elf.plt.plist = from->elf.plt.plist;
4693 from->elf.plt.plist = NULL;
4694 }
4695 }
4696
4697 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4698
4699 static void
4700 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4701 struct elf_link_hash_entry *dir,
4702 struct elf_link_hash_entry *ind)
4703 {
4704 struct ppc_link_hash_entry *edir, *eind;
4705
4706 edir = (struct ppc_link_hash_entry *) dir;
4707 eind = (struct ppc_link_hash_entry *) ind;
4708
4709 edir->is_func |= eind->is_func;
4710 edir->is_func_descriptor |= eind->is_func_descriptor;
4711 edir->tls_mask |= eind->tls_mask;
4712 if (eind->oh != NULL)
4713 edir->oh = ppc_follow_link (eind->oh);
4714
4715 if (edir->elf.versioned != versioned_hidden)
4716 {
4717 /* If called to transfer flags for a weakdef during processing
4718 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4719 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4720 if (!(ELIMINATE_COPY_RELOCS
4721 && eind->elf.root.type != bfd_link_hash_indirect
4722 && edir->elf.dynamic_adjusted))
4723 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4724
4725 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4726 edir->elf.ref_regular |= eind->elf.ref_regular;
4727 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4728 edir->elf.needs_plt |= eind->elf.needs_plt;
4729 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4730 }
4731
4732 /* If we were called to copy over info for a weak sym, don't copy
4733 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4734 in order to simplify readonly_dynrelocs and save a field in the
4735 symbol hash entry, but that means dyn_relocs can't be used in any
4736 tests about a specific symbol, or affect other symbol flags which
4737 are then tested.
4738 Chain weakdefs so we can get from the weakdef back to an alias.
4739 The list is circular so that we don't need to use u.weakdef as
4740 well as this list to look at all aliases. */
4741 if (eind->elf.root.type != bfd_link_hash_indirect)
4742 {
4743 struct ppc_link_hash_entry *cur, *add, *next;
4744
4745 add = eind;
4746 do
4747 {
4748 cur = edir->weakref;
4749 if (cur != NULL)
4750 {
4751 do
4752 {
4753 /* We can be called twice for the same symbols.
4754 Don't make multiple loops. */
4755 if (cur == add)
4756 return;
4757 cur = cur->weakref;
4758 } while (cur != edir);
4759 }
4760 next = add->weakref;
4761 if (cur != add)
4762 {
4763 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4764 edir->weakref = add;
4765 }
4766 add = next;
4767 } while (add != NULL && add != eind);
4768 return;
4769 }
4770
4771 /* Copy over any dynamic relocs we may have on the indirect sym. */
4772 if (eind->dyn_relocs != NULL)
4773 {
4774 if (edir->dyn_relocs != NULL)
4775 {
4776 struct elf_dyn_relocs **pp;
4777 struct elf_dyn_relocs *p;
4778
4779 /* Add reloc counts against the indirect sym to the direct sym
4780 list. Merge any entries against the same section. */
4781 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4782 {
4783 struct elf_dyn_relocs *q;
4784
4785 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4786 if (q->sec == p->sec)
4787 {
4788 q->pc_count += p->pc_count;
4789 q->count += p->count;
4790 *pp = p->next;
4791 break;
4792 }
4793 if (q == NULL)
4794 pp = &p->next;
4795 }
4796 *pp = edir->dyn_relocs;
4797 }
4798
4799 edir->dyn_relocs = eind->dyn_relocs;
4800 eind->dyn_relocs = NULL;
4801 }
4802
4803 /* Copy over got entries that we may have already seen to the
4804 symbol which just became indirect. */
4805 if (eind->elf.got.glist != NULL)
4806 {
4807 if (edir->elf.got.glist != NULL)
4808 {
4809 struct got_entry **entp;
4810 struct got_entry *ent;
4811
4812 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4813 {
4814 struct got_entry *dent;
4815
4816 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4817 if (dent->addend == ent->addend
4818 && dent->owner == ent->owner
4819 && dent->tls_type == ent->tls_type)
4820 {
4821 dent->got.refcount += ent->got.refcount;
4822 *entp = ent->next;
4823 break;
4824 }
4825 if (dent == NULL)
4826 entp = &ent->next;
4827 }
4828 *entp = edir->elf.got.glist;
4829 }
4830
4831 edir->elf.got.glist = eind->elf.got.glist;
4832 eind->elf.got.glist = NULL;
4833 }
4834
4835 /* And plt entries. */
4836 move_plt_plist (eind, edir);
4837
4838 if (eind->elf.dynindx != -1)
4839 {
4840 if (edir->elf.dynindx != -1)
4841 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4842 edir->elf.dynstr_index);
4843 edir->elf.dynindx = eind->elf.dynindx;
4844 edir->elf.dynstr_index = eind->elf.dynstr_index;
4845 eind->elf.dynindx = -1;
4846 eind->elf.dynstr_index = 0;
4847 }
4848 }
4849
4850 /* Find the function descriptor hash entry from the given function code
4851 hash entry FH. Link the entries via their OH fields. */
4852
4853 static struct ppc_link_hash_entry *
4854 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4855 {
4856 struct ppc_link_hash_entry *fdh = fh->oh;
4857
4858 if (fdh == NULL)
4859 {
4860 const char *fd_name = fh->elf.root.root.string + 1;
4861
4862 fdh = (struct ppc_link_hash_entry *)
4863 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4864 if (fdh == NULL)
4865 return fdh;
4866
4867 fdh->is_func_descriptor = 1;
4868 fdh->oh = fh;
4869 fh->is_func = 1;
4870 fh->oh = fdh;
4871 }
4872
4873 fdh = ppc_follow_link (fdh);
4874 fdh->is_func_descriptor = 1;
4875 fdh->oh = fh;
4876 return fdh;
4877 }
4878
4879 /* Make a fake function descriptor sym for the undefined code sym FH. */
4880
4881 static struct ppc_link_hash_entry *
4882 make_fdh (struct bfd_link_info *info,
4883 struct ppc_link_hash_entry *fh)
4884 {
4885 bfd *abfd = fh->elf.root.u.undef.abfd;
4886 struct bfd_link_hash_entry *bh = NULL;
4887 struct ppc_link_hash_entry *fdh;
4888 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4889 ? BSF_WEAK
4890 : BSF_GLOBAL);
4891
4892 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4893 fh->elf.root.root.string + 1,
4894 flags, bfd_und_section_ptr, 0,
4895 NULL, FALSE, FALSE, &bh))
4896 return NULL;
4897
4898 fdh = (struct ppc_link_hash_entry *) bh;
4899 fdh->elf.non_elf = 0;
4900 fdh->fake = 1;
4901 fdh->is_func_descriptor = 1;
4902 fdh->oh = fh;
4903 fh->is_func = 1;
4904 fh->oh = fdh;
4905 return fdh;
4906 }
4907
4908 /* Fix function descriptor symbols defined in .opd sections to be
4909 function type. */
4910
4911 static bfd_boolean
4912 ppc64_elf_add_symbol_hook (bfd *ibfd,
4913 struct bfd_link_info *info,
4914 Elf_Internal_Sym *isym,
4915 const char **name,
4916 flagword *flags ATTRIBUTE_UNUSED,
4917 asection **sec,
4918 bfd_vma *value)
4919 {
4920 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4921 && (ibfd->flags & DYNAMIC) == 0
4922 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4923 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4924
4925 if (*sec != NULL
4926 && strcmp ((*sec)->name, ".opd") == 0)
4927 {
4928 asection *code_sec;
4929
4930 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4931 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4932 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4933
4934 /* If the symbol is a function defined in .opd, and the function
4935 code is in a discarded group, let it appear to be undefined. */
4936 if (!bfd_link_relocatable (info)
4937 && (*sec)->reloc_count != 0
4938 && opd_entry_value (*sec, *value, &code_sec, NULL,
4939 FALSE) != (bfd_vma) -1
4940 && discarded_section (code_sec))
4941 {
4942 *sec = bfd_und_section_ptr;
4943 isym->st_shndx = SHN_UNDEF;
4944 }
4945 }
4946 else if (*sec != NULL
4947 && strcmp ((*sec)->name, ".toc") == 0
4948 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4949 {
4950 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4951 if (htab != NULL)
4952 htab->params->object_in_toc = 1;
4953 }
4954
4955 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4956 {
4957 if (abiversion (ibfd) == 0)
4958 set_abiversion (ibfd, 2);
4959 else if (abiversion (ibfd) == 1)
4960 {
4961 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4962 " for ABI version 1\n"), name);
4963 bfd_set_error (bfd_error_bad_value);
4964 return FALSE;
4965 }
4966 }
4967
4968 return TRUE;
4969 }
4970
4971 /* Merge non-visibility st_other attributes: local entry point. */
4972
4973 static void
4974 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4975 const Elf_Internal_Sym *isym,
4976 bfd_boolean definition,
4977 bfd_boolean dynamic)
4978 {
4979 if (definition && !dynamic)
4980 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4981 | ELF_ST_VISIBILITY (h->other));
4982 }
4983
4984 /* Hook called on merging a symbol. We use this to clear "fake" since
4985 we now have a real symbol. */
4986
4987 static bfd_boolean
4988 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
4989 const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
4990 asection **psec ATTRIBUTE_UNUSED,
4991 bfd_boolean newdef ATTRIBUTE_UNUSED,
4992 bfd_boolean olddef ATTRIBUTE_UNUSED,
4993 bfd *oldbfd ATTRIBUTE_UNUSED,
4994 const asection *oldsec ATTRIBUTE_UNUSED)
4995 {
4996 ((struct ppc_link_hash_entry *) h)->fake = 0;
4997 return TRUE;
4998 }
4999
5000 /* This function makes an old ABI object reference to ".bar" cause the
5001 inclusion of a new ABI object archive that defines "bar".
5002 NAME is a symbol defined in an archive. Return a symbol in the hash
5003 table that might be satisfied by the archive symbols. */
5004
5005 static struct elf_link_hash_entry *
5006 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5007 struct bfd_link_info *info,
5008 const char *name)
5009 {
5010 struct elf_link_hash_entry *h;
5011 char *dot_name;
5012 size_t len;
5013
5014 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5015 if (h != NULL
5016 /* Don't return this sym if it is a fake function descriptor
5017 created by add_symbol_adjust. */
5018 && !((struct ppc_link_hash_entry *) h)->fake)
5019 return h;
5020
5021 if (name[0] == '.')
5022 return h;
5023
5024 len = strlen (name);
5025 dot_name = bfd_alloc (abfd, len + 2);
5026 if (dot_name == NULL)
5027 return (struct elf_link_hash_entry *) 0 - 1;
5028 dot_name[0] = '.';
5029 memcpy (dot_name + 1, name, len + 1);
5030 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5031 bfd_release (abfd, dot_name);
5032 return h;
5033 }
5034
5035 /* This function satisfies all old ABI object references to ".bar" if a
5036 new ABI object defines "bar". Well, at least, undefined dot symbols
5037 are made weak. This stops later archive searches from including an
5038 object if we already have a function descriptor definition. It also
5039 prevents the linker complaining about undefined symbols.
5040 We also check and correct mismatched symbol visibility here. The
5041 most restrictive visibility of the function descriptor and the
5042 function entry symbol is used. */
5043
5044 static bfd_boolean
5045 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5046 {
5047 struct ppc_link_hash_table *htab;
5048 struct ppc_link_hash_entry *fdh;
5049
5050 if (eh->elf.root.type == bfd_link_hash_warning)
5051 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5052
5053 if (eh->elf.root.type == bfd_link_hash_indirect)
5054 return TRUE;
5055
5056 if (eh->elf.root.root.string[0] != '.')
5057 abort ();
5058
5059 htab = ppc_hash_table (info);
5060 if (htab == NULL)
5061 return FALSE;
5062
5063 fdh = lookup_fdh (eh, htab);
5064 if (fdh == NULL
5065 && !bfd_link_relocatable (info)
5066 && (eh->elf.root.type == bfd_link_hash_undefined
5067 || eh->elf.root.type == bfd_link_hash_undefweak)
5068 && eh->elf.ref_regular)
5069 {
5070 /* Make an undefined function descriptor sym, in order to
5071 pull in an --as-needed shared lib. Archives are handled
5072 elsewhere. */
5073 fdh = make_fdh (info, eh);
5074 if (fdh == NULL)
5075 return FALSE;
5076 }
5077
5078 if (fdh != NULL)
5079 {
5080 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5081 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5082
5083 /* Make both descriptor and entry symbol have the most
5084 constraining visibility of either symbol. */
5085 if (entry_vis < descr_vis)
5086 fdh->elf.other += entry_vis - descr_vis;
5087 else if (entry_vis > descr_vis)
5088 eh->elf.other += descr_vis - entry_vis;
5089
5090 /* Propagate reference flags from entry symbol to function
5091 descriptor symbol. */
5092 fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5093 fdh->elf.ref_regular |= eh->elf.ref_regular;
5094 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5095
5096 if (!fdh->elf.forced_local
5097 && fdh->elf.dynindx == -1
5098 && fdh->elf.versioned != versioned_hidden
5099 && (bfd_link_dll (info)
5100 || fdh->elf.def_dynamic
5101 || fdh->elf.ref_dynamic)
5102 && (eh->elf.ref_regular
5103 || eh->elf.def_regular))
5104 {
5105 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5106 return FALSE;
5107 }
5108 }
5109
5110 return TRUE;
5111 }
5112
5113 /* Set up opd section info and abiversion for IBFD, and process list
5114 of dot-symbols we made in link_hash_newfunc. */
5115
5116 static bfd_boolean
5117 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5118 {
5119 struct ppc_link_hash_table *htab;
5120 struct ppc_link_hash_entry **p, *eh;
5121 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5122
5123 if (opd != NULL && opd->size != 0)
5124 {
5125 if (abiversion (ibfd) == 0)
5126 set_abiversion (ibfd, 1);
5127 else if (abiversion (ibfd) >= 2)
5128 {
5129 /* xgettext:c-format */
5130 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5131 " version %d\n"),
5132 ibfd, abiversion (ibfd));
5133 bfd_set_error (bfd_error_bad_value);
5134 return FALSE;
5135 }
5136
5137 if ((ibfd->flags & DYNAMIC) == 0
5138 && (opd->flags & SEC_RELOC) != 0
5139 && opd->reloc_count != 0
5140 && !bfd_is_abs_section (opd->output_section))
5141 {
5142 /* Garbage collection needs some extra help with .opd sections.
5143 We don't want to necessarily keep everything referenced by
5144 relocs in .opd, as that would keep all functions. Instead,
5145 if we reference an .opd symbol (a function descriptor), we
5146 want to keep the function code symbol's section. This is
5147 easy for global symbols, but for local syms we need to keep
5148 information about the associated function section. */
5149 bfd_size_type amt;
5150 asection **opd_sym_map;
5151
5152 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5153 opd_sym_map = bfd_zalloc (ibfd, amt);
5154 if (opd_sym_map == NULL)
5155 return FALSE;
5156 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5157 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5158 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5159 }
5160 }
5161
5162 if (!is_ppc64_elf (info->output_bfd))
5163 return TRUE;
5164 htab = ppc_hash_table (info);
5165 if (htab == NULL)
5166 return FALSE;
5167
5168 /* For input files without an explicit abiversion in e_flags
5169 we should have flagged any with symbol st_other bits set
5170 as ELFv1 and above flagged those with .opd as ELFv2.
5171 Set the output abiversion if not yet set, and for any input
5172 still ambiguous, take its abiversion from the output.
5173 Differences in ABI are reported later. */
5174 if (abiversion (info->output_bfd) == 0)
5175 set_abiversion (info->output_bfd, abiversion (ibfd));
5176 else if (abiversion (ibfd) == 0)
5177 set_abiversion (ibfd, abiversion (info->output_bfd));
5178
5179 p = &htab->dot_syms;
5180 while ((eh = *p) != NULL)
5181 {
5182 *p = NULL;
5183 if (&eh->elf == htab->elf.hgot)
5184 ;
5185 else if (htab->elf.hgot == NULL
5186 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5187 htab->elf.hgot = &eh->elf;
5188 else if (abiversion (ibfd) <= 1)
5189 {
5190 htab->need_func_desc_adj = 1;
5191 if (!add_symbol_adjust (eh, info))
5192 return FALSE;
5193 }
5194 p = &eh->u.next_dot_sym;
5195 }
5196 return TRUE;
5197 }
5198
5199 /* Undo hash table changes when an --as-needed input file is determined
5200 not to be needed. */
5201
5202 static bfd_boolean
5203 ppc64_elf_notice_as_needed (bfd *ibfd,
5204 struct bfd_link_info *info,
5205 enum notice_asneeded_action act)
5206 {
5207 if (act == notice_not_needed)
5208 {
5209 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5210
5211 if (htab == NULL)
5212 return FALSE;
5213
5214 htab->dot_syms = NULL;
5215 }
5216 return _bfd_elf_notice_as_needed (ibfd, info, act);
5217 }
5218
5219 /* If --just-symbols against a final linked binary, then assume we need
5220 toc adjusting stubs when calling functions defined there. */
5221
5222 static void
5223 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5224 {
5225 if ((sec->flags & SEC_CODE) != 0
5226 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5227 && is_ppc64_elf (sec->owner))
5228 {
5229 if (abiversion (sec->owner) >= 2
5230 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5231 sec->has_toc_reloc = 1;
5232 }
5233 _bfd_elf_link_just_syms (sec, info);
5234 }
5235
5236 static struct plt_entry **
5237 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5238 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5239 {
5240 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5241 struct plt_entry **local_plt;
5242 unsigned char *local_got_tls_masks;
5243
5244 if (local_got_ents == NULL)
5245 {
5246 bfd_size_type size = symtab_hdr->sh_info;
5247
5248 size *= (sizeof (*local_got_ents)
5249 + sizeof (*local_plt)
5250 + sizeof (*local_got_tls_masks));
5251 local_got_ents = bfd_zalloc (abfd, size);
5252 if (local_got_ents == NULL)
5253 return NULL;
5254 elf_local_got_ents (abfd) = local_got_ents;
5255 }
5256
5257 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5258 {
5259 struct got_entry *ent;
5260
5261 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5262 if (ent->addend == r_addend
5263 && ent->owner == abfd
5264 && ent->tls_type == tls_type)
5265 break;
5266 if (ent == NULL)
5267 {
5268 bfd_size_type amt = sizeof (*ent);
5269 ent = bfd_alloc (abfd, amt);
5270 if (ent == NULL)
5271 return FALSE;
5272 ent->next = local_got_ents[r_symndx];
5273 ent->addend = r_addend;
5274 ent->owner = abfd;
5275 ent->tls_type = tls_type;
5276 ent->is_indirect = FALSE;
5277 ent->got.refcount = 0;
5278 local_got_ents[r_symndx] = ent;
5279 }
5280 ent->got.refcount += 1;
5281 }
5282
5283 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5284 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5285 local_got_tls_masks[r_symndx] |= tls_type;
5286
5287 return local_plt + r_symndx;
5288 }
5289
5290 static bfd_boolean
5291 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5292 {
5293 struct plt_entry *ent;
5294
5295 for (ent = *plist; ent != NULL; ent = ent->next)
5296 if (ent->addend == addend)
5297 break;
5298 if (ent == NULL)
5299 {
5300 bfd_size_type amt = sizeof (*ent);
5301 ent = bfd_alloc (abfd, amt);
5302 if (ent == NULL)
5303 return FALSE;
5304 ent->next = *plist;
5305 ent->addend = addend;
5306 ent->plt.refcount = 0;
5307 *plist = ent;
5308 }
5309 ent->plt.refcount += 1;
5310 return TRUE;
5311 }
5312
5313 static bfd_boolean
5314 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5315 {
5316 return (r_type == R_PPC64_REL24
5317 || r_type == R_PPC64_REL14
5318 || r_type == R_PPC64_REL14_BRTAKEN
5319 || r_type == R_PPC64_REL14_BRNTAKEN
5320 || r_type == R_PPC64_ADDR24
5321 || r_type == R_PPC64_ADDR14
5322 || r_type == R_PPC64_ADDR14_BRTAKEN
5323 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5324 }
5325
5326 /* Look through the relocs for a section during the first phase, and
5327 calculate needed space in the global offset table, procedure
5328 linkage table, and dynamic reloc sections. */
5329
5330 static bfd_boolean
5331 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5332 asection *sec, const Elf_Internal_Rela *relocs)
5333 {
5334 struct ppc_link_hash_table *htab;
5335 Elf_Internal_Shdr *symtab_hdr;
5336 struct elf_link_hash_entry **sym_hashes;
5337 const Elf_Internal_Rela *rel;
5338 const Elf_Internal_Rela *rel_end;
5339 asection *sreloc;
5340 asection **opd_sym_map;
5341 struct elf_link_hash_entry *tga, *dottga;
5342
5343 if (bfd_link_relocatable (info))
5344 return TRUE;
5345
5346 /* Don't do anything special with non-loaded, non-alloced sections.
5347 In particular, any relocs in such sections should not affect GOT
5348 and PLT reference counting (ie. we don't allow them to create GOT
5349 or PLT entries), there's no possibility or desire to optimize TLS
5350 relocs, and there's not much point in propagating relocs to shared
5351 libs that the dynamic linker won't relocate. */
5352 if ((sec->flags & SEC_ALLOC) == 0)
5353 return TRUE;
5354
5355 BFD_ASSERT (is_ppc64_elf (abfd));
5356
5357 htab = ppc_hash_table (info);
5358 if (htab == NULL)
5359 return FALSE;
5360
5361 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5362 FALSE, FALSE, TRUE);
5363 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5364 FALSE, FALSE, TRUE);
5365 symtab_hdr = &elf_symtab_hdr (abfd);
5366 sym_hashes = elf_sym_hashes (abfd);
5367 sreloc = NULL;
5368 opd_sym_map = NULL;
5369 if (ppc64_elf_section_data (sec) != NULL
5370 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5371 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5372
5373 rel_end = relocs + sec->reloc_count;
5374 for (rel = relocs; rel < rel_end; rel++)
5375 {
5376 unsigned long r_symndx;
5377 struct elf_link_hash_entry *h;
5378 enum elf_ppc64_reloc_type r_type;
5379 int tls_type;
5380 struct _ppc64_elf_section_data *ppc64_sec;
5381 struct plt_entry **ifunc, **plt_list;
5382
5383 r_symndx = ELF64_R_SYM (rel->r_info);
5384 if (r_symndx < symtab_hdr->sh_info)
5385 h = NULL;
5386 else
5387 {
5388 struct ppc_link_hash_entry *eh;
5389
5390 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5391 h = elf_follow_link (h);
5392 eh = (struct ppc_link_hash_entry *) h;
5393
5394 /* PR15323, ref flags aren't set for references in the same
5395 object. */
5396 h->root.non_ir_ref = 1;
5397 if (eh->is_func && eh->oh != NULL)
5398 eh->oh->elf.root.non_ir_ref = 1;
5399
5400 if (h == htab->elf.hgot)
5401 sec->has_toc_reloc = 1;
5402 }
5403
5404 tls_type = 0;
5405 ifunc = NULL;
5406 if (h != NULL)
5407 {
5408 if (h->type == STT_GNU_IFUNC)
5409 {
5410 h->needs_plt = 1;
5411 ifunc = &h->plt.plist;
5412 }
5413 }
5414 else
5415 {
5416 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5417 abfd, r_symndx);
5418 if (isym == NULL)
5419 return FALSE;
5420
5421 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5422 {
5423 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5424 rel->r_addend, PLT_IFUNC);
5425 if (ifunc == NULL)
5426 return FALSE;
5427 }
5428 }
5429
5430 r_type = ELF64_R_TYPE (rel->r_info);
5431 switch (r_type)
5432 {
5433 case R_PPC64_TLSGD:
5434 case R_PPC64_TLSLD:
5435 /* These special tls relocs tie a call to __tls_get_addr with
5436 its parameter symbol. */
5437 break;
5438
5439 case R_PPC64_GOT_TLSLD16:
5440 case R_PPC64_GOT_TLSLD16_LO:
5441 case R_PPC64_GOT_TLSLD16_HI:
5442 case R_PPC64_GOT_TLSLD16_HA:
5443 tls_type = TLS_TLS | TLS_LD;
5444 goto dogottls;
5445
5446 case R_PPC64_GOT_TLSGD16:
5447 case R_PPC64_GOT_TLSGD16_LO:
5448 case R_PPC64_GOT_TLSGD16_HI:
5449 case R_PPC64_GOT_TLSGD16_HA:
5450 tls_type = TLS_TLS | TLS_GD;
5451 goto dogottls;
5452
5453 case R_PPC64_GOT_TPREL16_DS:
5454 case R_PPC64_GOT_TPREL16_LO_DS:
5455 case R_PPC64_GOT_TPREL16_HI:
5456 case R_PPC64_GOT_TPREL16_HA:
5457 if (bfd_link_pic (info))
5458 info->flags |= DF_STATIC_TLS;
5459 tls_type = TLS_TLS | TLS_TPREL;
5460 goto dogottls;
5461
5462 case R_PPC64_GOT_DTPREL16_DS:
5463 case R_PPC64_GOT_DTPREL16_LO_DS:
5464 case R_PPC64_GOT_DTPREL16_HI:
5465 case R_PPC64_GOT_DTPREL16_HA:
5466 tls_type = TLS_TLS | TLS_DTPREL;
5467 dogottls:
5468 sec->has_tls_reloc = 1;
5469 /* Fall through */
5470
5471 case R_PPC64_GOT16:
5472 case R_PPC64_GOT16_DS:
5473 case R_PPC64_GOT16_HA:
5474 case R_PPC64_GOT16_HI:
5475 case R_PPC64_GOT16_LO:
5476 case R_PPC64_GOT16_LO_DS:
5477 /* This symbol requires a global offset table entry. */
5478 sec->has_toc_reloc = 1;
5479 if (r_type == R_PPC64_GOT_TLSLD16
5480 || r_type == R_PPC64_GOT_TLSGD16
5481 || r_type == R_PPC64_GOT_TPREL16_DS
5482 || r_type == R_PPC64_GOT_DTPREL16_DS
5483 || r_type == R_PPC64_GOT16
5484 || r_type == R_PPC64_GOT16_DS)
5485 {
5486 htab->do_multi_toc = 1;
5487 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5488 }
5489
5490 if (ppc64_elf_tdata (abfd)->got == NULL
5491 && !create_got_section (abfd, info))
5492 return FALSE;
5493
5494 if (h != NULL)
5495 {
5496 struct ppc_link_hash_entry *eh;
5497 struct got_entry *ent;
5498
5499 eh = (struct ppc_link_hash_entry *) h;
5500 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5501 if (ent->addend == rel->r_addend
5502 && ent->owner == abfd
5503 && ent->tls_type == tls_type)
5504 break;
5505 if (ent == NULL)
5506 {
5507 bfd_size_type amt = sizeof (*ent);
5508 ent = bfd_alloc (abfd, amt);
5509 if (ent == NULL)
5510 return FALSE;
5511 ent->next = eh->elf.got.glist;
5512 ent->addend = rel->r_addend;
5513 ent->owner = abfd;
5514 ent->tls_type = tls_type;
5515 ent->is_indirect = FALSE;
5516 ent->got.refcount = 0;
5517 eh->elf.got.glist = ent;
5518 }
5519 ent->got.refcount += 1;
5520 eh->tls_mask |= tls_type;
5521 }
5522 else
5523 /* This is a global offset table entry for a local symbol. */
5524 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5525 rel->r_addend, tls_type))
5526 return FALSE;
5527
5528 /* We may also need a plt entry if the symbol turns out to be
5529 an ifunc. */
5530 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5531 {
5532 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5533 return FALSE;
5534 }
5535 break;
5536
5537 case R_PPC64_PLT16_HA:
5538 case R_PPC64_PLT16_HI:
5539 case R_PPC64_PLT16_LO:
5540 case R_PPC64_PLT32:
5541 case R_PPC64_PLT64:
5542 /* This symbol requires a procedure linkage table entry. */
5543 plt_list = ifunc;
5544 if (h != NULL)
5545 {
5546 h->needs_plt = 1;
5547 if (h->root.root.string[0] == '.'
5548 && h->root.root.string[1] != '\0')
5549 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5550 plt_list = &h->plt.plist;
5551 }
5552 if (plt_list == NULL)
5553 {
5554 /* It does not make sense to have a procedure linkage
5555 table entry for a non-ifunc local symbol. */
5556 info->callbacks->einfo
5557 /* xgettext:c-format */
5558 (_("%P: %H: %s reloc against local symbol\n"),
5559 abfd, sec, rel->r_offset,
5560 ppc64_elf_howto_table[r_type]->name);
5561 bfd_set_error (bfd_error_bad_value);
5562 return FALSE;
5563 }
5564 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5565 return FALSE;
5566 break;
5567
5568 /* The following relocations don't need to propagate the
5569 relocation if linking a shared object since they are
5570 section relative. */
5571 case R_PPC64_SECTOFF:
5572 case R_PPC64_SECTOFF_LO:
5573 case R_PPC64_SECTOFF_HI:
5574 case R_PPC64_SECTOFF_HA:
5575 case R_PPC64_SECTOFF_DS:
5576 case R_PPC64_SECTOFF_LO_DS:
5577 case R_PPC64_DTPREL16:
5578 case R_PPC64_DTPREL16_LO:
5579 case R_PPC64_DTPREL16_HI:
5580 case R_PPC64_DTPREL16_HA:
5581 case R_PPC64_DTPREL16_DS:
5582 case R_PPC64_DTPREL16_LO_DS:
5583 case R_PPC64_DTPREL16_HIGH:
5584 case R_PPC64_DTPREL16_HIGHA:
5585 case R_PPC64_DTPREL16_HIGHER:
5586 case R_PPC64_DTPREL16_HIGHERA:
5587 case R_PPC64_DTPREL16_HIGHEST:
5588 case R_PPC64_DTPREL16_HIGHESTA:
5589 break;
5590
5591 /* Nor do these. */
5592 case R_PPC64_REL16:
5593 case R_PPC64_REL16_LO:
5594 case R_PPC64_REL16_HI:
5595 case R_PPC64_REL16_HA:
5596 case R_PPC64_REL16DX_HA:
5597 break;
5598
5599 /* Not supported as a dynamic relocation. */
5600 case R_PPC64_ADDR64_LOCAL:
5601 if (bfd_link_pic (info))
5602 {
5603 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5604 ppc_howto_init ();
5605 /* xgettext:c-format */
5606 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5607 "in shared libraries and PIEs.\n"),
5608 abfd, sec, rel->r_offset,
5609 ppc64_elf_howto_table[r_type]->name);
5610 bfd_set_error (bfd_error_bad_value);
5611 return FALSE;
5612 }
5613 break;
5614
5615 case R_PPC64_TOC16:
5616 case R_PPC64_TOC16_DS:
5617 htab->do_multi_toc = 1;
5618 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5619 /* Fall through. */
5620 case R_PPC64_TOC16_LO:
5621 case R_PPC64_TOC16_HI:
5622 case R_PPC64_TOC16_HA:
5623 case R_PPC64_TOC16_LO_DS:
5624 sec->has_toc_reloc = 1;
5625 break;
5626
5627 /* Marker reloc. */
5628 case R_PPC64_ENTRY:
5629 break;
5630
5631 /* This relocation describes the C++ object vtable hierarchy.
5632 Reconstruct it for later use during GC. */
5633 case R_PPC64_GNU_VTINHERIT:
5634 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5635 return FALSE;
5636 break;
5637
5638 /* This relocation describes which C++ vtable entries are actually
5639 used. Record for later use during GC. */
5640 case R_PPC64_GNU_VTENTRY:
5641 BFD_ASSERT (h != NULL);
5642 if (h != NULL
5643 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5644 return FALSE;
5645 break;
5646
5647 case R_PPC64_REL14:
5648 case R_PPC64_REL14_BRTAKEN:
5649 case R_PPC64_REL14_BRNTAKEN:
5650 {
5651 asection *dest = NULL;
5652
5653 /* Heuristic: If jumping outside our section, chances are
5654 we are going to need a stub. */
5655 if (h != NULL)
5656 {
5657 /* If the sym is weak it may be overridden later, so
5658 don't assume we know where a weak sym lives. */
5659 if (h->root.type == bfd_link_hash_defined)
5660 dest = h->root.u.def.section;
5661 }
5662 else
5663 {
5664 Elf_Internal_Sym *isym;
5665
5666 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5667 abfd, r_symndx);
5668 if (isym == NULL)
5669 return FALSE;
5670
5671 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5672 }
5673
5674 if (dest != sec)
5675 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5676 }
5677 /* Fall through. */
5678
5679 case R_PPC64_REL24:
5680 plt_list = ifunc;
5681 if (h != NULL)
5682 {
5683 h->needs_plt = 1;
5684 if (h->root.root.string[0] == '.'
5685 && h->root.root.string[1] != '\0')
5686 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5687
5688 if (h == tga || h == dottga)
5689 {
5690 sec->has_tls_reloc = 1;
5691 if (rel != relocs
5692 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5693 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5694 /* We have a new-style __tls_get_addr call with
5695 a marker reloc. */
5696 ;
5697 else
5698 /* Mark this section as having an old-style call. */
5699 sec->has_tls_get_addr_call = 1;
5700 }
5701 plt_list = &h->plt.plist;
5702 }
5703
5704 /* We may need a .plt entry if the function this reloc
5705 refers to is in a shared lib. */
5706 if (plt_list
5707 && !update_plt_info (abfd, plt_list, rel->r_addend))
5708 return FALSE;
5709 break;
5710
5711 case R_PPC64_ADDR14:
5712 case R_PPC64_ADDR14_BRNTAKEN:
5713 case R_PPC64_ADDR14_BRTAKEN:
5714 case R_PPC64_ADDR24:
5715 goto dodyn;
5716
5717 case R_PPC64_TPREL64:
5718 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5719 if (bfd_link_pic (info))
5720 info->flags |= DF_STATIC_TLS;
5721 goto dotlstoc;
5722
5723 case R_PPC64_DTPMOD64:
5724 if (rel + 1 < rel_end
5725 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5726 && rel[1].r_offset == rel->r_offset + 8)
5727 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5728 else
5729 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5730 goto dotlstoc;
5731
5732 case R_PPC64_DTPREL64:
5733 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5734 if (rel != relocs
5735 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5736 && rel[-1].r_offset == rel->r_offset - 8)
5737 /* This is the second reloc of a dtpmod, dtprel pair.
5738 Don't mark with TLS_DTPREL. */
5739 goto dodyn;
5740
5741 dotlstoc:
5742 sec->has_tls_reloc = 1;
5743 if (h != NULL)
5744 {
5745 struct ppc_link_hash_entry *eh;
5746 eh = (struct ppc_link_hash_entry *) h;
5747 eh->tls_mask |= tls_type;
5748 }
5749 else
5750 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5751 rel->r_addend, tls_type))
5752 return FALSE;
5753
5754 ppc64_sec = ppc64_elf_section_data (sec);
5755 if (ppc64_sec->sec_type != sec_toc)
5756 {
5757 bfd_size_type amt;
5758
5759 /* One extra to simplify get_tls_mask. */
5760 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5761 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5762 if (ppc64_sec->u.toc.symndx == NULL)
5763 return FALSE;
5764 amt = sec->size * sizeof (bfd_vma) / 8;
5765 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5766 if (ppc64_sec->u.toc.add == NULL)
5767 return FALSE;
5768 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5769 ppc64_sec->sec_type = sec_toc;
5770 }
5771 BFD_ASSERT (rel->r_offset % 8 == 0);
5772 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5773 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5774
5775 /* Mark the second slot of a GD or LD entry.
5776 -1 to indicate GD and -2 to indicate LD. */
5777 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5778 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5779 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5780 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5781 goto dodyn;
5782
5783 case R_PPC64_TPREL16:
5784 case R_PPC64_TPREL16_LO:
5785 case R_PPC64_TPREL16_HI:
5786 case R_PPC64_TPREL16_HA:
5787 case R_PPC64_TPREL16_DS:
5788 case R_PPC64_TPREL16_LO_DS:
5789 case R_PPC64_TPREL16_HIGH:
5790 case R_PPC64_TPREL16_HIGHA:
5791 case R_PPC64_TPREL16_HIGHER:
5792 case R_PPC64_TPREL16_HIGHERA:
5793 case R_PPC64_TPREL16_HIGHEST:
5794 case R_PPC64_TPREL16_HIGHESTA:
5795 if (bfd_link_pic (info))
5796 {
5797 info->flags |= DF_STATIC_TLS;
5798 goto dodyn;
5799 }
5800 break;
5801
5802 case R_PPC64_ADDR64:
5803 if (opd_sym_map != NULL
5804 && rel + 1 < rel_end
5805 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5806 {
5807 if (h != NULL)
5808 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5809 else
5810 {
5811 asection *s;
5812 Elf_Internal_Sym *isym;
5813
5814 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5815 abfd, r_symndx);
5816 if (isym == NULL)
5817 return FALSE;
5818
5819 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5820 if (s != NULL && s != sec)
5821 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5822 }
5823 }
5824 /* Fall through. */
5825
5826 case R_PPC64_ADDR16:
5827 case R_PPC64_ADDR16_DS:
5828 case R_PPC64_ADDR16_HA:
5829 case R_PPC64_ADDR16_HI:
5830 case R_PPC64_ADDR16_HIGH:
5831 case R_PPC64_ADDR16_HIGHA:
5832 case R_PPC64_ADDR16_HIGHER:
5833 case R_PPC64_ADDR16_HIGHERA:
5834 case R_PPC64_ADDR16_HIGHEST:
5835 case R_PPC64_ADDR16_HIGHESTA:
5836 case R_PPC64_ADDR16_LO:
5837 case R_PPC64_ADDR16_LO_DS:
5838 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5839 && rel->r_addend == 0)
5840 {
5841 /* We may need a .plt entry if this reloc refers to a
5842 function in a shared lib. */
5843 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5844 return FALSE;
5845 h->pointer_equality_needed = 1;
5846 }
5847 /* Fall through. */
5848
5849 case R_PPC64_REL30:
5850 case R_PPC64_REL32:
5851 case R_PPC64_REL64:
5852 case R_PPC64_ADDR32:
5853 case R_PPC64_UADDR16:
5854 case R_PPC64_UADDR32:
5855 case R_PPC64_UADDR64:
5856 case R_PPC64_TOC:
5857 if (h != NULL && !bfd_link_pic (info))
5858 /* We may need a copy reloc. */
5859 h->non_got_ref = 1;
5860
5861 /* Don't propagate .opd relocs. */
5862 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5863 break;
5864
5865 /* If we are creating a shared library, and this is a reloc
5866 against a global symbol, or a non PC relative reloc
5867 against a local symbol, then we need to copy the reloc
5868 into the shared library. However, if we are linking with
5869 -Bsymbolic, we do not need to copy a reloc against a
5870 global symbol which is defined in an object we are
5871 including in the link (i.e., DEF_REGULAR is set). At
5872 this point we have not seen all the input files, so it is
5873 possible that DEF_REGULAR is not set now but will be set
5874 later (it is never cleared). In case of a weak definition,
5875 DEF_REGULAR may be cleared later by a strong definition in
5876 a shared library. We account for that possibility below by
5877 storing information in the dyn_relocs field of the hash
5878 table entry. A similar situation occurs when creating
5879 shared libraries and symbol visibility changes render the
5880 symbol local.
5881
5882 If on the other hand, we are creating an executable, we
5883 may need to keep relocations for symbols satisfied by a
5884 dynamic library if we manage to avoid copy relocs for the
5885 symbol. */
5886 dodyn:
5887 if ((bfd_link_pic (info)
5888 && (must_be_dyn_reloc (info, r_type)
5889 || (h != NULL
5890 && (!SYMBOLIC_BIND (info, h)
5891 || h->root.type == bfd_link_hash_defweak
5892 || !h->def_regular))))
5893 || (ELIMINATE_COPY_RELOCS
5894 && !bfd_link_pic (info)
5895 && h != NULL
5896 && (h->root.type == bfd_link_hash_defweak
5897 || !h->def_regular))
5898 || (!bfd_link_pic (info)
5899 && ifunc != NULL))
5900 {
5901 /* We must copy these reloc types into the output file.
5902 Create a reloc section in dynobj and make room for
5903 this reloc. */
5904 if (sreloc == NULL)
5905 {
5906 sreloc = _bfd_elf_make_dynamic_reloc_section
5907 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5908
5909 if (sreloc == NULL)
5910 return FALSE;
5911 }
5912
5913 /* If this is a global symbol, we count the number of
5914 relocations we need for this symbol. */
5915 if (h != NULL)
5916 {
5917 struct elf_dyn_relocs *p;
5918 struct elf_dyn_relocs **head;
5919
5920 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5921 p = *head;
5922 if (p == NULL || p->sec != sec)
5923 {
5924 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5925 if (p == NULL)
5926 return FALSE;
5927 p->next = *head;
5928 *head = p;
5929 p->sec = sec;
5930 p->count = 0;
5931 p->pc_count = 0;
5932 }
5933 p->count += 1;
5934 if (!must_be_dyn_reloc (info, r_type))
5935 p->pc_count += 1;
5936 }
5937 else
5938 {
5939 /* Track dynamic relocs needed for local syms too.
5940 We really need local syms available to do this
5941 easily. Oh well. */
5942 struct ppc_dyn_relocs *p;
5943 struct ppc_dyn_relocs **head;
5944 bfd_boolean is_ifunc;
5945 asection *s;
5946 void *vpp;
5947 Elf_Internal_Sym *isym;
5948
5949 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5950 abfd, r_symndx);
5951 if (isym == NULL)
5952 return FALSE;
5953
5954 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5955 if (s == NULL)
5956 s = sec;
5957
5958 vpp = &elf_section_data (s)->local_dynrel;
5959 head = (struct ppc_dyn_relocs **) vpp;
5960 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5961 p = *head;
5962 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5963 p = p->next;
5964 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5965 {
5966 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5967 if (p == NULL)
5968 return FALSE;
5969 p->next = *head;
5970 *head = p;
5971 p->sec = sec;
5972 p->ifunc = is_ifunc;
5973 p->count = 0;
5974 }
5975 p->count += 1;
5976 }
5977 }
5978 break;
5979
5980 default:
5981 break;
5982 }
5983 }
5984
5985 return TRUE;
5986 }
5987
5988 /* Merge backend specific data from an object file to the output
5989 object file when linking. */
5990
5991 static bfd_boolean
5992 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
5993 {
5994 bfd *obfd = info->output_bfd;
5995 unsigned long iflags, oflags;
5996
5997 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5998 return TRUE;
5999
6000 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6001 return TRUE;
6002
6003 if (!_bfd_generic_verify_endian_match (ibfd, info))
6004 return FALSE;
6005
6006 iflags = elf_elfheader (ibfd)->e_flags;
6007 oflags = elf_elfheader (obfd)->e_flags;
6008
6009 if (iflags & ~EF_PPC64_ABI)
6010 {
6011 _bfd_error_handler
6012 /* xgettext:c-format */
6013 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6014 bfd_set_error (bfd_error_bad_value);
6015 return FALSE;
6016 }
6017 else if (iflags != oflags && iflags != 0)
6018 {
6019 _bfd_error_handler
6020 /* xgettext:c-format */
6021 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6022 ibfd, iflags, oflags);
6023 bfd_set_error (bfd_error_bad_value);
6024 return FALSE;
6025 }
6026
6027 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6028
6029 /* Merge Tag_compatibility attributes and any common GNU ones. */
6030 _bfd_elf_merge_object_attributes (ibfd, info);
6031
6032 return TRUE;
6033 }
6034
6035 static bfd_boolean
6036 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6037 {
6038 /* Print normal ELF private data. */
6039 _bfd_elf_print_private_bfd_data (abfd, ptr);
6040
6041 if (elf_elfheader (abfd)->e_flags != 0)
6042 {
6043 FILE *file = ptr;
6044
6045 fprintf (file, _("private flags = 0x%lx:"),
6046 elf_elfheader (abfd)->e_flags);
6047
6048 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6049 fprintf (file, _(" [abiv%ld]"),
6050 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6051 fputc ('\n', file);
6052 }
6053
6054 return TRUE;
6055 }
6056
6057 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6058 of the code entry point, and its section, which must be in the same
6059 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6060
6061 static bfd_vma
6062 opd_entry_value (asection *opd_sec,
6063 bfd_vma offset,
6064 asection **code_sec,
6065 bfd_vma *code_off,
6066 bfd_boolean in_code_sec)
6067 {
6068 bfd *opd_bfd = opd_sec->owner;
6069 Elf_Internal_Rela *relocs;
6070 Elf_Internal_Rela *lo, *hi, *look;
6071 bfd_vma val;
6072
6073 /* No relocs implies we are linking a --just-symbols object, or looking
6074 at a final linked executable with addr2line or somesuch. */
6075 if (opd_sec->reloc_count == 0)
6076 {
6077 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6078
6079 if (contents == NULL)
6080 {
6081 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6082 return (bfd_vma) -1;
6083 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6084 }
6085
6086 /* PR 17512: file: 64b9dfbb. */
6087 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6088 return (bfd_vma) -1;
6089
6090 val = bfd_get_64 (opd_bfd, contents + offset);
6091 if (code_sec != NULL)
6092 {
6093 asection *sec, *likely = NULL;
6094
6095 if (in_code_sec)
6096 {
6097 sec = *code_sec;
6098 if (sec->vma <= val
6099 && val < sec->vma + sec->size)
6100 likely = sec;
6101 else
6102 val = -1;
6103 }
6104 else
6105 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6106 if (sec->vma <= val
6107 && (sec->flags & SEC_LOAD) != 0
6108 && (sec->flags & SEC_ALLOC) != 0)
6109 likely = sec;
6110 if (likely != NULL)
6111 {
6112 *code_sec = likely;
6113 if (code_off != NULL)
6114 *code_off = val - likely->vma;
6115 }
6116 }
6117 return val;
6118 }
6119
6120 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6121
6122 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6123 if (relocs == NULL)
6124 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6125 /* PR 17512: file: df8e1fd6. */
6126 if (relocs == NULL)
6127 return (bfd_vma) -1;
6128
6129 /* Go find the opd reloc at the sym address. */
6130 lo = relocs;
6131 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6132 val = (bfd_vma) -1;
6133 while (lo < hi)
6134 {
6135 look = lo + (hi - lo) / 2;
6136 if (look->r_offset < offset)
6137 lo = look + 1;
6138 else if (look->r_offset > offset)
6139 hi = look;
6140 else
6141 {
6142 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6143
6144 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6145 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6146 {
6147 unsigned long symndx = ELF64_R_SYM (look->r_info);
6148 asection *sec = NULL;
6149
6150 if (symndx >= symtab_hdr->sh_info
6151 && elf_sym_hashes (opd_bfd) != NULL)
6152 {
6153 struct elf_link_hash_entry **sym_hashes;
6154 struct elf_link_hash_entry *rh;
6155
6156 sym_hashes = elf_sym_hashes (opd_bfd);
6157 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6158 if (rh != NULL)
6159 {
6160 rh = elf_follow_link (rh);
6161 if (rh->root.type != bfd_link_hash_defined
6162 && rh->root.type != bfd_link_hash_defweak)
6163 break;
6164 if (rh->root.u.def.section->owner == opd_bfd)
6165 {
6166 val = rh->root.u.def.value;
6167 sec = rh->root.u.def.section;
6168 }
6169 }
6170 }
6171
6172 if (sec == NULL)
6173 {
6174 Elf_Internal_Sym *sym;
6175
6176 if (symndx < symtab_hdr->sh_info)
6177 {
6178 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6179 if (sym == NULL)
6180 {
6181 size_t symcnt = symtab_hdr->sh_info;
6182 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6183 symcnt, 0,
6184 NULL, NULL, NULL);
6185 if (sym == NULL)
6186 break;
6187 symtab_hdr->contents = (bfd_byte *) sym;
6188 }
6189 sym += symndx;
6190 }
6191 else
6192 {
6193 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6194 1, symndx,
6195 NULL, NULL, NULL);
6196 if (sym == NULL)
6197 break;
6198 }
6199 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6200 if (sec == NULL)
6201 break;
6202 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6203 val = sym->st_value;
6204 }
6205
6206 val += look->r_addend;
6207 if (code_off != NULL)
6208 *code_off = val;
6209 if (code_sec != NULL)
6210 {
6211 if (in_code_sec && *code_sec != sec)
6212 return -1;
6213 else
6214 *code_sec = sec;
6215 }
6216 if (sec->output_section != NULL)
6217 val += sec->output_section->vma + sec->output_offset;
6218 }
6219 break;
6220 }
6221 }
6222
6223 return val;
6224 }
6225
6226 /* If the ELF symbol SYM might be a function in SEC, return the
6227 function size and set *CODE_OFF to the function's entry point,
6228 otherwise return zero. */
6229
6230 static bfd_size_type
6231 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6232 bfd_vma *code_off)
6233 {
6234 bfd_size_type size;
6235
6236 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6237 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6238 return 0;
6239
6240 size = 0;
6241 if (!(sym->flags & BSF_SYNTHETIC))
6242 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6243
6244 if (strcmp (sym->section->name, ".opd") == 0)
6245 {
6246 struct _opd_sec_data *opd = get_opd_info (sym->section);
6247 bfd_vma symval = sym->value;
6248
6249 if (opd != NULL
6250 && opd->adjust != NULL
6251 && elf_section_data (sym->section)->relocs != NULL)
6252 {
6253 /* opd_entry_value will use cached relocs that have been
6254 adjusted, but with raw symbols. That means both local
6255 and global symbols need adjusting. */
6256 long adjust = opd->adjust[OPD_NDX (symval)];
6257 if (adjust == -1)
6258 return 0;
6259 symval += adjust;
6260 }
6261
6262 if (opd_entry_value (sym->section, symval,
6263 &sec, code_off, TRUE) == (bfd_vma) -1)
6264 return 0;
6265 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6266 symbol. This size has nothing to do with the code size of the
6267 function, which is what we're supposed to return, but the
6268 code size isn't available without looking up the dot-sym.
6269 However, doing that would be a waste of time particularly
6270 since elf_find_function will look at the dot-sym anyway.
6271 Now, elf_find_function will keep the largest size of any
6272 function sym found at the code address of interest, so return
6273 1 here to avoid it incorrectly caching a larger function size
6274 for a small function. This does mean we return the wrong
6275 size for a new-ABI function of size 24, but all that does is
6276 disable caching for such functions. */
6277 if (size == 24)
6278 size = 1;
6279 }
6280 else
6281 {
6282 if (sym->section != sec)
6283 return 0;
6284 *code_off = sym->value;
6285 }
6286 if (size == 0)
6287 size = 1;
6288 return size;
6289 }
6290
6291 /* Return true if symbol is defined in a regular object file. */
6292
6293 static bfd_boolean
6294 is_static_defined (struct elf_link_hash_entry *h)
6295 {
6296 return ((h->root.type == bfd_link_hash_defined
6297 || h->root.type == bfd_link_hash_defweak)
6298 && h->root.u.def.section != NULL
6299 && h->root.u.def.section->output_section != NULL);
6300 }
6301
6302 /* If FDH is a function descriptor symbol, return the associated code
6303 entry symbol if it is defined. Return NULL otherwise. */
6304
6305 static struct ppc_link_hash_entry *
6306 defined_code_entry (struct ppc_link_hash_entry *fdh)
6307 {
6308 if (fdh->is_func_descriptor)
6309 {
6310 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6311 if (fh->elf.root.type == bfd_link_hash_defined
6312 || fh->elf.root.type == bfd_link_hash_defweak)
6313 return fh;
6314 }
6315 return NULL;
6316 }
6317
6318 /* If FH is a function code entry symbol, return the associated
6319 function descriptor symbol if it is defined. Return NULL otherwise. */
6320
6321 static struct ppc_link_hash_entry *
6322 defined_func_desc (struct ppc_link_hash_entry *fh)
6323 {
6324 if (fh->oh != NULL
6325 && fh->oh->is_func_descriptor)
6326 {
6327 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6328 if (fdh->elf.root.type == bfd_link_hash_defined
6329 || fdh->elf.root.type == bfd_link_hash_defweak)
6330 return fdh;
6331 }
6332 return NULL;
6333 }
6334
6335 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6336
6337 /* Garbage collect sections, after first dealing with dot-symbols. */
6338
6339 static bfd_boolean
6340 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6341 {
6342 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6343
6344 if (htab != NULL && htab->need_func_desc_adj)
6345 {
6346 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6347 htab->need_func_desc_adj = 0;
6348 }
6349 return bfd_elf_gc_sections (abfd, info);
6350 }
6351
6352 /* Mark all our entry sym sections, both opd and code section. */
6353
6354 static void
6355 ppc64_elf_gc_keep (struct bfd_link_info *info)
6356 {
6357 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6358 struct bfd_sym_chain *sym;
6359
6360 if (htab == NULL)
6361 return;
6362
6363 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6364 {
6365 struct ppc_link_hash_entry *eh, *fh;
6366 asection *sec;
6367
6368 eh = (struct ppc_link_hash_entry *)
6369 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6370 if (eh == NULL)
6371 continue;
6372 if (eh->elf.root.type != bfd_link_hash_defined
6373 && eh->elf.root.type != bfd_link_hash_defweak)
6374 continue;
6375
6376 fh = defined_code_entry (eh);
6377 if (fh != NULL)
6378 {
6379 sec = fh->elf.root.u.def.section;
6380 sec->flags |= SEC_KEEP;
6381 }
6382 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6383 && opd_entry_value (eh->elf.root.u.def.section,
6384 eh->elf.root.u.def.value,
6385 &sec, NULL, FALSE) != (bfd_vma) -1)
6386 sec->flags |= SEC_KEEP;
6387
6388 sec = eh->elf.root.u.def.section;
6389 sec->flags |= SEC_KEEP;
6390 }
6391 }
6392
6393 /* Mark sections containing dynamically referenced symbols. When
6394 building shared libraries, we must assume that any visible symbol is
6395 referenced. */
6396
6397 static bfd_boolean
6398 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6399 {
6400 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6401 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6402 struct ppc_link_hash_entry *fdh;
6403 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6404
6405 /* Dynamic linking info is on the func descriptor sym. */
6406 fdh = defined_func_desc (eh);
6407 if (fdh != NULL)
6408 eh = fdh;
6409
6410 if ((eh->elf.root.type == bfd_link_hash_defined
6411 || eh->elf.root.type == bfd_link_hash_defweak)
6412 && (eh->elf.ref_dynamic
6413 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6414 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6415 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6416 && (!bfd_link_executable (info)
6417 || info->export_dynamic
6418 || (eh->elf.dynamic
6419 && d != NULL
6420 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6421 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6422 || !bfd_hide_sym_by_version (info->version_info,
6423 eh->elf.root.root.string)))))
6424 {
6425 asection *code_sec;
6426 struct ppc_link_hash_entry *fh;
6427
6428 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6429
6430 /* Function descriptor syms cause the associated
6431 function code sym section to be marked. */
6432 fh = defined_code_entry (eh);
6433 if (fh != NULL)
6434 {
6435 code_sec = fh->elf.root.u.def.section;
6436 code_sec->flags |= SEC_KEEP;
6437 }
6438 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6439 && opd_entry_value (eh->elf.root.u.def.section,
6440 eh->elf.root.u.def.value,
6441 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6442 code_sec->flags |= SEC_KEEP;
6443 }
6444
6445 return TRUE;
6446 }
6447
6448 /* Return the section that should be marked against GC for a given
6449 relocation. */
6450
6451 static asection *
6452 ppc64_elf_gc_mark_hook (asection *sec,
6453 struct bfd_link_info *info,
6454 Elf_Internal_Rela *rel,
6455 struct elf_link_hash_entry *h,
6456 Elf_Internal_Sym *sym)
6457 {
6458 asection *rsec;
6459
6460 /* Syms return NULL if we're marking .opd, so we avoid marking all
6461 function sections, as all functions are referenced in .opd. */
6462 rsec = NULL;
6463 if (get_opd_info (sec) != NULL)
6464 return rsec;
6465
6466 if (h != NULL)
6467 {
6468 enum elf_ppc64_reloc_type r_type;
6469 struct ppc_link_hash_entry *eh, *fh, *fdh;
6470
6471 r_type = ELF64_R_TYPE (rel->r_info);
6472 switch (r_type)
6473 {
6474 case R_PPC64_GNU_VTINHERIT:
6475 case R_PPC64_GNU_VTENTRY:
6476 break;
6477
6478 default:
6479 switch (h->root.type)
6480 {
6481 case bfd_link_hash_defined:
6482 case bfd_link_hash_defweak:
6483 eh = (struct ppc_link_hash_entry *) h;
6484 fdh = defined_func_desc (eh);
6485 if (fdh != NULL)
6486 {
6487 /* -mcall-aixdesc code references the dot-symbol on
6488 a call reloc. Mark the function descriptor too
6489 against garbage collection. */
6490 fdh->elf.mark = 1;
6491 if (fdh->elf.u.weakdef != NULL)
6492 fdh->elf.u.weakdef->mark = 1;
6493 eh = fdh;
6494 }
6495
6496 /* Function descriptor syms cause the associated
6497 function code sym section to be marked. */
6498 fh = defined_code_entry (eh);
6499 if (fh != NULL)
6500 {
6501 /* They also mark their opd section. */
6502 eh->elf.root.u.def.section->gc_mark = 1;
6503
6504 rsec = fh->elf.root.u.def.section;
6505 }
6506 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6507 && opd_entry_value (eh->elf.root.u.def.section,
6508 eh->elf.root.u.def.value,
6509 &rsec, NULL, FALSE) != (bfd_vma) -1)
6510 eh->elf.root.u.def.section->gc_mark = 1;
6511 else
6512 rsec = h->root.u.def.section;
6513 break;
6514
6515 case bfd_link_hash_common:
6516 rsec = h->root.u.c.p->section;
6517 break;
6518
6519 default:
6520 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6521 }
6522 }
6523 }
6524 else
6525 {
6526 struct _opd_sec_data *opd;
6527
6528 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6529 opd = get_opd_info (rsec);
6530 if (opd != NULL && opd->func_sec != NULL)
6531 {
6532 rsec->gc_mark = 1;
6533
6534 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6535 }
6536 }
6537
6538 return rsec;
6539 }
6540
6541 /* Update the .got, .plt. and dynamic reloc reference counts for the
6542 section being removed. */
6543
6544 static bfd_boolean
6545 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6546 asection *sec, const Elf_Internal_Rela *relocs)
6547 {
6548 struct ppc_link_hash_table *htab;
6549 Elf_Internal_Shdr *symtab_hdr;
6550 struct elf_link_hash_entry **sym_hashes;
6551 struct got_entry **local_got_ents;
6552 const Elf_Internal_Rela *rel, *relend;
6553
6554 if (bfd_link_relocatable (info))
6555 return TRUE;
6556
6557 if ((sec->flags & SEC_ALLOC) == 0)
6558 return TRUE;
6559
6560 elf_section_data (sec)->local_dynrel = NULL;
6561
6562 htab = ppc_hash_table (info);
6563 if (htab == NULL)
6564 return FALSE;
6565
6566 symtab_hdr = &elf_symtab_hdr (abfd);
6567 sym_hashes = elf_sym_hashes (abfd);
6568 local_got_ents = elf_local_got_ents (abfd);
6569
6570 relend = relocs + sec->reloc_count;
6571 for (rel = relocs; rel < relend; rel++)
6572 {
6573 unsigned long r_symndx;
6574 enum elf_ppc64_reloc_type r_type;
6575 struct elf_link_hash_entry *h = NULL;
6576 struct plt_entry **plt_list;
6577 unsigned char tls_type = 0;
6578
6579 r_symndx = ELF64_R_SYM (rel->r_info);
6580 r_type = ELF64_R_TYPE (rel->r_info);
6581 if (r_symndx >= symtab_hdr->sh_info)
6582 {
6583 struct ppc_link_hash_entry *eh;
6584 struct elf_dyn_relocs **pp;
6585 struct elf_dyn_relocs *p;
6586
6587 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6588 h = elf_follow_link (h);
6589 eh = (struct ppc_link_hash_entry *) h;
6590
6591 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6592 if (p->sec == sec)
6593 {
6594 /* Everything must go for SEC. */
6595 *pp = p->next;
6596 break;
6597 }
6598 }
6599
6600 switch (r_type)
6601 {
6602 case R_PPC64_GOT_TLSLD16:
6603 case R_PPC64_GOT_TLSLD16_LO:
6604 case R_PPC64_GOT_TLSLD16_HI:
6605 case R_PPC64_GOT_TLSLD16_HA:
6606 tls_type = TLS_TLS | TLS_LD;
6607 goto dogot;
6608
6609 case R_PPC64_GOT_TLSGD16:
6610 case R_PPC64_GOT_TLSGD16_LO:
6611 case R_PPC64_GOT_TLSGD16_HI:
6612 case R_PPC64_GOT_TLSGD16_HA:
6613 tls_type = TLS_TLS | TLS_GD;
6614 goto dogot;
6615
6616 case R_PPC64_GOT_TPREL16_DS:
6617 case R_PPC64_GOT_TPREL16_LO_DS:
6618 case R_PPC64_GOT_TPREL16_HI:
6619 case R_PPC64_GOT_TPREL16_HA:
6620 tls_type = TLS_TLS | TLS_TPREL;
6621 goto dogot;
6622
6623 case R_PPC64_GOT_DTPREL16_DS:
6624 case R_PPC64_GOT_DTPREL16_LO_DS:
6625 case R_PPC64_GOT_DTPREL16_HI:
6626 case R_PPC64_GOT_DTPREL16_HA:
6627 tls_type = TLS_TLS | TLS_DTPREL;
6628 goto dogot;
6629
6630 case R_PPC64_GOT16:
6631 case R_PPC64_GOT16_DS:
6632 case R_PPC64_GOT16_HA:
6633 case R_PPC64_GOT16_HI:
6634 case R_PPC64_GOT16_LO:
6635 case R_PPC64_GOT16_LO_DS:
6636 dogot:
6637 {
6638 struct got_entry *ent;
6639
6640 if (h != NULL)
6641 ent = h->got.glist;
6642 else
6643 ent = local_got_ents[r_symndx];
6644
6645 for (; ent != NULL; ent = ent->next)
6646 if (ent->addend == rel->r_addend
6647 && ent->owner == abfd
6648 && ent->tls_type == tls_type)
6649 break;
6650 if (ent == NULL)
6651 abort ();
6652 if (ent->got.refcount > 0)
6653 ent->got.refcount -= 1;
6654 }
6655 break;
6656
6657 case R_PPC64_PLT16_HA:
6658 case R_PPC64_PLT16_HI:
6659 case R_PPC64_PLT16_LO:
6660 case R_PPC64_PLT32:
6661 case R_PPC64_PLT64:
6662 case R_PPC64_REL14:
6663 case R_PPC64_REL14_BRNTAKEN:
6664 case R_PPC64_REL14_BRTAKEN:
6665 case R_PPC64_REL24:
6666 plt_list = NULL;
6667 if (h != NULL)
6668 plt_list = &h->plt.plist;
6669 else if (local_got_ents != NULL)
6670 {
6671 struct plt_entry **local_plt = (struct plt_entry **)
6672 (local_got_ents + symtab_hdr->sh_info);
6673 unsigned char *local_got_tls_masks = (unsigned char *)
6674 (local_plt + symtab_hdr->sh_info);
6675 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6676 plt_list = local_plt + r_symndx;
6677 }
6678 if (plt_list)
6679 {
6680 struct plt_entry *ent;
6681
6682 for (ent = *plt_list; ent != NULL; ent = ent->next)
6683 if (ent->addend == rel->r_addend)
6684 break;
6685 if (ent != NULL && ent->plt.refcount > 0)
6686 ent->plt.refcount -= 1;
6687 }
6688 break;
6689
6690 default:
6691 break;
6692 }
6693 }
6694 return TRUE;
6695 }
6696
6697 /* The maximum size of .sfpr. */
6698 #define SFPR_MAX (218*4)
6699
6700 struct sfpr_def_parms
6701 {
6702 const char name[12];
6703 unsigned char lo, hi;
6704 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6705 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6706 };
6707
6708 /* Auto-generate _save*, _rest* functions in .sfpr.
6709 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6710 instead. */
6711
6712 static bfd_boolean
6713 sfpr_define (struct bfd_link_info *info,
6714 const struct sfpr_def_parms *parm,
6715 asection *stub_sec)
6716 {
6717 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6718 unsigned int i;
6719 size_t len = strlen (parm->name);
6720 bfd_boolean writing = FALSE;
6721 char sym[16];
6722
6723 if (htab == NULL)
6724 return FALSE;
6725
6726 memcpy (sym, parm->name, len);
6727 sym[len + 2] = 0;
6728
6729 for (i = parm->lo; i <= parm->hi; i++)
6730 {
6731 struct ppc_link_hash_entry *h;
6732
6733 sym[len + 0] = i / 10 + '0';
6734 sym[len + 1] = i % 10 + '0';
6735 h = (struct ppc_link_hash_entry *)
6736 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6737 if (stub_sec != NULL)
6738 {
6739 if (h != NULL
6740 && h->elf.root.type == bfd_link_hash_defined
6741 && h->elf.root.u.def.section == htab->sfpr)
6742 {
6743 struct elf_link_hash_entry *s;
6744 char buf[32];
6745 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6746 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6747 if (s == NULL)
6748 return FALSE;
6749 if (s->root.type == bfd_link_hash_new
6750 || (s->root.type = bfd_link_hash_defined
6751 && s->root.u.def.section == stub_sec))
6752 {
6753 s->root.type = bfd_link_hash_defined;
6754 s->root.u.def.section = stub_sec;
6755 s->root.u.def.value = (stub_sec->size
6756 + h->elf.root.u.def.value);
6757 s->ref_regular = 1;
6758 s->def_regular = 1;
6759 s->ref_regular_nonweak = 1;
6760 s->forced_local = 1;
6761 s->non_elf = 0;
6762 s->root.linker_def = 1;
6763 }
6764 }
6765 continue;
6766 }
6767 if (h != NULL)
6768 {
6769 h->save_res = 1;
6770 if (!h->elf.def_regular)
6771 {
6772 h->elf.root.type = bfd_link_hash_defined;
6773 h->elf.root.u.def.section = htab->sfpr;
6774 h->elf.root.u.def.value = htab->sfpr->size;
6775 h->elf.type = STT_FUNC;
6776 h->elf.def_regular = 1;
6777 h->elf.non_elf = 0;
6778 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6779 writing = TRUE;
6780 if (htab->sfpr->contents == NULL)
6781 {
6782 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6783 if (htab->sfpr->contents == NULL)
6784 return FALSE;
6785 }
6786 }
6787 }
6788 if (writing)
6789 {
6790 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6791 if (i != parm->hi)
6792 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6793 else
6794 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6795 htab->sfpr->size = p - htab->sfpr->contents;
6796 }
6797 }
6798
6799 return TRUE;
6800 }
6801
6802 static bfd_byte *
6803 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6804 {
6805 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6806 return p + 4;
6807 }
6808
6809 static bfd_byte *
6810 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6811 {
6812 p = savegpr0 (abfd, p, r);
6813 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6814 p = p + 4;
6815 bfd_put_32 (abfd, BLR, p);
6816 return p + 4;
6817 }
6818
6819 static bfd_byte *
6820 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6821 {
6822 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6823 return p + 4;
6824 }
6825
6826 static bfd_byte *
6827 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6828 {
6829 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6830 p = p + 4;
6831 p = restgpr0 (abfd, p, r);
6832 bfd_put_32 (abfd, MTLR_R0, p);
6833 p = p + 4;
6834 if (r == 29)
6835 {
6836 p = restgpr0 (abfd, p, 30);
6837 p = restgpr0 (abfd, p, 31);
6838 }
6839 bfd_put_32 (abfd, BLR, p);
6840 return p + 4;
6841 }
6842
6843 static bfd_byte *
6844 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6845 {
6846 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6847 return p + 4;
6848 }
6849
6850 static bfd_byte *
6851 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6852 {
6853 p = savegpr1 (abfd, p, r);
6854 bfd_put_32 (abfd, BLR, p);
6855 return p + 4;
6856 }
6857
6858 static bfd_byte *
6859 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6860 {
6861 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6862 return p + 4;
6863 }
6864
6865 static bfd_byte *
6866 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6867 {
6868 p = restgpr1 (abfd, p, r);
6869 bfd_put_32 (abfd, BLR, p);
6870 return p + 4;
6871 }
6872
6873 static bfd_byte *
6874 savefpr (bfd *abfd, bfd_byte *p, int r)
6875 {
6876 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6877 return p + 4;
6878 }
6879
6880 static bfd_byte *
6881 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6882 {
6883 p = savefpr (abfd, p, r);
6884 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6885 p = p + 4;
6886 bfd_put_32 (abfd, BLR, p);
6887 return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 restfpr (bfd *abfd, bfd_byte *p, int r)
6892 {
6893 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6894 return p + 4;
6895 }
6896
6897 static bfd_byte *
6898 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6899 {
6900 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6901 p = p + 4;
6902 p = restfpr (abfd, p, r);
6903 bfd_put_32 (abfd, MTLR_R0, p);
6904 p = p + 4;
6905 if (r == 29)
6906 {
6907 p = restfpr (abfd, p, 30);
6908 p = restfpr (abfd, p, 31);
6909 }
6910 bfd_put_32 (abfd, BLR, p);
6911 return p + 4;
6912 }
6913
6914 static bfd_byte *
6915 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6916 {
6917 p = savefpr (abfd, p, r);
6918 bfd_put_32 (abfd, BLR, p);
6919 return p + 4;
6920 }
6921
6922 static bfd_byte *
6923 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6924 {
6925 p = restfpr (abfd, p, r);
6926 bfd_put_32 (abfd, BLR, p);
6927 return p + 4;
6928 }
6929
6930 static bfd_byte *
6931 savevr (bfd *abfd, bfd_byte *p, int r)
6932 {
6933 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6934 p = p + 4;
6935 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6936 return p + 4;
6937 }
6938
6939 static bfd_byte *
6940 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6941 {
6942 p = savevr (abfd, p, r);
6943 bfd_put_32 (abfd, BLR, p);
6944 return p + 4;
6945 }
6946
6947 static bfd_byte *
6948 restvr (bfd *abfd, bfd_byte *p, int r)
6949 {
6950 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6951 p = p + 4;
6952 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6953 return p + 4;
6954 }
6955
6956 static bfd_byte *
6957 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6958 {
6959 p = restvr (abfd, p, r);
6960 bfd_put_32 (abfd, BLR, p);
6961 return p + 4;
6962 }
6963
6964 /* Called via elf_link_hash_traverse to transfer dynamic linking
6965 information on function code symbol entries to their corresponding
6966 function descriptor symbol entries. */
6967
6968 static bfd_boolean
6969 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6970 {
6971 struct bfd_link_info *info;
6972 struct ppc_link_hash_table *htab;
6973 struct ppc_link_hash_entry *fh;
6974 struct ppc_link_hash_entry *fdh;
6975 bfd_boolean force_local;
6976
6977 fh = (struct ppc_link_hash_entry *) h;
6978 if (fh->elf.root.type == bfd_link_hash_indirect)
6979 return TRUE;
6980
6981 if (!fh->is_func)
6982 return TRUE;
6983
6984 if (fh->elf.root.root.string[0] != '.'
6985 || fh->elf.root.root.string[1] == '\0')
6986 return TRUE;
6987
6988 info = inf;
6989 htab = ppc_hash_table (info);
6990 if (htab == NULL)
6991 return FALSE;
6992
6993 /* Find the corresponding function descriptor symbol. */
6994 fdh = lookup_fdh (fh, htab);
6995
6996 /* Resolve undefined references to dot-symbols as the value
6997 in the function descriptor, if we have one in a regular object.
6998 This is to satisfy cases like ".quad .foo". Calls to functions
6999 in dynamic objects are handled elsewhere. */
7000 if ((fh->elf.root.type == bfd_link_hash_undefined
7001 || fh->elf.root.type == bfd_link_hash_undefweak)
7002 && (fdh->elf.root.type == bfd_link_hash_defined
7003 || fdh->elf.root.type == bfd_link_hash_defweak)
7004 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7005 && opd_entry_value (fdh->elf.root.u.def.section,
7006 fdh->elf.root.u.def.value,
7007 &fh->elf.root.u.def.section,
7008 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7009 {
7010 fh->elf.root.type = fdh->elf.root.type;
7011 fh->elf.forced_local = 1;
7012 fh->elf.def_regular = fdh->elf.def_regular;
7013 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7014 }
7015
7016 if (!fh->elf.dynamic)
7017 {
7018 struct plt_entry *ent;
7019
7020 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7021 if (ent->plt.refcount > 0)
7022 break;
7023 if (ent == NULL)
7024 return TRUE;
7025 }
7026
7027 /* Create a descriptor as undefined if necessary. */
7028 if (fdh == NULL
7029 && !bfd_link_executable (info)
7030 && (fh->elf.root.type == bfd_link_hash_undefined
7031 || fh->elf.root.type == bfd_link_hash_undefweak))
7032 {
7033 fdh = make_fdh (info, fh);
7034 if (fdh == NULL)
7035 return FALSE;
7036 }
7037
7038 /* We can't support overriding of symbols on a fake descriptor. */
7039 if (fdh != NULL
7040 && fdh->fake
7041 && (fh->elf.root.type == bfd_link_hash_defined
7042 || fh->elf.root.type == bfd_link_hash_defweak))
7043 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7044
7045 /* Transfer dynamic linking information to the function descriptor. */
7046 if (fdh != NULL)
7047 {
7048 fdh->elf.ref_regular |= fh->elf.ref_regular;
7049 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7050 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7051 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7052 fdh->elf.dynamic |= fh->elf.dynamic;
7053 fdh->elf.needs_plt |= (fh->elf.needs_plt
7054 || fh->elf.type == STT_FUNC
7055 || fh->elf.type == STT_GNU_IFUNC);
7056 move_plt_plist (fh, fdh);
7057
7058 if (!fdh->elf.forced_local
7059 && fh->elf.dynindx != -1)
7060 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7061 return FALSE;
7062 }
7063
7064 /* Now that the info is on the function descriptor, clear the
7065 function code sym info. Any function code syms for which we
7066 don't have a definition in a regular file, we force local.
7067 This prevents a shared library from exporting syms that have
7068 been imported from another library. Function code syms that
7069 are really in the library we must leave global to prevent the
7070 linker dragging in a definition from a static library. */
7071 force_local = (!fh->elf.def_regular
7072 || fdh == NULL
7073 || !fdh->elf.def_regular
7074 || fdh->elf.forced_local);
7075 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7076
7077 return TRUE;
7078 }
7079
7080 static const struct sfpr_def_parms save_res_funcs[] =
7081 {
7082 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7083 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7084 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7085 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7086 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7087 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7088 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7089 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7090 { "._savef", 14, 31, savefpr, savefpr1_tail },
7091 { "._restf", 14, 31, restfpr, restfpr1_tail },
7092 { "_savevr_", 20, 31, savevr, savevr_tail },
7093 { "_restvr_", 20, 31, restvr, restvr_tail }
7094 };
7095
7096 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7097 this hook to a) provide some gcc support functions, and b) transfer
7098 dynamic linking information gathered so far on function code symbol
7099 entries, to their corresponding function descriptor symbol entries. */
7100
7101 static bfd_boolean
7102 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7103 struct bfd_link_info *info)
7104 {
7105 struct ppc_link_hash_table *htab;
7106
7107 htab = ppc_hash_table (info);
7108 if (htab == NULL)
7109 return FALSE;
7110
7111 /* Provide any missing _save* and _rest* functions. */
7112 if (htab->sfpr != NULL)
7113 {
7114 unsigned int i;
7115
7116 htab->sfpr->size = 0;
7117 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7118 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7119 return FALSE;
7120 if (htab->sfpr->size == 0)
7121 htab->sfpr->flags |= SEC_EXCLUDE;
7122 }
7123
7124 if (bfd_link_relocatable (info))
7125 return TRUE;
7126
7127 if (htab->elf.hgot != NULL)
7128 {
7129 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7130 /* Make .TOC. defined so as to prevent it being made dynamic.
7131 The wrong value here is fixed later in ppc64_elf_set_toc. */
7132 if (!htab->elf.hgot->def_regular
7133 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7134 {
7135 htab->elf.hgot->root.type = bfd_link_hash_defined;
7136 htab->elf.hgot->root.u.def.value = 0;
7137 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7138 htab->elf.hgot->def_regular = 1;
7139 htab->elf.hgot->root.linker_def = 1;
7140 }
7141 htab->elf.hgot->type = STT_OBJECT;
7142 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7143 | STV_HIDDEN);
7144 }
7145
7146 if (htab->need_func_desc_adj)
7147 {
7148 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7149 htab->need_func_desc_adj = 0;
7150 }
7151
7152 return TRUE;
7153 }
7154
7155 /* Return true if we have dynamic relocs against H that apply to
7156 read-only sections. */
7157
7158 static bfd_boolean
7159 readonly_dynrelocs (struct elf_link_hash_entry *h)
7160 {
7161 struct ppc_link_hash_entry *eh;
7162 struct elf_dyn_relocs *p;
7163
7164 eh = (struct ppc_link_hash_entry *) h;
7165 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7166 {
7167 asection *s = p->sec->output_section;
7168
7169 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7170 return TRUE;
7171 }
7172 return FALSE;
7173 }
7174
7175 /* Return true if we have dynamic relocs against H or any of its weak
7176 aliases, that apply to read-only sections. */
7177
7178 static bfd_boolean
7179 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7180 {
7181 struct ppc_link_hash_entry *eh;
7182
7183 eh = (struct ppc_link_hash_entry *) h;
7184 do
7185 {
7186 if (readonly_dynrelocs (&eh->elf))
7187 return TRUE;
7188 eh = eh->weakref;
7189 } while (eh != NULL && &eh->elf != h);
7190
7191 return FALSE;
7192 }
7193
7194 /* Return whether EH has pc-relative dynamic relocs. */
7195
7196 static bfd_boolean
7197 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7198 {
7199 struct elf_dyn_relocs *p;
7200
7201 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7202 if (p->pc_count != 0)
7203 return TRUE;
7204 return FALSE;
7205 }
7206
7207 /* Return true if a global entry stub will be created for H. Valid
7208 for ELFv2 before plt entries have been allocated. */
7209
7210 static bfd_boolean
7211 global_entry_stub (struct elf_link_hash_entry *h)
7212 {
7213 struct plt_entry *pent;
7214
7215 if (!h->pointer_equality_needed
7216 || h->def_regular)
7217 return FALSE;
7218
7219 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7220 if (pent->plt.refcount > 0
7221 && pent->addend == 0)
7222 return TRUE;
7223
7224 return FALSE;
7225 }
7226
7227 /* Adjust a symbol defined by a dynamic object and referenced by a
7228 regular object. The current definition is in some section of the
7229 dynamic object, but we're not including those sections. We have to
7230 change the definition to something the rest of the link can
7231 understand. */
7232
7233 static bfd_boolean
7234 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7235 struct elf_link_hash_entry *h)
7236 {
7237 struct ppc_link_hash_table *htab;
7238 asection *s;
7239
7240 htab = ppc_hash_table (info);
7241 if (htab == NULL)
7242 return FALSE;
7243
7244 /* Deal with function syms. */
7245 if (h->type == STT_FUNC
7246 || h->type == STT_GNU_IFUNC
7247 || h->needs_plt)
7248 {
7249 /* Clear procedure linkage table information for any symbol that
7250 won't need a .plt entry. */
7251 struct plt_entry *ent;
7252 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7253 if (ent->plt.refcount > 0)
7254 break;
7255 if (ent == NULL
7256 || (h->type != STT_GNU_IFUNC
7257 && (SYMBOL_CALLS_LOCAL (info, h)
7258 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7259 && h->root.type == bfd_link_hash_undefweak)))
7260 || ((struct ppc_link_hash_entry *) h)->save_res)
7261 {
7262 h->plt.plist = NULL;
7263 h->needs_plt = 0;
7264 h->pointer_equality_needed = 0;
7265 }
7266 else if (abiversion (info->output_bfd) >= 2)
7267 {
7268 /* Taking a function's address in a read/write section
7269 doesn't require us to define the function symbol in the
7270 executable on a global entry stub. A dynamic reloc can
7271 be used instead. The reason we prefer a few more dynamic
7272 relocs is that calling via a global entry stub costs a
7273 few more instructions, and pointer_equality_needed causes
7274 extra work in ld.so when resolving these symbols. */
7275 if (global_entry_stub (h)
7276 && !alias_readonly_dynrelocs (h))
7277 {
7278 h->pointer_equality_needed = 0;
7279 /* After adjust_dynamic_symbol, non_got_ref set in
7280 the non-pic case means that dyn_relocs for this
7281 symbol should be discarded. */
7282 h->non_got_ref = 0;
7283 }
7284
7285 /* If making a plt entry, then we don't need copy relocs. */
7286 return TRUE;
7287 }
7288 }
7289 else
7290 h->plt.plist = NULL;
7291
7292 /* If this is a weak symbol, and there is a real definition, the
7293 processor independent code will have arranged for us to see the
7294 real definition first, and we can just use the same value. */
7295 if (h->u.weakdef != NULL)
7296 {
7297 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7298 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7299 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7300 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7301 if (ELIMINATE_COPY_RELOCS)
7302 h->non_got_ref = h->u.weakdef->non_got_ref;
7303 return TRUE;
7304 }
7305
7306 /* If we are creating a shared library, we must presume that the
7307 only references to the symbol are via the global offset table.
7308 For such cases we need not do anything here; the relocations will
7309 be handled correctly by relocate_section. */
7310 if (bfd_link_pic (info))
7311 return TRUE;
7312
7313 /* If there are no references to this symbol that do not use the
7314 GOT, we don't need to generate a copy reloc. */
7315 if (!h->non_got_ref)
7316 return TRUE;
7317
7318 /* Don't generate a copy reloc for symbols defined in the executable. */
7319 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7320
7321 /* If -z nocopyreloc was given, don't generate them either. */
7322 || info->nocopyreloc
7323
7324 /* If we didn't find any dynamic relocs in read-only sections, then
7325 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7326 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7327
7328 /* Protected variables do not work with .dynbss. The copy in
7329 .dynbss won't be used by the shared library with the protected
7330 definition for the variable. Text relocations are preferable
7331 to an incorrect program. */
7332 || h->protected_def)
7333 {
7334 h->non_got_ref = 0;
7335 return TRUE;
7336 }
7337
7338 if (h->plt.plist != NULL)
7339 {
7340 /* We should never get here, but unfortunately there are versions
7341 of gcc out there that improperly (for this ABI) put initialized
7342 function pointers, vtable refs and suchlike in read-only
7343 sections. Allow them to proceed, but warn that this might
7344 break at runtime. */
7345 info->callbacks->einfo
7346 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7347 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7348 h->root.root.string);
7349 }
7350
7351 /* This is a reference to a symbol defined by a dynamic object which
7352 is not a function. */
7353
7354 /* We must allocate the symbol in our .dynbss section, which will
7355 become part of the .bss section of the executable. There will be
7356 an entry for this symbol in the .dynsym section. The dynamic
7357 object will contain position independent code, so all references
7358 from the dynamic object to this symbol will go through the global
7359 offset table. The dynamic linker will use the .dynsym entry to
7360 determine the address it must put in the global offset table, so
7361 both the dynamic object and the regular object will refer to the
7362 same memory location for the variable. */
7363
7364 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7365 to copy the initial value out of the dynamic object and into the
7366 runtime process image. We need to remember the offset into the
7367 .rela.bss section we are going to use. */
7368 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7369 {
7370 htab->elf.srelbss->size += sizeof (Elf64_External_Rela);
7371 h->needs_copy = 1;
7372 }
7373
7374 s = htab->elf.sdynbss;
7375
7376 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7377 }
7378
7379 /* If given a function descriptor symbol, hide both the function code
7380 sym and the descriptor. */
7381 static void
7382 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7383 struct elf_link_hash_entry *h,
7384 bfd_boolean force_local)
7385 {
7386 struct ppc_link_hash_entry *eh;
7387 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7388
7389 eh = (struct ppc_link_hash_entry *) h;
7390 if (eh->is_func_descriptor)
7391 {
7392 struct ppc_link_hash_entry *fh = eh->oh;
7393
7394 if (fh == NULL)
7395 {
7396 const char *p, *q;
7397 struct elf_link_hash_table *htab = elf_hash_table (info);
7398 char save;
7399
7400 /* We aren't supposed to use alloca in BFD because on
7401 systems which do not have alloca the version in libiberty
7402 calls xmalloc, which might cause the program to crash
7403 when it runs out of memory. This function doesn't have a
7404 return status, so there's no way to gracefully return an
7405 error. So cheat. We know that string[-1] can be safely
7406 accessed; It's either a string in an ELF string table,
7407 or allocated in an objalloc structure. */
7408
7409 p = eh->elf.root.root.string - 1;
7410 save = *p;
7411 *(char *) p = '.';
7412 fh = (struct ppc_link_hash_entry *)
7413 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7414 *(char *) p = save;
7415
7416 /* Unfortunately, if it so happens that the string we were
7417 looking for was allocated immediately before this string,
7418 then we overwrote the string terminator. That's the only
7419 reason the lookup should fail. */
7420 if (fh == NULL)
7421 {
7422 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7423 while (q >= eh->elf.root.root.string && *q == *p)
7424 --q, --p;
7425 if (q < eh->elf.root.root.string && *p == '.')
7426 fh = (struct ppc_link_hash_entry *)
7427 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7428 }
7429 if (fh != NULL)
7430 {
7431 eh->oh = fh;
7432 fh->oh = eh;
7433 }
7434 }
7435 if (fh != NULL)
7436 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7437 }
7438 }
7439
7440 static bfd_boolean
7441 get_sym_h (struct elf_link_hash_entry **hp,
7442 Elf_Internal_Sym **symp,
7443 asection **symsecp,
7444 unsigned char **tls_maskp,
7445 Elf_Internal_Sym **locsymsp,
7446 unsigned long r_symndx,
7447 bfd *ibfd)
7448 {
7449 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7450
7451 if (r_symndx >= symtab_hdr->sh_info)
7452 {
7453 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7454 struct elf_link_hash_entry *h;
7455
7456 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7457 h = elf_follow_link (h);
7458
7459 if (hp != NULL)
7460 *hp = h;
7461
7462 if (symp != NULL)
7463 *symp = NULL;
7464
7465 if (symsecp != NULL)
7466 {
7467 asection *symsec = NULL;
7468 if (h->root.type == bfd_link_hash_defined
7469 || h->root.type == bfd_link_hash_defweak)
7470 symsec = h->root.u.def.section;
7471 *symsecp = symsec;
7472 }
7473
7474 if (tls_maskp != NULL)
7475 {
7476 struct ppc_link_hash_entry *eh;
7477
7478 eh = (struct ppc_link_hash_entry *) h;
7479 *tls_maskp = &eh->tls_mask;
7480 }
7481 }
7482 else
7483 {
7484 Elf_Internal_Sym *sym;
7485 Elf_Internal_Sym *locsyms = *locsymsp;
7486
7487 if (locsyms == NULL)
7488 {
7489 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7490 if (locsyms == NULL)
7491 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7492 symtab_hdr->sh_info,
7493 0, NULL, NULL, NULL);
7494 if (locsyms == NULL)
7495 return FALSE;
7496 *locsymsp = locsyms;
7497 }
7498 sym = locsyms + r_symndx;
7499
7500 if (hp != NULL)
7501 *hp = NULL;
7502
7503 if (symp != NULL)
7504 *symp = sym;
7505
7506 if (symsecp != NULL)
7507 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7508
7509 if (tls_maskp != NULL)
7510 {
7511 struct got_entry **lgot_ents;
7512 unsigned char *tls_mask;
7513
7514 tls_mask = NULL;
7515 lgot_ents = elf_local_got_ents (ibfd);
7516 if (lgot_ents != NULL)
7517 {
7518 struct plt_entry **local_plt = (struct plt_entry **)
7519 (lgot_ents + symtab_hdr->sh_info);
7520 unsigned char *lgot_masks = (unsigned char *)
7521 (local_plt + symtab_hdr->sh_info);
7522 tls_mask = &lgot_masks[r_symndx];
7523 }
7524 *tls_maskp = tls_mask;
7525 }
7526 }
7527 return TRUE;
7528 }
7529
7530 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7531 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7532 type suitable for optimization, and 1 otherwise. */
7533
7534 static int
7535 get_tls_mask (unsigned char **tls_maskp,
7536 unsigned long *toc_symndx,
7537 bfd_vma *toc_addend,
7538 Elf_Internal_Sym **locsymsp,
7539 const Elf_Internal_Rela *rel,
7540 bfd *ibfd)
7541 {
7542 unsigned long r_symndx;
7543 int next_r;
7544 struct elf_link_hash_entry *h;
7545 Elf_Internal_Sym *sym;
7546 asection *sec;
7547 bfd_vma off;
7548
7549 r_symndx = ELF64_R_SYM (rel->r_info);
7550 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7551 return 0;
7552
7553 if ((*tls_maskp != NULL && **tls_maskp != 0)
7554 || sec == NULL
7555 || ppc64_elf_section_data (sec) == NULL
7556 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7557 return 1;
7558
7559 /* Look inside a TOC section too. */
7560 if (h != NULL)
7561 {
7562 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7563 off = h->root.u.def.value;
7564 }
7565 else
7566 off = sym->st_value;
7567 off += rel->r_addend;
7568 BFD_ASSERT (off % 8 == 0);
7569 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7570 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7571 if (toc_symndx != NULL)
7572 *toc_symndx = r_symndx;
7573 if (toc_addend != NULL)
7574 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7575 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7576 return 0;
7577 if ((h == NULL || is_static_defined (h))
7578 && (next_r == -1 || next_r == -2))
7579 return 1 - next_r;
7580 return 1;
7581 }
7582
7583 /* Find (or create) an entry in the tocsave hash table. */
7584
7585 static struct tocsave_entry *
7586 tocsave_find (struct ppc_link_hash_table *htab,
7587 enum insert_option insert,
7588 Elf_Internal_Sym **local_syms,
7589 const Elf_Internal_Rela *irela,
7590 bfd *ibfd)
7591 {
7592 unsigned long r_indx;
7593 struct elf_link_hash_entry *h;
7594 Elf_Internal_Sym *sym;
7595 struct tocsave_entry ent, *p;
7596 hashval_t hash;
7597 struct tocsave_entry **slot;
7598
7599 r_indx = ELF64_R_SYM (irela->r_info);
7600 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7601 return NULL;
7602 if (ent.sec == NULL || ent.sec->output_section == NULL)
7603 {
7604 _bfd_error_handler
7605 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7606 return NULL;
7607 }
7608
7609 if (h != NULL)
7610 ent.offset = h->root.u.def.value;
7611 else
7612 ent.offset = sym->st_value;
7613 ent.offset += irela->r_addend;
7614
7615 hash = tocsave_htab_hash (&ent);
7616 slot = ((struct tocsave_entry **)
7617 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7618 if (slot == NULL)
7619 return NULL;
7620
7621 if (*slot == NULL)
7622 {
7623 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7624 if (p == NULL)
7625 return NULL;
7626 *p = ent;
7627 *slot = p;
7628 }
7629 return *slot;
7630 }
7631
7632 /* Adjust all global syms defined in opd sections. In gcc generated
7633 code for the old ABI, these will already have been done. */
7634
7635 static bfd_boolean
7636 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7637 {
7638 struct ppc_link_hash_entry *eh;
7639 asection *sym_sec;
7640 struct _opd_sec_data *opd;
7641
7642 if (h->root.type == bfd_link_hash_indirect)
7643 return TRUE;
7644
7645 if (h->root.type != bfd_link_hash_defined
7646 && h->root.type != bfd_link_hash_defweak)
7647 return TRUE;
7648
7649 eh = (struct ppc_link_hash_entry *) h;
7650 if (eh->adjust_done)
7651 return TRUE;
7652
7653 sym_sec = eh->elf.root.u.def.section;
7654 opd = get_opd_info (sym_sec);
7655 if (opd != NULL && opd->adjust != NULL)
7656 {
7657 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7658 if (adjust == -1)
7659 {
7660 /* This entry has been deleted. */
7661 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7662 if (dsec == NULL)
7663 {
7664 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7665 if (discarded_section (dsec))
7666 {
7667 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7668 break;
7669 }
7670 }
7671 eh->elf.root.u.def.value = 0;
7672 eh->elf.root.u.def.section = dsec;
7673 }
7674 else
7675 eh->elf.root.u.def.value += adjust;
7676 eh->adjust_done = 1;
7677 }
7678 return TRUE;
7679 }
7680
7681 /* Handles decrementing dynamic reloc counts for the reloc specified by
7682 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7683 have already been determined. */
7684
7685 static bfd_boolean
7686 dec_dynrel_count (bfd_vma r_info,
7687 asection *sec,
7688 struct bfd_link_info *info,
7689 Elf_Internal_Sym **local_syms,
7690 struct elf_link_hash_entry *h,
7691 Elf_Internal_Sym *sym)
7692 {
7693 enum elf_ppc64_reloc_type r_type;
7694 asection *sym_sec = NULL;
7695
7696 /* Can this reloc be dynamic? This switch, and later tests here
7697 should be kept in sync with the code in check_relocs. */
7698 r_type = ELF64_R_TYPE (r_info);
7699 switch (r_type)
7700 {
7701 default:
7702 return TRUE;
7703
7704 case R_PPC64_TPREL16:
7705 case R_PPC64_TPREL16_LO:
7706 case R_PPC64_TPREL16_HI:
7707 case R_PPC64_TPREL16_HA:
7708 case R_PPC64_TPREL16_DS:
7709 case R_PPC64_TPREL16_LO_DS:
7710 case R_PPC64_TPREL16_HIGH:
7711 case R_PPC64_TPREL16_HIGHA:
7712 case R_PPC64_TPREL16_HIGHER:
7713 case R_PPC64_TPREL16_HIGHERA:
7714 case R_PPC64_TPREL16_HIGHEST:
7715 case R_PPC64_TPREL16_HIGHESTA:
7716 if (!bfd_link_pic (info))
7717 return TRUE;
7718
7719 case R_PPC64_TPREL64:
7720 case R_PPC64_DTPMOD64:
7721 case R_PPC64_DTPREL64:
7722 case R_PPC64_ADDR64:
7723 case R_PPC64_REL30:
7724 case R_PPC64_REL32:
7725 case R_PPC64_REL64:
7726 case R_PPC64_ADDR14:
7727 case R_PPC64_ADDR14_BRNTAKEN:
7728 case R_PPC64_ADDR14_BRTAKEN:
7729 case R_PPC64_ADDR16:
7730 case R_PPC64_ADDR16_DS:
7731 case R_PPC64_ADDR16_HA:
7732 case R_PPC64_ADDR16_HI:
7733 case R_PPC64_ADDR16_HIGH:
7734 case R_PPC64_ADDR16_HIGHA:
7735 case R_PPC64_ADDR16_HIGHER:
7736 case R_PPC64_ADDR16_HIGHERA:
7737 case R_PPC64_ADDR16_HIGHEST:
7738 case R_PPC64_ADDR16_HIGHESTA:
7739 case R_PPC64_ADDR16_LO:
7740 case R_PPC64_ADDR16_LO_DS:
7741 case R_PPC64_ADDR24:
7742 case R_PPC64_ADDR32:
7743 case R_PPC64_UADDR16:
7744 case R_PPC64_UADDR32:
7745 case R_PPC64_UADDR64:
7746 case R_PPC64_TOC:
7747 break;
7748 }
7749
7750 if (local_syms != NULL)
7751 {
7752 unsigned long r_symndx;
7753 bfd *ibfd = sec->owner;
7754
7755 r_symndx = ELF64_R_SYM (r_info);
7756 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7757 return FALSE;
7758 }
7759
7760 if ((bfd_link_pic (info)
7761 && (must_be_dyn_reloc (info, r_type)
7762 || (h != NULL
7763 && (!SYMBOLIC_BIND (info, h)
7764 || h->root.type == bfd_link_hash_defweak
7765 || !h->def_regular))))
7766 || (ELIMINATE_COPY_RELOCS
7767 && !bfd_link_pic (info)
7768 && h != NULL
7769 && (h->root.type == bfd_link_hash_defweak
7770 || !h->def_regular)))
7771 ;
7772 else
7773 return TRUE;
7774
7775 if (h != NULL)
7776 {
7777 struct elf_dyn_relocs *p;
7778 struct elf_dyn_relocs **pp;
7779 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7780
7781 /* elf_gc_sweep may have already removed all dyn relocs associated
7782 with local syms for a given section. Also, symbol flags are
7783 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7784 report a dynreloc miscount. */
7785 if (*pp == NULL && info->gc_sections)
7786 return TRUE;
7787
7788 while ((p = *pp) != NULL)
7789 {
7790 if (p->sec == sec)
7791 {
7792 if (!must_be_dyn_reloc (info, r_type))
7793 p->pc_count -= 1;
7794 p->count -= 1;
7795 if (p->count == 0)
7796 *pp = p->next;
7797 return TRUE;
7798 }
7799 pp = &p->next;
7800 }
7801 }
7802 else
7803 {
7804 struct ppc_dyn_relocs *p;
7805 struct ppc_dyn_relocs **pp;
7806 void *vpp;
7807 bfd_boolean is_ifunc;
7808
7809 if (local_syms == NULL)
7810 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7811 if (sym_sec == NULL)
7812 sym_sec = sec;
7813
7814 vpp = &elf_section_data (sym_sec)->local_dynrel;
7815 pp = (struct ppc_dyn_relocs **) vpp;
7816
7817 if (*pp == NULL && info->gc_sections)
7818 return TRUE;
7819
7820 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7821 while ((p = *pp) != NULL)
7822 {
7823 if (p->sec == sec && p->ifunc == is_ifunc)
7824 {
7825 p->count -= 1;
7826 if (p->count == 0)
7827 *pp = p->next;
7828 return TRUE;
7829 }
7830 pp = &p->next;
7831 }
7832 }
7833
7834 /* xgettext:c-format */
7835 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7836 sec->owner, sec);
7837 bfd_set_error (bfd_error_bad_value);
7838 return FALSE;
7839 }
7840
7841 /* Remove unused Official Procedure Descriptor entries. Currently we
7842 only remove those associated with functions in discarded link-once
7843 sections, or weakly defined functions that have been overridden. It
7844 would be possible to remove many more entries for statically linked
7845 applications. */
7846
7847 bfd_boolean
7848 ppc64_elf_edit_opd (struct bfd_link_info *info)
7849 {
7850 bfd *ibfd;
7851 bfd_boolean some_edited = FALSE;
7852 asection *need_pad = NULL;
7853 struct ppc_link_hash_table *htab;
7854
7855 htab = ppc_hash_table (info);
7856 if (htab == NULL)
7857 return FALSE;
7858
7859 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7860 {
7861 asection *sec;
7862 Elf_Internal_Rela *relstart, *rel, *relend;
7863 Elf_Internal_Shdr *symtab_hdr;
7864 Elf_Internal_Sym *local_syms;
7865 struct _opd_sec_data *opd;
7866 bfd_boolean need_edit, add_aux_fields, broken;
7867 bfd_size_type cnt_16b = 0;
7868
7869 if (!is_ppc64_elf (ibfd))
7870 continue;
7871
7872 sec = bfd_get_section_by_name (ibfd, ".opd");
7873 if (sec == NULL || sec->size == 0)
7874 continue;
7875
7876 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7877 continue;
7878
7879 if (sec->output_section == bfd_abs_section_ptr)
7880 continue;
7881
7882 /* Look through the section relocs. */
7883 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7884 continue;
7885
7886 local_syms = NULL;
7887 symtab_hdr = &elf_symtab_hdr (ibfd);
7888
7889 /* Read the relocations. */
7890 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7891 info->keep_memory);
7892 if (relstart == NULL)
7893 return FALSE;
7894
7895 /* First run through the relocs to check they are sane, and to
7896 determine whether we need to edit this opd section. */
7897 need_edit = FALSE;
7898 broken = FALSE;
7899 need_pad = sec;
7900 relend = relstart + sec->reloc_count;
7901 for (rel = relstart; rel < relend; )
7902 {
7903 enum elf_ppc64_reloc_type r_type;
7904 unsigned long r_symndx;
7905 asection *sym_sec;
7906 struct elf_link_hash_entry *h;
7907 Elf_Internal_Sym *sym;
7908 bfd_vma offset;
7909
7910 /* .opd contains an array of 16 or 24 byte entries. We're
7911 only interested in the reloc pointing to a function entry
7912 point. */
7913 offset = rel->r_offset;
7914 if (rel + 1 == relend
7915 || rel[1].r_offset != offset + 8)
7916 {
7917 /* If someone messes with .opd alignment then after a
7918 "ld -r" we might have padding in the middle of .opd.
7919 Also, there's nothing to prevent someone putting
7920 something silly in .opd with the assembler. No .opd
7921 optimization for them! */
7922 broken_opd:
7923 _bfd_error_handler
7924 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7925 broken = TRUE;
7926 break;
7927 }
7928
7929 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7930 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7931 {
7932 _bfd_error_handler
7933 /* xgettext:c-format */
7934 (_("%B: unexpected reloc type %u in .opd section"),
7935 ibfd, r_type);
7936 broken = TRUE;
7937 break;
7938 }
7939
7940 r_symndx = ELF64_R_SYM (rel->r_info);
7941 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7942 r_symndx, ibfd))
7943 goto error_ret;
7944
7945 if (sym_sec == NULL || sym_sec->owner == NULL)
7946 {
7947 const char *sym_name;
7948 if (h != NULL)
7949 sym_name = h->root.root.string;
7950 else
7951 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7952 sym_sec);
7953
7954 _bfd_error_handler
7955 /* xgettext:c-format */
7956 (_("%B: undefined sym `%s' in .opd section"),
7957 ibfd, sym_name);
7958 broken = TRUE;
7959 break;
7960 }
7961
7962 /* opd entries are always for functions defined in the
7963 current input bfd. If the symbol isn't defined in the
7964 input bfd, then we won't be using the function in this
7965 bfd; It must be defined in a linkonce section in another
7966 bfd, or is weak. It's also possible that we are
7967 discarding the function due to a linker script /DISCARD/,
7968 which we test for via the output_section. */
7969 if (sym_sec->owner != ibfd
7970 || sym_sec->output_section == bfd_abs_section_ptr)
7971 need_edit = TRUE;
7972
7973 rel += 2;
7974 if (rel + 1 == relend
7975 || (rel + 2 < relend
7976 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7977 ++rel;
7978
7979 if (rel == relend)
7980 {
7981 if (sec->size == offset + 24)
7982 {
7983 need_pad = NULL;
7984 break;
7985 }
7986 if (sec->size == offset + 16)
7987 {
7988 cnt_16b++;
7989 break;
7990 }
7991 goto broken_opd;
7992 }
7993 else if (rel + 1 < relend
7994 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7995 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7996 {
7997 if (rel[0].r_offset == offset + 16)
7998 cnt_16b++;
7999 else if (rel[0].r_offset != offset + 24)
8000 goto broken_opd;
8001 }
8002 else
8003 goto broken_opd;
8004 }
8005
8006 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8007
8008 if (!broken && (need_edit || add_aux_fields))
8009 {
8010 Elf_Internal_Rela *write_rel;
8011 Elf_Internal_Shdr *rel_hdr;
8012 bfd_byte *rptr, *wptr;
8013 bfd_byte *new_contents;
8014 bfd_size_type amt;
8015
8016 new_contents = NULL;
8017 amt = OPD_NDX (sec->size) * sizeof (long);
8018 opd = &ppc64_elf_section_data (sec)->u.opd;
8019 opd->adjust = bfd_zalloc (sec->owner, amt);
8020 if (opd->adjust == NULL)
8021 return FALSE;
8022 ppc64_elf_section_data (sec)->sec_type = sec_opd;
8023
8024 /* This seems a waste of time as input .opd sections are all
8025 zeros as generated by gcc, but I suppose there's no reason
8026 this will always be so. We might start putting something in
8027 the third word of .opd entries. */
8028 if ((sec->flags & SEC_IN_MEMORY) == 0)
8029 {
8030 bfd_byte *loc;
8031 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8032 {
8033 if (loc != NULL)
8034 free (loc);
8035 error_ret:
8036 if (local_syms != NULL
8037 && symtab_hdr->contents != (unsigned char *) local_syms)
8038 free (local_syms);
8039 if (elf_section_data (sec)->relocs != relstart)
8040 free (relstart);
8041 return FALSE;
8042 }
8043 sec->contents = loc;
8044 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8045 }
8046
8047 elf_section_data (sec)->relocs = relstart;
8048
8049 new_contents = sec->contents;
8050 if (add_aux_fields)
8051 {
8052 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8053 if (new_contents == NULL)
8054 return FALSE;
8055 need_pad = NULL;
8056 }
8057 wptr = new_contents;
8058 rptr = sec->contents;
8059 write_rel = relstart;
8060 for (rel = relstart; rel < relend; )
8061 {
8062 unsigned long r_symndx;
8063 asection *sym_sec;
8064 struct elf_link_hash_entry *h;
8065 struct ppc_link_hash_entry *fdh = NULL;
8066 Elf_Internal_Sym *sym;
8067 long opd_ent_size;
8068 Elf_Internal_Rela *next_rel;
8069 bfd_boolean skip;
8070
8071 r_symndx = ELF64_R_SYM (rel->r_info);
8072 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8073 r_symndx, ibfd))
8074 goto error_ret;
8075
8076 next_rel = rel + 2;
8077 if (next_rel + 1 == relend
8078 || (next_rel + 2 < relend
8079 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8080 ++next_rel;
8081
8082 /* See if the .opd entry is full 24 byte or
8083 16 byte (with fd_aux entry overlapped with next
8084 fd_func). */
8085 opd_ent_size = 24;
8086 if (next_rel == relend)
8087 {
8088 if (sec->size == rel->r_offset + 16)
8089 opd_ent_size = 16;
8090 }
8091 else if (next_rel->r_offset == rel->r_offset + 16)
8092 opd_ent_size = 16;
8093
8094 if (h != NULL
8095 && h->root.root.string[0] == '.')
8096 {
8097 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8098 if (fdh != NULL)
8099 {
8100 fdh = ppc_follow_link (fdh);
8101 if (fdh->elf.root.type != bfd_link_hash_defined
8102 && fdh->elf.root.type != bfd_link_hash_defweak)
8103 fdh = NULL;
8104 }
8105 }
8106
8107 skip = (sym_sec->owner != ibfd
8108 || sym_sec->output_section == bfd_abs_section_ptr);
8109 if (skip)
8110 {
8111 if (fdh != NULL && sym_sec->owner == ibfd)
8112 {
8113 /* Arrange for the function descriptor sym
8114 to be dropped. */
8115 fdh->elf.root.u.def.value = 0;
8116 fdh->elf.root.u.def.section = sym_sec;
8117 }
8118 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8119
8120 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8121 rel = next_rel;
8122 else
8123 while (1)
8124 {
8125 if (!dec_dynrel_count (rel->r_info, sec, info,
8126 NULL, h, sym))
8127 goto error_ret;
8128
8129 if (++rel == next_rel)
8130 break;
8131
8132 r_symndx = ELF64_R_SYM (rel->r_info);
8133 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8134 r_symndx, ibfd))
8135 goto error_ret;
8136 }
8137 }
8138 else
8139 {
8140 /* We'll be keeping this opd entry. */
8141 long adjust;
8142
8143 if (fdh != NULL)
8144 {
8145 /* Redefine the function descriptor symbol to
8146 this location in the opd section. It is
8147 necessary to update the value here rather
8148 than using an array of adjustments as we do
8149 for local symbols, because various places
8150 in the generic ELF code use the value
8151 stored in u.def.value. */
8152 fdh->elf.root.u.def.value = wptr - new_contents;
8153 fdh->adjust_done = 1;
8154 }
8155
8156 /* Local syms are a bit tricky. We could
8157 tweak them as they can be cached, but
8158 we'd need to look through the local syms
8159 for the function descriptor sym which we
8160 don't have at the moment. So keep an
8161 array of adjustments. */
8162 adjust = (wptr - new_contents) - (rptr - sec->contents);
8163 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8164
8165 if (wptr != rptr)
8166 memcpy (wptr, rptr, opd_ent_size);
8167 wptr += opd_ent_size;
8168 if (add_aux_fields && opd_ent_size == 16)
8169 {
8170 memset (wptr, '\0', 8);
8171 wptr += 8;
8172 }
8173
8174 /* We need to adjust any reloc offsets to point to the
8175 new opd entries. */
8176 for ( ; rel != next_rel; ++rel)
8177 {
8178 rel->r_offset += adjust;
8179 if (write_rel != rel)
8180 memcpy (write_rel, rel, sizeof (*rel));
8181 ++write_rel;
8182 }
8183 }
8184
8185 rptr += opd_ent_size;
8186 }
8187
8188 sec->size = wptr - new_contents;
8189 sec->reloc_count = write_rel - relstart;
8190 if (add_aux_fields)
8191 {
8192 free (sec->contents);
8193 sec->contents = new_contents;
8194 }
8195
8196 /* Fudge the header size too, as this is used later in
8197 elf_bfd_final_link if we are emitting relocs. */
8198 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8199 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8200 some_edited = TRUE;
8201 }
8202 else if (elf_section_data (sec)->relocs != relstart)
8203 free (relstart);
8204
8205 if (local_syms != NULL
8206 && symtab_hdr->contents != (unsigned char *) local_syms)
8207 {
8208 if (!info->keep_memory)
8209 free (local_syms);
8210 else
8211 symtab_hdr->contents = (unsigned char *) local_syms;
8212 }
8213 }
8214
8215 if (some_edited)
8216 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8217
8218 /* If we are doing a final link and the last .opd entry is just 16 byte
8219 long, add a 8 byte padding after it. */
8220 if (need_pad != NULL && !bfd_link_relocatable (info))
8221 {
8222 bfd_byte *p;
8223
8224 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8225 {
8226 BFD_ASSERT (need_pad->size > 0);
8227
8228 p = bfd_malloc (need_pad->size + 8);
8229 if (p == NULL)
8230 return FALSE;
8231
8232 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8233 p, 0, need_pad->size))
8234 return FALSE;
8235
8236 need_pad->contents = p;
8237 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8238 }
8239 else
8240 {
8241 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8242 if (p == NULL)
8243 return FALSE;
8244
8245 need_pad->contents = p;
8246 }
8247
8248 memset (need_pad->contents + need_pad->size, 0, 8);
8249 need_pad->size += 8;
8250 }
8251
8252 return TRUE;
8253 }
8254
8255 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8256
8257 asection *
8258 ppc64_elf_tls_setup (struct bfd_link_info *info)
8259 {
8260 struct ppc_link_hash_table *htab;
8261
8262 htab = ppc_hash_table (info);
8263 if (htab == NULL)
8264 return NULL;
8265
8266 if (abiversion (info->output_bfd) == 1)
8267 htab->opd_abi = 1;
8268
8269 if (htab->params->no_multi_toc)
8270 htab->do_multi_toc = 0;
8271 else if (!htab->do_multi_toc)
8272 htab->params->no_multi_toc = 1;
8273
8274 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8275 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8276 FALSE, FALSE, TRUE));
8277 /* Move dynamic linking info to the function descriptor sym. */
8278 if (htab->tls_get_addr != NULL)
8279 func_desc_adjust (&htab->tls_get_addr->elf, info);
8280 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8281 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8282 FALSE, FALSE, TRUE));
8283 if (htab->params->tls_get_addr_opt)
8284 {
8285 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8286
8287 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8288 FALSE, FALSE, TRUE);
8289 if (opt != NULL)
8290 func_desc_adjust (opt, info);
8291 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8292 FALSE, FALSE, TRUE);
8293 if (opt_fd != NULL
8294 && (opt_fd->root.type == bfd_link_hash_defined
8295 || opt_fd->root.type == bfd_link_hash_defweak))
8296 {
8297 /* If glibc supports an optimized __tls_get_addr call stub,
8298 signalled by the presence of __tls_get_addr_opt, and we'll
8299 be calling __tls_get_addr via a plt call stub, then
8300 make __tls_get_addr point to __tls_get_addr_opt. */
8301 tga_fd = &htab->tls_get_addr_fd->elf;
8302 if (htab->elf.dynamic_sections_created
8303 && tga_fd != NULL
8304 && (tga_fd->type == STT_FUNC
8305 || tga_fd->needs_plt)
8306 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8307 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8308 && tga_fd->root.type == bfd_link_hash_undefweak)))
8309 {
8310 struct plt_entry *ent;
8311
8312 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8313 if (ent->plt.refcount > 0)
8314 break;
8315 if (ent != NULL)
8316 {
8317 tga_fd->root.type = bfd_link_hash_indirect;
8318 tga_fd->root.u.i.link = &opt_fd->root;
8319 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8320 opt_fd->forced_local = 0;
8321 if (opt_fd->dynindx != -1)
8322 {
8323 /* Use __tls_get_addr_opt in dynamic relocations. */
8324 opt_fd->dynindx = -1;
8325 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8326 opt_fd->dynstr_index);
8327 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8328 return NULL;
8329 }
8330 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8331 tga = &htab->tls_get_addr->elf;
8332 if (opt != NULL && tga != NULL)
8333 {
8334 tga->root.type = bfd_link_hash_indirect;
8335 tga->root.u.i.link = &opt->root;
8336 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8337 opt->forced_local = 0;
8338 _bfd_elf_link_hash_hide_symbol (info, opt,
8339 tga->forced_local);
8340 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8341 }
8342 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8343 htab->tls_get_addr_fd->is_func_descriptor = 1;
8344 if (htab->tls_get_addr != NULL)
8345 {
8346 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8347 htab->tls_get_addr->is_func = 1;
8348 }
8349 }
8350 }
8351 }
8352 else if (htab->params->tls_get_addr_opt < 0)
8353 htab->params->tls_get_addr_opt = 0;
8354 }
8355 return _bfd_elf_tls_setup (info->output_bfd, info);
8356 }
8357
8358 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8359 HASH1 or HASH2. */
8360
8361 static bfd_boolean
8362 branch_reloc_hash_match (const bfd *ibfd,
8363 const Elf_Internal_Rela *rel,
8364 const struct ppc_link_hash_entry *hash1,
8365 const struct ppc_link_hash_entry *hash2)
8366 {
8367 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8368 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8369 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8370
8371 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8372 {
8373 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8374 struct elf_link_hash_entry *h;
8375
8376 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8377 h = elf_follow_link (h);
8378 if (h == &hash1->elf || h == &hash2->elf)
8379 return TRUE;
8380 }
8381 return FALSE;
8382 }
8383
8384 /* Run through all the TLS relocs looking for optimization
8385 opportunities. The linker has been hacked (see ppc64elf.em) to do
8386 a preliminary section layout so that we know the TLS segment
8387 offsets. We can't optimize earlier because some optimizations need
8388 to know the tp offset, and we need to optimize before allocating
8389 dynamic relocations. */
8390
8391 bfd_boolean
8392 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8393 {
8394 bfd *ibfd;
8395 asection *sec;
8396 struct ppc_link_hash_table *htab;
8397 unsigned char *toc_ref;
8398 int pass;
8399
8400 if (!bfd_link_executable (info))
8401 return TRUE;
8402
8403 htab = ppc_hash_table (info);
8404 if (htab == NULL)
8405 return FALSE;
8406
8407 /* Make two passes over the relocs. On the first pass, mark toc
8408 entries involved with tls relocs, and check that tls relocs
8409 involved in setting up a tls_get_addr call are indeed followed by
8410 such a call. If they are not, we can't do any tls optimization.
8411 On the second pass twiddle tls_mask flags to notify
8412 relocate_section that optimization can be done, and adjust got
8413 and plt refcounts. */
8414 toc_ref = NULL;
8415 for (pass = 0; pass < 2; ++pass)
8416 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8417 {
8418 Elf_Internal_Sym *locsyms = NULL;
8419 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8420
8421 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8422 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8423 {
8424 Elf_Internal_Rela *relstart, *rel, *relend;
8425 bfd_boolean found_tls_get_addr_arg = 0;
8426
8427 /* Read the relocations. */
8428 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8429 info->keep_memory);
8430 if (relstart == NULL)
8431 {
8432 free (toc_ref);
8433 return FALSE;
8434 }
8435
8436 relend = relstart + sec->reloc_count;
8437 for (rel = relstart; rel < relend; rel++)
8438 {
8439 enum elf_ppc64_reloc_type r_type;
8440 unsigned long r_symndx;
8441 struct elf_link_hash_entry *h;
8442 Elf_Internal_Sym *sym;
8443 asection *sym_sec;
8444 unsigned char *tls_mask;
8445 unsigned char tls_set, tls_clear, tls_type = 0;
8446 bfd_vma value;
8447 bfd_boolean ok_tprel, is_local;
8448 long toc_ref_index = 0;
8449 int expecting_tls_get_addr = 0;
8450 bfd_boolean ret = FALSE;
8451
8452 r_symndx = ELF64_R_SYM (rel->r_info);
8453 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8454 r_symndx, ibfd))
8455 {
8456 err_free_rel:
8457 if (elf_section_data (sec)->relocs != relstart)
8458 free (relstart);
8459 if (toc_ref != NULL)
8460 free (toc_ref);
8461 if (locsyms != NULL
8462 && (elf_symtab_hdr (ibfd).contents
8463 != (unsigned char *) locsyms))
8464 free (locsyms);
8465 return ret;
8466 }
8467
8468 if (h != NULL)
8469 {
8470 if (h->root.type == bfd_link_hash_defined
8471 || h->root.type == bfd_link_hash_defweak)
8472 value = h->root.u.def.value;
8473 else if (h->root.type == bfd_link_hash_undefweak)
8474 value = 0;
8475 else
8476 {
8477 found_tls_get_addr_arg = 0;
8478 continue;
8479 }
8480 }
8481 else
8482 /* Symbols referenced by TLS relocs must be of type
8483 STT_TLS. So no need for .opd local sym adjust. */
8484 value = sym->st_value;
8485
8486 ok_tprel = FALSE;
8487 is_local = FALSE;
8488 if (h == NULL
8489 || !h->def_dynamic)
8490 {
8491 is_local = TRUE;
8492 if (h != NULL
8493 && h->root.type == bfd_link_hash_undefweak)
8494 ok_tprel = TRUE;
8495 else if (sym_sec != NULL
8496 && sym_sec->output_section != NULL)
8497 {
8498 value += sym_sec->output_offset;
8499 value += sym_sec->output_section->vma;
8500 value -= htab->elf.tls_sec->vma;
8501 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8502 < (bfd_vma) 1 << 32);
8503 }
8504 }
8505
8506 r_type = ELF64_R_TYPE (rel->r_info);
8507 /* If this section has old-style __tls_get_addr calls
8508 without marker relocs, then check that each
8509 __tls_get_addr call reloc is preceded by a reloc
8510 that conceivably belongs to the __tls_get_addr arg
8511 setup insn. If we don't find matching arg setup
8512 relocs, don't do any tls optimization. */
8513 if (pass == 0
8514 && sec->has_tls_get_addr_call
8515 && h != NULL
8516 && (h == &htab->tls_get_addr->elf
8517 || h == &htab->tls_get_addr_fd->elf)
8518 && !found_tls_get_addr_arg
8519 && is_branch_reloc (r_type))
8520 {
8521 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8522 "TLS optimization disabled\n"),
8523 ibfd, sec, rel->r_offset);
8524 ret = TRUE;
8525 goto err_free_rel;
8526 }
8527
8528 found_tls_get_addr_arg = 0;
8529 switch (r_type)
8530 {
8531 case R_PPC64_GOT_TLSLD16:
8532 case R_PPC64_GOT_TLSLD16_LO:
8533 expecting_tls_get_addr = 1;
8534 found_tls_get_addr_arg = 1;
8535 /* Fall through. */
8536
8537 case R_PPC64_GOT_TLSLD16_HI:
8538 case R_PPC64_GOT_TLSLD16_HA:
8539 /* These relocs should never be against a symbol
8540 defined in a shared lib. Leave them alone if
8541 that turns out to be the case. */
8542 if (!is_local)
8543 continue;
8544
8545 /* LD -> LE */
8546 tls_set = 0;
8547 tls_clear = TLS_LD;
8548 tls_type = TLS_TLS | TLS_LD;
8549 break;
8550
8551 case R_PPC64_GOT_TLSGD16:
8552 case R_PPC64_GOT_TLSGD16_LO:
8553 expecting_tls_get_addr = 1;
8554 found_tls_get_addr_arg = 1;
8555 /* Fall through. */
8556
8557 case R_PPC64_GOT_TLSGD16_HI:
8558 case R_PPC64_GOT_TLSGD16_HA:
8559 if (ok_tprel)
8560 /* GD -> LE */
8561 tls_set = 0;
8562 else
8563 /* GD -> IE */
8564 tls_set = TLS_TLS | TLS_TPRELGD;
8565 tls_clear = TLS_GD;
8566 tls_type = TLS_TLS | TLS_GD;
8567 break;
8568
8569 case R_PPC64_GOT_TPREL16_DS:
8570 case R_PPC64_GOT_TPREL16_LO_DS:
8571 case R_PPC64_GOT_TPREL16_HI:
8572 case R_PPC64_GOT_TPREL16_HA:
8573 if (ok_tprel)
8574 {
8575 /* IE -> LE */
8576 tls_set = 0;
8577 tls_clear = TLS_TPREL;
8578 tls_type = TLS_TLS | TLS_TPREL;
8579 break;
8580 }
8581 continue;
8582
8583 case R_PPC64_TLSGD:
8584 case R_PPC64_TLSLD:
8585 found_tls_get_addr_arg = 1;
8586 /* Fall through. */
8587
8588 case R_PPC64_TLS:
8589 case R_PPC64_TOC16:
8590 case R_PPC64_TOC16_LO:
8591 if (sym_sec == NULL || sym_sec != toc)
8592 continue;
8593
8594 /* Mark this toc entry as referenced by a TLS
8595 code sequence. We can do that now in the
8596 case of R_PPC64_TLS, and after checking for
8597 tls_get_addr for the TOC16 relocs. */
8598 if (toc_ref == NULL)
8599 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8600 if (toc_ref == NULL)
8601 goto err_free_rel;
8602
8603 if (h != NULL)
8604 value = h->root.u.def.value;
8605 else
8606 value = sym->st_value;
8607 value += rel->r_addend;
8608 if (value % 8 != 0)
8609 continue;
8610 BFD_ASSERT (value < toc->size
8611 && toc->output_offset % 8 == 0);
8612 toc_ref_index = (value + toc->output_offset) / 8;
8613 if (r_type == R_PPC64_TLS
8614 || r_type == R_PPC64_TLSGD
8615 || r_type == R_PPC64_TLSLD)
8616 {
8617 toc_ref[toc_ref_index] = 1;
8618 continue;
8619 }
8620
8621 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8622 continue;
8623
8624 tls_set = 0;
8625 tls_clear = 0;
8626 expecting_tls_get_addr = 2;
8627 break;
8628
8629 case R_PPC64_TPREL64:
8630 if (pass == 0
8631 || sec != toc
8632 || toc_ref == NULL
8633 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8634 continue;
8635 if (ok_tprel)
8636 {
8637 /* IE -> LE */
8638 tls_set = TLS_EXPLICIT;
8639 tls_clear = TLS_TPREL;
8640 break;
8641 }
8642 continue;
8643
8644 case R_PPC64_DTPMOD64:
8645 if (pass == 0
8646 || sec != toc
8647 || toc_ref == NULL
8648 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8649 continue;
8650 if (rel + 1 < relend
8651 && (rel[1].r_info
8652 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8653 && rel[1].r_offset == rel->r_offset + 8)
8654 {
8655 if (ok_tprel)
8656 /* GD -> LE */
8657 tls_set = TLS_EXPLICIT | TLS_GD;
8658 else
8659 /* GD -> IE */
8660 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8661 tls_clear = TLS_GD;
8662 }
8663 else
8664 {
8665 if (!is_local)
8666 continue;
8667
8668 /* LD -> LE */
8669 tls_set = TLS_EXPLICIT;
8670 tls_clear = TLS_LD;
8671 }
8672 break;
8673
8674 default:
8675 continue;
8676 }
8677
8678 if (pass == 0)
8679 {
8680 if (!expecting_tls_get_addr
8681 || !sec->has_tls_get_addr_call)
8682 continue;
8683
8684 if (rel + 1 < relend
8685 && branch_reloc_hash_match (ibfd, rel + 1,
8686 htab->tls_get_addr,
8687 htab->tls_get_addr_fd))
8688 {
8689 if (expecting_tls_get_addr == 2)
8690 {
8691 /* Check for toc tls entries. */
8692 unsigned char *toc_tls;
8693 int retval;
8694
8695 retval = get_tls_mask (&toc_tls, NULL, NULL,
8696 &locsyms,
8697 rel, ibfd);
8698 if (retval == 0)
8699 goto err_free_rel;
8700 if (toc_tls != NULL)
8701 {
8702 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8703 found_tls_get_addr_arg = 1;
8704 if (retval > 1)
8705 toc_ref[toc_ref_index] = 1;
8706 }
8707 }
8708 continue;
8709 }
8710
8711 if (expecting_tls_get_addr != 1)
8712 continue;
8713
8714 /* Uh oh, we didn't find the expected call. We
8715 could just mark this symbol to exclude it
8716 from tls optimization but it's safer to skip
8717 the entire optimization. */
8718 /* xgettext:c-format */
8719 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8720 "TLS optimization disabled\n"),
8721 ibfd, sec, rel->r_offset);
8722 ret = TRUE;
8723 goto err_free_rel;
8724 }
8725
8726 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8727 {
8728 struct plt_entry *ent;
8729 for (ent = htab->tls_get_addr->elf.plt.plist;
8730 ent != NULL;
8731 ent = ent->next)
8732 if (ent->addend == 0)
8733 {
8734 if (ent->plt.refcount > 0)
8735 {
8736 ent->plt.refcount -= 1;
8737 expecting_tls_get_addr = 0;
8738 }
8739 break;
8740 }
8741 }
8742
8743 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8744 {
8745 struct plt_entry *ent;
8746 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8747 ent != NULL;
8748 ent = ent->next)
8749 if (ent->addend == 0)
8750 {
8751 if (ent->plt.refcount > 0)
8752 ent->plt.refcount -= 1;
8753 break;
8754 }
8755 }
8756
8757 if (tls_clear == 0)
8758 continue;
8759
8760 if ((tls_set & TLS_EXPLICIT) == 0)
8761 {
8762 struct got_entry *ent;
8763
8764 /* Adjust got entry for this reloc. */
8765 if (h != NULL)
8766 ent = h->got.glist;
8767 else
8768 ent = elf_local_got_ents (ibfd)[r_symndx];
8769
8770 for (; ent != NULL; ent = ent->next)
8771 if (ent->addend == rel->r_addend
8772 && ent->owner == ibfd
8773 && ent->tls_type == tls_type)
8774 break;
8775 if (ent == NULL)
8776 abort ();
8777
8778 if (tls_set == 0)
8779 {
8780 /* We managed to get rid of a got entry. */
8781 if (ent->got.refcount > 0)
8782 ent->got.refcount -= 1;
8783 }
8784 }
8785 else
8786 {
8787 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8788 we'll lose one or two dyn relocs. */
8789 if (!dec_dynrel_count (rel->r_info, sec, info,
8790 NULL, h, sym))
8791 return FALSE;
8792
8793 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8794 {
8795 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8796 NULL, h, sym))
8797 return FALSE;
8798 }
8799 }
8800
8801 *tls_mask |= tls_set;
8802 *tls_mask &= ~tls_clear;
8803 }
8804
8805 if (elf_section_data (sec)->relocs != relstart)
8806 free (relstart);
8807 }
8808
8809 if (locsyms != NULL
8810 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8811 {
8812 if (!info->keep_memory)
8813 free (locsyms);
8814 else
8815 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8816 }
8817 }
8818
8819 if (toc_ref != NULL)
8820 free (toc_ref);
8821 return TRUE;
8822 }
8823
8824 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8825 the values of any global symbols in a toc section that has been
8826 edited. Globals in toc sections should be a rarity, so this function
8827 sets a flag if any are found in toc sections other than the one just
8828 edited, so that futher hash table traversals can be avoided. */
8829
8830 struct adjust_toc_info
8831 {
8832 asection *toc;
8833 unsigned long *skip;
8834 bfd_boolean global_toc_syms;
8835 };
8836
8837 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8838
8839 static bfd_boolean
8840 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8841 {
8842 struct ppc_link_hash_entry *eh;
8843 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8844 unsigned long i;
8845
8846 if (h->root.type != bfd_link_hash_defined
8847 && h->root.type != bfd_link_hash_defweak)
8848 return TRUE;
8849
8850 eh = (struct ppc_link_hash_entry *) h;
8851 if (eh->adjust_done)
8852 return TRUE;
8853
8854 if (eh->elf.root.u.def.section == toc_inf->toc)
8855 {
8856 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8857 i = toc_inf->toc->rawsize >> 3;
8858 else
8859 i = eh->elf.root.u.def.value >> 3;
8860
8861 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8862 {
8863 _bfd_error_handler
8864 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8865 do
8866 ++i;
8867 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8868 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8869 }
8870
8871 eh->elf.root.u.def.value -= toc_inf->skip[i];
8872 eh->adjust_done = 1;
8873 }
8874 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8875 toc_inf->global_toc_syms = TRUE;
8876
8877 return TRUE;
8878 }
8879
8880 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8881 on a _LO variety toc/got reloc. */
8882
8883 static bfd_boolean
8884 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8885 {
8886 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8887 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8888 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8889 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8890 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8891 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8892 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8893 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8894 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8895 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8896 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8897 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8898 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8899 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8900 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8901 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8902 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8903 /* Exclude lfqu by testing reloc. If relocs are ever
8904 defined for the reduced D field in psq_lu then those
8905 will need testing too. */
8906 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8907 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8908 && (insn & 1) == 0)
8909 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8910 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8911 /* Exclude stfqu. psq_stu as above for psq_lu. */
8912 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8913 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8914 && (insn & 1) == 0));
8915 }
8916
8917 /* Examine all relocs referencing .toc sections in order to remove
8918 unused .toc entries. */
8919
8920 bfd_boolean
8921 ppc64_elf_edit_toc (struct bfd_link_info *info)
8922 {
8923 bfd *ibfd;
8924 struct adjust_toc_info toc_inf;
8925 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8926
8927 htab->do_toc_opt = 1;
8928 toc_inf.global_toc_syms = TRUE;
8929 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8930 {
8931 asection *toc, *sec;
8932 Elf_Internal_Shdr *symtab_hdr;
8933 Elf_Internal_Sym *local_syms;
8934 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8935 unsigned long *skip, *drop;
8936 unsigned char *used;
8937 unsigned char *keep, last, some_unused;
8938
8939 if (!is_ppc64_elf (ibfd))
8940 continue;
8941
8942 toc = bfd_get_section_by_name (ibfd, ".toc");
8943 if (toc == NULL
8944 || toc->size == 0
8945 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8946 || discarded_section (toc))
8947 continue;
8948
8949 toc_relocs = NULL;
8950 local_syms = NULL;
8951 symtab_hdr = &elf_symtab_hdr (ibfd);
8952
8953 /* Look at sections dropped from the final link. */
8954 skip = NULL;
8955 relstart = NULL;
8956 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8957 {
8958 if (sec->reloc_count == 0
8959 || !discarded_section (sec)
8960 || get_opd_info (sec)
8961 || (sec->flags & SEC_ALLOC) == 0
8962 || (sec->flags & SEC_DEBUGGING) != 0)
8963 continue;
8964
8965 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8966 if (relstart == NULL)
8967 goto error_ret;
8968
8969 /* Run through the relocs to see which toc entries might be
8970 unused. */
8971 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8972 {
8973 enum elf_ppc64_reloc_type r_type;
8974 unsigned long r_symndx;
8975 asection *sym_sec;
8976 struct elf_link_hash_entry *h;
8977 Elf_Internal_Sym *sym;
8978 bfd_vma val;
8979
8980 r_type = ELF64_R_TYPE (rel->r_info);
8981 switch (r_type)
8982 {
8983 default:
8984 continue;
8985
8986 case R_PPC64_TOC16:
8987 case R_PPC64_TOC16_LO:
8988 case R_PPC64_TOC16_HI:
8989 case R_PPC64_TOC16_HA:
8990 case R_PPC64_TOC16_DS:
8991 case R_PPC64_TOC16_LO_DS:
8992 break;
8993 }
8994
8995 r_symndx = ELF64_R_SYM (rel->r_info);
8996 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8997 r_symndx, ibfd))
8998 goto error_ret;
8999
9000 if (sym_sec != toc)
9001 continue;
9002
9003 if (h != NULL)
9004 val = h->root.u.def.value;
9005 else
9006 val = sym->st_value;
9007 val += rel->r_addend;
9008
9009 if (val >= toc->size)
9010 continue;
9011
9012 /* Anything in the toc ought to be aligned to 8 bytes.
9013 If not, don't mark as unused. */
9014 if (val & 7)
9015 continue;
9016
9017 if (skip == NULL)
9018 {
9019 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9020 if (skip == NULL)
9021 goto error_ret;
9022 }
9023
9024 skip[val >> 3] = ref_from_discarded;
9025 }
9026
9027 if (elf_section_data (sec)->relocs != relstart)
9028 free (relstart);
9029 }
9030
9031 /* For largetoc loads of address constants, we can convert
9032 . addis rx,2,addr@got@ha
9033 . ld ry,addr@got@l(rx)
9034 to
9035 . addis rx,2,addr@toc@ha
9036 . addi ry,rx,addr@toc@l
9037 when addr is within 2G of the toc pointer. This then means
9038 that the word storing "addr" in the toc is no longer needed. */
9039
9040 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9041 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9042 && toc->reloc_count != 0)
9043 {
9044 /* Read toc relocs. */
9045 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9046 info->keep_memory);
9047 if (toc_relocs == NULL)
9048 goto error_ret;
9049
9050 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9051 {
9052 enum elf_ppc64_reloc_type r_type;
9053 unsigned long r_symndx;
9054 asection *sym_sec;
9055 struct elf_link_hash_entry *h;
9056 Elf_Internal_Sym *sym;
9057 bfd_vma val, addr;
9058
9059 r_type = ELF64_R_TYPE (rel->r_info);
9060 if (r_type != R_PPC64_ADDR64)
9061 continue;
9062
9063 r_symndx = ELF64_R_SYM (rel->r_info);
9064 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9065 r_symndx, ibfd))
9066 goto error_ret;
9067
9068 if (sym_sec == NULL
9069 || sym_sec->output_section == NULL
9070 || discarded_section (sym_sec))
9071 continue;
9072
9073 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9074 continue;
9075
9076 if (h != NULL)
9077 {
9078 if (h->type == STT_GNU_IFUNC)
9079 continue;
9080 val = h->root.u.def.value;
9081 }
9082 else
9083 {
9084 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9085 continue;
9086 val = sym->st_value;
9087 }
9088 val += rel->r_addend;
9089 val += sym_sec->output_section->vma + sym_sec->output_offset;
9090
9091 /* We don't yet know the exact toc pointer value, but we
9092 know it will be somewhere in the toc section. Don't
9093 optimize if the difference from any possible toc
9094 pointer is outside [ff..f80008000, 7fff7fff]. */
9095 addr = toc->output_section->vma + TOC_BASE_OFF;
9096 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9097 continue;
9098
9099 addr = toc->output_section->vma + toc->output_section->rawsize;
9100 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9101 continue;
9102
9103 if (skip == NULL)
9104 {
9105 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9106 if (skip == NULL)
9107 goto error_ret;
9108 }
9109
9110 skip[rel->r_offset >> 3]
9111 |= can_optimize | ((rel - toc_relocs) << 2);
9112 }
9113 }
9114
9115 if (skip == NULL)
9116 continue;
9117
9118 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9119 if (used == NULL)
9120 {
9121 error_ret:
9122 if (local_syms != NULL
9123 && symtab_hdr->contents != (unsigned char *) local_syms)
9124 free (local_syms);
9125 if (sec != NULL
9126 && relstart != NULL
9127 && elf_section_data (sec)->relocs != relstart)
9128 free (relstart);
9129 if (toc_relocs != NULL
9130 && elf_section_data (toc)->relocs != toc_relocs)
9131 free (toc_relocs);
9132 if (skip != NULL)
9133 free (skip);
9134 return FALSE;
9135 }
9136
9137 /* Now check all kept sections that might reference the toc.
9138 Check the toc itself last. */
9139 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9140 : ibfd->sections);
9141 sec != NULL;
9142 sec = (sec == toc ? NULL
9143 : sec->next == NULL ? toc
9144 : sec->next == toc && toc->next ? toc->next
9145 : sec->next))
9146 {
9147 int repeat;
9148
9149 if (sec->reloc_count == 0
9150 || discarded_section (sec)
9151 || get_opd_info (sec)
9152 || (sec->flags & SEC_ALLOC) == 0
9153 || (sec->flags & SEC_DEBUGGING) != 0)
9154 continue;
9155
9156 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9157 info->keep_memory);
9158 if (relstart == NULL)
9159 {
9160 free (used);
9161 goto error_ret;
9162 }
9163
9164 /* Mark toc entries referenced as used. */
9165 do
9166 {
9167 repeat = 0;
9168 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9169 {
9170 enum elf_ppc64_reloc_type r_type;
9171 unsigned long r_symndx;
9172 asection *sym_sec;
9173 struct elf_link_hash_entry *h;
9174 Elf_Internal_Sym *sym;
9175 bfd_vma val;
9176 enum {no_check, check_lo, check_ha} insn_check;
9177
9178 r_type = ELF64_R_TYPE (rel->r_info);
9179 switch (r_type)
9180 {
9181 default:
9182 insn_check = no_check;
9183 break;
9184
9185 case R_PPC64_GOT_TLSLD16_HA:
9186 case R_PPC64_GOT_TLSGD16_HA:
9187 case R_PPC64_GOT_TPREL16_HA:
9188 case R_PPC64_GOT_DTPREL16_HA:
9189 case R_PPC64_GOT16_HA:
9190 case R_PPC64_TOC16_HA:
9191 insn_check = check_ha;
9192 break;
9193
9194 case R_PPC64_GOT_TLSLD16_LO:
9195 case R_PPC64_GOT_TLSGD16_LO:
9196 case R_PPC64_GOT_TPREL16_LO_DS:
9197 case R_PPC64_GOT_DTPREL16_LO_DS:
9198 case R_PPC64_GOT16_LO:
9199 case R_PPC64_GOT16_LO_DS:
9200 case R_PPC64_TOC16_LO:
9201 case R_PPC64_TOC16_LO_DS:
9202 insn_check = check_lo;
9203 break;
9204 }
9205
9206 if (insn_check != no_check)
9207 {
9208 bfd_vma off = rel->r_offset & ~3;
9209 unsigned char buf[4];
9210 unsigned int insn;
9211
9212 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9213 {
9214 free (used);
9215 goto error_ret;
9216 }
9217 insn = bfd_get_32 (ibfd, buf);
9218 if (insn_check == check_lo
9219 ? !ok_lo_toc_insn (insn, r_type)
9220 : ((insn & ((0x3f << 26) | 0x1f << 16))
9221 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9222 {
9223 char str[12];
9224
9225 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9226 sprintf (str, "%#08x", insn);
9227 info->callbacks->einfo
9228 /* xgettext:c-format */
9229 (_("%P: %H: toc optimization is not supported for"
9230 " %s instruction.\n"),
9231 ibfd, sec, rel->r_offset & ~3, str);
9232 }
9233 }
9234
9235 switch (r_type)
9236 {
9237 case R_PPC64_TOC16:
9238 case R_PPC64_TOC16_LO:
9239 case R_PPC64_TOC16_HI:
9240 case R_PPC64_TOC16_HA:
9241 case R_PPC64_TOC16_DS:
9242 case R_PPC64_TOC16_LO_DS:
9243 /* In case we're taking addresses of toc entries. */
9244 case R_PPC64_ADDR64:
9245 break;
9246
9247 default:
9248 continue;
9249 }
9250
9251 r_symndx = ELF64_R_SYM (rel->r_info);
9252 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9253 r_symndx, ibfd))
9254 {
9255 free (used);
9256 goto error_ret;
9257 }
9258
9259 if (sym_sec != toc)
9260 continue;
9261
9262 if (h != NULL)
9263 val = h->root.u.def.value;
9264 else
9265 val = sym->st_value;
9266 val += rel->r_addend;
9267
9268 if (val >= toc->size)
9269 continue;
9270
9271 if ((skip[val >> 3] & can_optimize) != 0)
9272 {
9273 bfd_vma off;
9274 unsigned char opc;
9275
9276 switch (r_type)
9277 {
9278 case R_PPC64_TOC16_HA:
9279 break;
9280
9281 case R_PPC64_TOC16_LO_DS:
9282 off = rel->r_offset;
9283 off += (bfd_big_endian (ibfd) ? -2 : 3);
9284 if (!bfd_get_section_contents (ibfd, sec, &opc,
9285 off, 1))
9286 {
9287 free (used);
9288 goto error_ret;
9289 }
9290 if ((opc & (0x3f << 2)) == (58u << 2))
9291 break;
9292 /* Fall through. */
9293
9294 default:
9295 /* Wrong sort of reloc, or not a ld. We may
9296 as well clear ref_from_discarded too. */
9297 skip[val >> 3] = 0;
9298 }
9299 }
9300
9301 if (sec != toc)
9302 used[val >> 3] = 1;
9303 /* For the toc section, we only mark as used if this
9304 entry itself isn't unused. */
9305 else if ((used[rel->r_offset >> 3]
9306 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9307 && !used[val >> 3])
9308 {
9309 /* Do all the relocs again, to catch reference
9310 chains. */
9311 repeat = 1;
9312 used[val >> 3] = 1;
9313 }
9314 }
9315 }
9316 while (repeat);
9317
9318 if (elf_section_data (sec)->relocs != relstart)
9319 free (relstart);
9320 }
9321
9322 /* Merge the used and skip arrays. Assume that TOC
9323 doublewords not appearing as either used or unused belong
9324 to to an entry more than one doubleword in size. */
9325 for (drop = skip, keep = used, last = 0, some_unused = 0;
9326 drop < skip + (toc->size + 7) / 8;
9327 ++drop, ++keep)
9328 {
9329 if (*keep)
9330 {
9331 *drop &= ~ref_from_discarded;
9332 if ((*drop & can_optimize) != 0)
9333 some_unused = 1;
9334 last = 0;
9335 }
9336 else if ((*drop & ref_from_discarded) != 0)
9337 {
9338 some_unused = 1;
9339 last = ref_from_discarded;
9340 }
9341 else
9342 *drop = last;
9343 }
9344
9345 free (used);
9346
9347 if (some_unused)
9348 {
9349 bfd_byte *contents, *src;
9350 unsigned long off;
9351 Elf_Internal_Sym *sym;
9352 bfd_boolean local_toc_syms = FALSE;
9353
9354 /* Shuffle the toc contents, and at the same time convert the
9355 skip array from booleans into offsets. */
9356 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9357 goto error_ret;
9358
9359 elf_section_data (toc)->this_hdr.contents = contents;
9360
9361 for (src = contents, off = 0, drop = skip;
9362 src < contents + toc->size;
9363 src += 8, ++drop)
9364 {
9365 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9366 off += 8;
9367 else if (off != 0)
9368 {
9369 *drop = off;
9370 memcpy (src - off, src, 8);
9371 }
9372 }
9373 *drop = off;
9374 toc->rawsize = toc->size;
9375 toc->size = src - contents - off;
9376
9377 /* Adjust addends for relocs against the toc section sym,
9378 and optimize any accesses we can. */
9379 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9380 {
9381 if (sec->reloc_count == 0
9382 || discarded_section (sec))
9383 continue;
9384
9385 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9386 info->keep_memory);
9387 if (relstart == NULL)
9388 goto error_ret;
9389
9390 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9391 {
9392 enum elf_ppc64_reloc_type r_type;
9393 unsigned long r_symndx;
9394 asection *sym_sec;
9395 struct elf_link_hash_entry *h;
9396 bfd_vma val;
9397
9398 r_type = ELF64_R_TYPE (rel->r_info);
9399 switch (r_type)
9400 {
9401 default:
9402 continue;
9403
9404 case R_PPC64_TOC16:
9405 case R_PPC64_TOC16_LO:
9406 case R_PPC64_TOC16_HI:
9407 case R_PPC64_TOC16_HA:
9408 case R_PPC64_TOC16_DS:
9409 case R_PPC64_TOC16_LO_DS:
9410 case R_PPC64_ADDR64:
9411 break;
9412 }
9413
9414 r_symndx = ELF64_R_SYM (rel->r_info);
9415 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9416 r_symndx, ibfd))
9417 goto error_ret;
9418
9419 if (sym_sec != toc)
9420 continue;
9421
9422 if (h != NULL)
9423 val = h->root.u.def.value;
9424 else
9425 {
9426 val = sym->st_value;
9427 if (val != 0)
9428 local_toc_syms = TRUE;
9429 }
9430
9431 val += rel->r_addend;
9432
9433 if (val > toc->rawsize)
9434 val = toc->rawsize;
9435 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9436 continue;
9437 else if ((skip[val >> 3] & can_optimize) != 0)
9438 {
9439 Elf_Internal_Rela *tocrel
9440 = toc_relocs + (skip[val >> 3] >> 2);
9441 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9442
9443 switch (r_type)
9444 {
9445 case R_PPC64_TOC16_HA:
9446 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9447 break;
9448
9449 case R_PPC64_TOC16_LO_DS:
9450 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9451 break;
9452
9453 default:
9454 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9455 ppc_howto_init ();
9456 info->callbacks->einfo
9457 /* xgettext:c-format */
9458 (_("%P: %H: %s references "
9459 "optimized away TOC entry\n"),
9460 ibfd, sec, rel->r_offset,
9461 ppc64_elf_howto_table[r_type]->name);
9462 bfd_set_error (bfd_error_bad_value);
9463 goto error_ret;
9464 }
9465 rel->r_addend = tocrel->r_addend;
9466 elf_section_data (sec)->relocs = relstart;
9467 continue;
9468 }
9469
9470 if (h != NULL || sym->st_value != 0)
9471 continue;
9472
9473 rel->r_addend -= skip[val >> 3];
9474 elf_section_data (sec)->relocs = relstart;
9475 }
9476
9477 if (elf_section_data (sec)->relocs != relstart)
9478 free (relstart);
9479 }
9480
9481 /* We shouldn't have local or global symbols defined in the TOC,
9482 but handle them anyway. */
9483 if (local_syms != NULL)
9484 for (sym = local_syms;
9485 sym < local_syms + symtab_hdr->sh_info;
9486 ++sym)
9487 if (sym->st_value != 0
9488 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9489 {
9490 unsigned long i;
9491
9492 if (sym->st_value > toc->rawsize)
9493 i = toc->rawsize >> 3;
9494 else
9495 i = sym->st_value >> 3;
9496
9497 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9498 {
9499 if (local_toc_syms)
9500 _bfd_error_handler
9501 (_("%s defined on removed toc entry"),
9502 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9503 do
9504 ++i;
9505 while ((skip[i] & (ref_from_discarded | can_optimize)));
9506 sym->st_value = (bfd_vma) i << 3;
9507 }
9508
9509 sym->st_value -= skip[i];
9510 symtab_hdr->contents = (unsigned char *) local_syms;
9511 }
9512
9513 /* Adjust any global syms defined in this toc input section. */
9514 if (toc_inf.global_toc_syms)
9515 {
9516 toc_inf.toc = toc;
9517 toc_inf.skip = skip;
9518 toc_inf.global_toc_syms = FALSE;
9519 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9520 &toc_inf);
9521 }
9522
9523 if (toc->reloc_count != 0)
9524 {
9525 Elf_Internal_Shdr *rel_hdr;
9526 Elf_Internal_Rela *wrel;
9527 bfd_size_type sz;
9528
9529 /* Remove unused toc relocs, and adjust those we keep. */
9530 if (toc_relocs == NULL)
9531 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9532 info->keep_memory);
9533 if (toc_relocs == NULL)
9534 goto error_ret;
9535
9536 wrel = toc_relocs;
9537 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9538 if ((skip[rel->r_offset >> 3]
9539 & (ref_from_discarded | can_optimize)) == 0)
9540 {
9541 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9542 wrel->r_info = rel->r_info;
9543 wrel->r_addend = rel->r_addend;
9544 ++wrel;
9545 }
9546 else if (!dec_dynrel_count (rel->r_info, toc, info,
9547 &local_syms, NULL, NULL))
9548 goto error_ret;
9549
9550 elf_section_data (toc)->relocs = toc_relocs;
9551 toc->reloc_count = wrel - toc_relocs;
9552 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9553 sz = rel_hdr->sh_entsize;
9554 rel_hdr->sh_size = toc->reloc_count * sz;
9555 }
9556 }
9557 else if (toc_relocs != NULL
9558 && elf_section_data (toc)->relocs != toc_relocs)
9559 free (toc_relocs);
9560
9561 if (local_syms != NULL
9562 && symtab_hdr->contents != (unsigned char *) local_syms)
9563 {
9564 if (!info->keep_memory)
9565 free (local_syms);
9566 else
9567 symtab_hdr->contents = (unsigned char *) local_syms;
9568 }
9569 free (skip);
9570 }
9571
9572 return TRUE;
9573 }
9574
9575 /* Return true iff input section I references the TOC using
9576 instructions limited to +/-32k offsets. */
9577
9578 bfd_boolean
9579 ppc64_elf_has_small_toc_reloc (asection *i)
9580 {
9581 return (is_ppc64_elf (i->owner)
9582 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9583 }
9584
9585 /* Allocate space for one GOT entry. */
9586
9587 static void
9588 allocate_got (struct elf_link_hash_entry *h,
9589 struct bfd_link_info *info,
9590 struct got_entry *gent)
9591 {
9592 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9593 bfd_boolean dyn;
9594 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9595 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9596 ? 16 : 8);
9597 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9598 ? 2 : 1) * sizeof (Elf64_External_Rela);
9599 asection *got = ppc64_elf_tdata (gent->owner)->got;
9600
9601 gent->got.offset = got->size;
9602 got->size += entsize;
9603
9604 dyn = htab->elf.dynamic_sections_created;
9605 if (h->type == STT_GNU_IFUNC)
9606 {
9607 htab->elf.irelplt->size += rentsize;
9608 htab->got_reli_size += rentsize;
9609 }
9610 else if ((bfd_link_pic (info)
9611 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9612 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9613 || h->root.type != bfd_link_hash_undefweak))
9614 {
9615 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9616 relgot->size += rentsize;
9617 }
9618 }
9619
9620 /* This function merges got entries in the same toc group. */
9621
9622 static void
9623 merge_got_entries (struct got_entry **pent)
9624 {
9625 struct got_entry *ent, *ent2;
9626
9627 for (ent = *pent; ent != NULL; ent = ent->next)
9628 if (!ent->is_indirect)
9629 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9630 if (!ent2->is_indirect
9631 && ent2->addend == ent->addend
9632 && ent2->tls_type == ent->tls_type
9633 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9634 {
9635 ent2->is_indirect = TRUE;
9636 ent2->got.ent = ent;
9637 }
9638 }
9639
9640 /* Allocate space in .plt, .got and associated reloc sections for
9641 dynamic relocs. */
9642
9643 static bfd_boolean
9644 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9645 {
9646 struct bfd_link_info *info;
9647 struct ppc_link_hash_table *htab;
9648 asection *s;
9649 struct ppc_link_hash_entry *eh;
9650 struct got_entry **pgent, *gent;
9651
9652 if (h->root.type == bfd_link_hash_indirect)
9653 return TRUE;
9654
9655 info = (struct bfd_link_info *) inf;
9656 htab = ppc_hash_table (info);
9657 if (htab == NULL)
9658 return FALSE;
9659
9660 eh = (struct ppc_link_hash_entry *) h;
9661 /* Run through the TLS GD got entries first if we're changing them
9662 to TPREL. */
9663 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9664 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9665 if (gent->got.refcount > 0
9666 && (gent->tls_type & TLS_GD) != 0)
9667 {
9668 /* This was a GD entry that has been converted to TPREL. If
9669 there happens to be a TPREL entry we can use that one. */
9670 struct got_entry *ent;
9671 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9672 if (ent->got.refcount > 0
9673 && (ent->tls_type & TLS_TPREL) != 0
9674 && ent->addend == gent->addend
9675 && ent->owner == gent->owner)
9676 {
9677 gent->got.refcount = 0;
9678 break;
9679 }
9680
9681 /* If not, then we'll be using our own TPREL entry. */
9682 if (gent->got.refcount != 0)
9683 gent->tls_type = TLS_TLS | TLS_TPREL;
9684 }
9685
9686 /* Remove any list entry that won't generate a word in the GOT before
9687 we call merge_got_entries. Otherwise we risk merging to empty
9688 entries. */
9689 pgent = &h->got.glist;
9690 while ((gent = *pgent) != NULL)
9691 if (gent->got.refcount > 0)
9692 {
9693 if ((gent->tls_type & TLS_LD) != 0
9694 && !h->def_dynamic)
9695 {
9696 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9697 *pgent = gent->next;
9698 }
9699 else
9700 pgent = &gent->next;
9701 }
9702 else
9703 *pgent = gent->next;
9704
9705 if (!htab->do_multi_toc)
9706 merge_got_entries (&h->got.glist);
9707
9708 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9709 if (!gent->is_indirect)
9710 {
9711 /* Make sure this symbol is output as a dynamic symbol.
9712 Undefined weak syms won't yet be marked as dynamic,
9713 nor will all TLS symbols. */
9714 if (h->dynindx == -1
9715 && !h->forced_local
9716 && h->type != STT_GNU_IFUNC
9717 && htab->elf.dynamic_sections_created)
9718 {
9719 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9720 return FALSE;
9721 }
9722
9723 if (!is_ppc64_elf (gent->owner))
9724 abort ();
9725
9726 allocate_got (h, info, gent);
9727 }
9728
9729 if (!htab->elf.dynamic_sections_created
9730 && h->type != STT_GNU_IFUNC)
9731 eh->dyn_relocs = NULL;
9732
9733 if (eh->dyn_relocs != NULL)
9734 {
9735 struct elf_dyn_relocs *p, **pp;
9736
9737 /* In the shared -Bsymbolic case, discard space allocated for
9738 dynamic pc-relative relocs against symbols which turn out to
9739 be defined in regular objects. For the normal shared case,
9740 discard space for relocs that have become local due to symbol
9741 visibility changes. */
9742
9743 if (bfd_link_pic (info))
9744 {
9745 /* Relocs that use pc_count are those that appear on a call
9746 insn, or certain REL relocs (see must_be_dyn_reloc) that
9747 can be generated via assembly. We want calls to
9748 protected symbols to resolve directly to the function
9749 rather than going via the plt. If people want function
9750 pointer comparisons to work as expected then they should
9751 avoid writing weird assembly. */
9752 if (SYMBOL_CALLS_LOCAL (info, h))
9753 {
9754 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9755 {
9756 p->count -= p->pc_count;
9757 p->pc_count = 0;
9758 if (p->count == 0)
9759 *pp = p->next;
9760 else
9761 pp = &p->next;
9762 }
9763 }
9764
9765 /* Also discard relocs on undefined weak syms with
9766 non-default visibility. */
9767 if (eh->dyn_relocs != NULL
9768 && h->root.type == bfd_link_hash_undefweak)
9769 {
9770 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9771 eh->dyn_relocs = NULL;
9772
9773 /* Make sure this symbol is output as a dynamic symbol.
9774 Undefined weak syms won't yet be marked as dynamic. */
9775 else if (h->dynindx == -1
9776 && !h->forced_local)
9777 {
9778 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9779 return FALSE;
9780 }
9781 }
9782 }
9783 else if (h->type == STT_GNU_IFUNC)
9784 {
9785 /* A plt entry is always created when making direct calls to
9786 an ifunc, even when building a static executable, but
9787 that doesn't cover all cases. We may have only an ifunc
9788 initialised function pointer for a given ifunc symbol.
9789
9790 For ELFv2, dynamic relocations are not required when
9791 generating a global entry PLT stub. */
9792 if (abiversion (info->output_bfd) >= 2)
9793 {
9794 if (global_entry_stub (h))
9795 eh->dyn_relocs = NULL;
9796 }
9797
9798 /* For ELFv1 we have function descriptors. Descriptors need
9799 to be treated like PLT entries and thus have dynamic
9800 relocations. One exception is when the function
9801 descriptor is copied into .dynbss (which should only
9802 happen with ancient versions of gcc). */
9803 else if (h->needs_copy)
9804 eh->dyn_relocs = NULL;
9805 }
9806 else if (ELIMINATE_COPY_RELOCS)
9807 {
9808 /* For the non-pic case, discard space for relocs against
9809 symbols which turn out to need copy relocs or are not
9810 dynamic. */
9811
9812 /* First make sure this symbol is output as a dynamic symbol.
9813 Undefined weak syms won't yet be marked as dynamic. */
9814 if (h->root.type == bfd_link_hash_undefweak
9815 && !h->non_got_ref
9816 && !h->def_regular
9817 && h->dynindx == -1
9818 && !h->forced_local
9819 && !bfd_elf_link_record_dynamic_symbol (info, h))
9820 return FALSE;
9821
9822 if (h->non_got_ref
9823 || h->def_regular
9824 || h->dynindx == -1)
9825 eh->dyn_relocs = NULL;
9826 }
9827
9828 /* Finally, allocate space. */
9829 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9830 {
9831 asection *sreloc = elf_section_data (p->sec)->sreloc;
9832 if (eh->elf.type == STT_GNU_IFUNC)
9833 sreloc = htab->elf.irelplt;
9834 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9835 }
9836 }
9837
9838 if ((htab->elf.dynamic_sections_created
9839 && h->dynindx != -1
9840 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9841 || h->type == STT_GNU_IFUNC)
9842 {
9843 struct plt_entry *pent;
9844 bfd_boolean doneone = FALSE;
9845 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9846 if (pent->plt.refcount > 0)
9847 {
9848 if (!htab->elf.dynamic_sections_created
9849 || h->dynindx == -1)
9850 {
9851 s = htab->elf.iplt;
9852 pent->plt.offset = s->size;
9853 s->size += PLT_ENTRY_SIZE (htab);
9854 s = htab->elf.irelplt;
9855 }
9856 else
9857 {
9858 /* If this is the first .plt entry, make room for the special
9859 first entry. */
9860 s = htab->elf.splt;
9861 if (s->size == 0)
9862 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9863
9864 pent->plt.offset = s->size;
9865
9866 /* Make room for this entry. */
9867 s->size += PLT_ENTRY_SIZE (htab);
9868
9869 /* Make room for the .glink code. */
9870 s = htab->glink;
9871 if (s->size == 0)
9872 s->size += GLINK_CALL_STUB_SIZE;
9873 if (htab->opd_abi)
9874 {
9875 /* We need bigger stubs past index 32767. */
9876 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9877 s->size += 4;
9878 s->size += 2*4;
9879 }
9880 else
9881 s->size += 4;
9882
9883 /* We also need to make an entry in the .rela.plt section. */
9884 s = htab->elf.srelplt;
9885 }
9886 s->size += sizeof (Elf64_External_Rela);
9887 doneone = TRUE;
9888 }
9889 else
9890 pent->plt.offset = (bfd_vma) -1;
9891 if (!doneone)
9892 {
9893 h->plt.plist = NULL;
9894 h->needs_plt = 0;
9895 }
9896 }
9897 else
9898 {
9899 h->plt.plist = NULL;
9900 h->needs_plt = 0;
9901 }
9902
9903 return TRUE;
9904 }
9905
9906 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9907 to set up space for global entry stubs. These are put in glink,
9908 after the branch table. */
9909
9910 static bfd_boolean
9911 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9912 {
9913 struct bfd_link_info *info;
9914 struct ppc_link_hash_table *htab;
9915 struct plt_entry *pent;
9916 asection *s;
9917
9918 if (h->root.type == bfd_link_hash_indirect)
9919 return TRUE;
9920
9921 if (!h->pointer_equality_needed)
9922 return TRUE;
9923
9924 if (h->def_regular)
9925 return TRUE;
9926
9927 info = inf;
9928 htab = ppc_hash_table (info);
9929 if (htab == NULL)
9930 return FALSE;
9931
9932 s = htab->glink;
9933 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9934 if (pent->plt.offset != (bfd_vma) -1
9935 && pent->addend == 0)
9936 {
9937 /* For ELFv2, if this symbol is not defined in a regular file
9938 and we are not generating a shared library or pie, then we
9939 need to define the symbol in the executable on a call stub.
9940 This is to avoid text relocations. */
9941 s->size = (s->size + 15) & -16;
9942 h->root.type = bfd_link_hash_defined;
9943 h->root.u.def.section = s;
9944 h->root.u.def.value = s->size;
9945 s->size += 16;
9946 break;
9947 }
9948 return TRUE;
9949 }
9950
9951 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9952 read-only sections. */
9953
9954 static bfd_boolean
9955 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9956 {
9957 if (h->root.type == bfd_link_hash_indirect)
9958 return TRUE;
9959
9960 if (readonly_dynrelocs (h))
9961 {
9962 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9963
9964 /* Not an error, just cut short the traversal. */
9965 return FALSE;
9966 }
9967 return TRUE;
9968 }
9969
9970 /* Set the sizes of the dynamic sections. */
9971
9972 static bfd_boolean
9973 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9974 struct bfd_link_info *info)
9975 {
9976 struct ppc_link_hash_table *htab;
9977 bfd *dynobj;
9978 asection *s;
9979 bfd_boolean relocs;
9980 bfd *ibfd;
9981 struct got_entry *first_tlsld;
9982
9983 htab = ppc_hash_table (info);
9984 if (htab == NULL)
9985 return FALSE;
9986
9987 dynobj = htab->elf.dynobj;
9988 if (dynobj == NULL)
9989 abort ();
9990
9991 if (htab->elf.dynamic_sections_created)
9992 {
9993 /* Set the contents of the .interp section to the interpreter. */
9994 if (bfd_link_executable (info) && !info->nointerp)
9995 {
9996 s = bfd_get_linker_section (dynobj, ".interp");
9997 if (s == NULL)
9998 abort ();
9999 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10000 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10001 }
10002 }
10003
10004 /* Set up .got offsets for local syms, and space for local dynamic
10005 relocs. */
10006 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10007 {
10008 struct got_entry **lgot_ents;
10009 struct got_entry **end_lgot_ents;
10010 struct plt_entry **local_plt;
10011 struct plt_entry **end_local_plt;
10012 unsigned char *lgot_masks;
10013 bfd_size_type locsymcount;
10014 Elf_Internal_Shdr *symtab_hdr;
10015
10016 if (!is_ppc64_elf (ibfd))
10017 continue;
10018
10019 for (s = ibfd->sections; s != NULL; s = s->next)
10020 {
10021 struct ppc_dyn_relocs *p;
10022
10023 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10024 {
10025 if (!bfd_is_abs_section (p->sec)
10026 && bfd_is_abs_section (p->sec->output_section))
10027 {
10028 /* Input section has been discarded, either because
10029 it is a copy of a linkonce section or due to
10030 linker script /DISCARD/, so we'll be discarding
10031 the relocs too. */
10032 }
10033 else if (p->count != 0)
10034 {
10035 asection *srel = elf_section_data (p->sec)->sreloc;
10036 if (p->ifunc)
10037 srel = htab->elf.irelplt;
10038 srel->size += p->count * sizeof (Elf64_External_Rela);
10039 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10040 info->flags |= DF_TEXTREL;
10041 }
10042 }
10043 }
10044
10045 lgot_ents = elf_local_got_ents (ibfd);
10046 if (!lgot_ents)
10047 continue;
10048
10049 symtab_hdr = &elf_symtab_hdr (ibfd);
10050 locsymcount = symtab_hdr->sh_info;
10051 end_lgot_ents = lgot_ents + locsymcount;
10052 local_plt = (struct plt_entry **) end_lgot_ents;
10053 end_local_plt = local_plt + locsymcount;
10054 lgot_masks = (unsigned char *) end_local_plt;
10055 s = ppc64_elf_tdata (ibfd)->got;
10056 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10057 {
10058 struct got_entry **pent, *ent;
10059
10060 pent = lgot_ents;
10061 while ((ent = *pent) != NULL)
10062 if (ent->got.refcount > 0)
10063 {
10064 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10065 {
10066 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10067 *pent = ent->next;
10068 }
10069 else
10070 {
10071 unsigned int ent_size = 8;
10072 unsigned int rel_size = sizeof (Elf64_External_Rela);
10073
10074 ent->got.offset = s->size;
10075 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10076 {
10077 ent_size *= 2;
10078 rel_size *= 2;
10079 }
10080 s->size += ent_size;
10081 if ((*lgot_masks & PLT_IFUNC) != 0)
10082 {
10083 htab->elf.irelplt->size += rel_size;
10084 htab->got_reli_size += rel_size;
10085 }
10086 else if (bfd_link_pic (info))
10087 {
10088 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10089 srel->size += rel_size;
10090 }
10091 pent = &ent->next;
10092 }
10093 }
10094 else
10095 *pent = ent->next;
10096 }
10097
10098 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10099 for (; local_plt < end_local_plt; ++local_plt)
10100 {
10101 struct plt_entry *ent;
10102
10103 for (ent = *local_plt; ent != NULL; ent = ent->next)
10104 if (ent->plt.refcount > 0)
10105 {
10106 s = htab->elf.iplt;
10107 ent->plt.offset = s->size;
10108 s->size += PLT_ENTRY_SIZE (htab);
10109
10110 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10111 }
10112 else
10113 ent->plt.offset = (bfd_vma) -1;
10114 }
10115 }
10116
10117 /* Allocate global sym .plt and .got entries, and space for global
10118 sym dynamic relocs. */
10119 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10120 /* Stash the end of glink branch table. */
10121 if (htab->glink != NULL)
10122 htab->glink->rawsize = htab->glink->size;
10123
10124 if (!htab->opd_abi && !bfd_link_pic (info))
10125 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10126
10127 first_tlsld = NULL;
10128 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10129 {
10130 struct got_entry *ent;
10131
10132 if (!is_ppc64_elf (ibfd))
10133 continue;
10134
10135 ent = ppc64_tlsld_got (ibfd);
10136 if (ent->got.refcount > 0)
10137 {
10138 if (!htab->do_multi_toc && first_tlsld != NULL)
10139 {
10140 ent->is_indirect = TRUE;
10141 ent->got.ent = first_tlsld;
10142 }
10143 else
10144 {
10145 if (first_tlsld == NULL)
10146 first_tlsld = ent;
10147 s = ppc64_elf_tdata (ibfd)->got;
10148 ent->got.offset = s->size;
10149 ent->owner = ibfd;
10150 s->size += 16;
10151 if (bfd_link_pic (info))
10152 {
10153 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10154 srel->size += sizeof (Elf64_External_Rela);
10155 }
10156 }
10157 }
10158 else
10159 ent->got.offset = (bfd_vma) -1;
10160 }
10161
10162 /* We now have determined the sizes of the various dynamic sections.
10163 Allocate memory for them. */
10164 relocs = FALSE;
10165 for (s = dynobj->sections; s != NULL; s = s->next)
10166 {
10167 if ((s->flags & SEC_LINKER_CREATED) == 0)
10168 continue;
10169
10170 if (s == htab->brlt || s == htab->relbrlt)
10171 /* These haven't been allocated yet; don't strip. */
10172 continue;
10173 else if (s == htab->elf.sgot
10174 || s == htab->elf.splt
10175 || s == htab->elf.iplt
10176 || s == htab->glink
10177 || s == htab->elf.sdynbss)
10178 {
10179 /* Strip this section if we don't need it; see the
10180 comment below. */
10181 }
10182 else if (s == htab->glink_eh_frame)
10183 {
10184 if (!bfd_is_abs_section (s->output_section))
10185 /* Not sized yet. */
10186 continue;
10187 }
10188 else if (CONST_STRNEQ (s->name, ".rela"))
10189 {
10190 if (s->size != 0)
10191 {
10192 if (s != htab->elf.srelplt)
10193 relocs = TRUE;
10194
10195 /* We use the reloc_count field as a counter if we need
10196 to copy relocs into the output file. */
10197 s->reloc_count = 0;
10198 }
10199 }
10200 else
10201 {
10202 /* It's not one of our sections, so don't allocate space. */
10203 continue;
10204 }
10205
10206 if (s->size == 0)
10207 {
10208 /* If we don't need this section, strip it from the
10209 output file. This is mostly to handle .rela.bss and
10210 .rela.plt. We must create both sections in
10211 create_dynamic_sections, because they must be created
10212 before the linker maps input sections to output
10213 sections. The linker does that before
10214 adjust_dynamic_symbol is called, and it is that
10215 function which decides whether anything needs to go
10216 into these sections. */
10217 s->flags |= SEC_EXCLUDE;
10218 continue;
10219 }
10220
10221 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10222 continue;
10223
10224 /* Allocate memory for the section contents. We use bfd_zalloc
10225 here in case unused entries are not reclaimed before the
10226 section's contents are written out. This should not happen,
10227 but this way if it does we get a R_PPC64_NONE reloc in .rela
10228 sections instead of garbage.
10229 We also rely on the section contents being zero when writing
10230 the GOT. */
10231 s->contents = bfd_zalloc (dynobj, s->size);
10232 if (s->contents == NULL)
10233 return FALSE;
10234 }
10235
10236 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10237 {
10238 if (!is_ppc64_elf (ibfd))
10239 continue;
10240
10241 s = ppc64_elf_tdata (ibfd)->got;
10242 if (s != NULL && s != htab->elf.sgot)
10243 {
10244 if (s->size == 0)
10245 s->flags |= SEC_EXCLUDE;
10246 else
10247 {
10248 s->contents = bfd_zalloc (ibfd, s->size);
10249 if (s->contents == NULL)
10250 return FALSE;
10251 }
10252 }
10253 s = ppc64_elf_tdata (ibfd)->relgot;
10254 if (s != NULL)
10255 {
10256 if (s->size == 0)
10257 s->flags |= SEC_EXCLUDE;
10258 else
10259 {
10260 s->contents = bfd_zalloc (ibfd, s->size);
10261 if (s->contents == NULL)
10262 return FALSE;
10263 relocs = TRUE;
10264 s->reloc_count = 0;
10265 }
10266 }
10267 }
10268
10269 if (htab->elf.dynamic_sections_created)
10270 {
10271 bfd_boolean tls_opt;
10272
10273 /* Add some entries to the .dynamic section. We fill in the
10274 values later, in ppc64_elf_finish_dynamic_sections, but we
10275 must add the entries now so that we get the correct size for
10276 the .dynamic section. The DT_DEBUG entry is filled in by the
10277 dynamic linker and used by the debugger. */
10278 #define add_dynamic_entry(TAG, VAL) \
10279 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10280
10281 if (bfd_link_executable (info))
10282 {
10283 if (!add_dynamic_entry (DT_DEBUG, 0))
10284 return FALSE;
10285 }
10286
10287 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10288 {
10289 if (!add_dynamic_entry (DT_PLTGOT, 0)
10290 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10291 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10292 || !add_dynamic_entry (DT_JMPREL, 0)
10293 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10294 return FALSE;
10295 }
10296
10297 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10298 {
10299 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10300 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10301 return FALSE;
10302 }
10303
10304 tls_opt = (htab->params->tls_get_addr_opt
10305 && htab->tls_get_addr_fd != NULL
10306 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10307 if (tls_opt || !htab->opd_abi)
10308 {
10309 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10310 return FALSE;
10311 }
10312
10313 if (relocs)
10314 {
10315 if (!add_dynamic_entry (DT_RELA, 0)
10316 || !add_dynamic_entry (DT_RELASZ, 0)
10317 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10318 return FALSE;
10319
10320 /* If any dynamic relocs apply to a read-only section,
10321 then we need a DT_TEXTREL entry. */
10322 if ((info->flags & DF_TEXTREL) == 0)
10323 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10324
10325 if ((info->flags & DF_TEXTREL) != 0)
10326 {
10327 if (!add_dynamic_entry (DT_TEXTREL, 0))
10328 return FALSE;
10329 }
10330 }
10331 }
10332 #undef add_dynamic_entry
10333
10334 return TRUE;
10335 }
10336
10337 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10338
10339 static bfd_boolean
10340 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10341 {
10342 if (h->plt.plist != NULL
10343 && !h->def_regular
10344 && !h->pointer_equality_needed)
10345 return FALSE;
10346
10347 return _bfd_elf_hash_symbol (h);
10348 }
10349
10350 /* Determine the type of stub needed, if any, for a call. */
10351
10352 static inline enum ppc_stub_type
10353 ppc_type_of_stub (asection *input_sec,
10354 const Elf_Internal_Rela *rel,
10355 struct ppc_link_hash_entry **hash,
10356 struct plt_entry **plt_ent,
10357 bfd_vma destination,
10358 unsigned long local_off)
10359 {
10360 struct ppc_link_hash_entry *h = *hash;
10361 bfd_vma location;
10362 bfd_vma branch_offset;
10363 bfd_vma max_branch_offset;
10364 enum elf_ppc64_reloc_type r_type;
10365
10366 if (h != NULL)
10367 {
10368 struct plt_entry *ent;
10369 struct ppc_link_hash_entry *fdh = h;
10370 if (h->oh != NULL
10371 && h->oh->is_func_descriptor)
10372 {
10373 fdh = ppc_follow_link (h->oh);
10374 *hash = fdh;
10375 }
10376
10377 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10378 if (ent->addend == rel->r_addend
10379 && ent->plt.offset != (bfd_vma) -1)
10380 {
10381 *plt_ent = ent;
10382 return ppc_stub_plt_call;
10383 }
10384
10385 /* Here, we know we don't have a plt entry. If we don't have a
10386 either a defined function descriptor or a defined entry symbol
10387 in a regular object file, then it is pointless trying to make
10388 any other type of stub. */
10389 if (!is_static_defined (&fdh->elf)
10390 && !is_static_defined (&h->elf))
10391 return ppc_stub_none;
10392 }
10393 else if (elf_local_got_ents (input_sec->owner) != NULL)
10394 {
10395 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10396 struct plt_entry **local_plt = (struct plt_entry **)
10397 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10398 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10399
10400 if (local_plt[r_symndx] != NULL)
10401 {
10402 struct plt_entry *ent;
10403
10404 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10405 if (ent->addend == rel->r_addend
10406 && ent->plt.offset != (bfd_vma) -1)
10407 {
10408 *plt_ent = ent;
10409 return ppc_stub_plt_call;
10410 }
10411 }
10412 }
10413
10414 /* Determine where the call point is. */
10415 location = (input_sec->output_offset
10416 + input_sec->output_section->vma
10417 + rel->r_offset);
10418
10419 branch_offset = destination - location;
10420 r_type = ELF64_R_TYPE (rel->r_info);
10421
10422 /* Determine if a long branch stub is needed. */
10423 max_branch_offset = 1 << 25;
10424 if (r_type != R_PPC64_REL24)
10425 max_branch_offset = 1 << 15;
10426
10427 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10428 /* We need a stub. Figure out whether a long_branch or plt_branch
10429 is needed later. */
10430 return ppc_stub_long_branch;
10431
10432 return ppc_stub_none;
10433 }
10434
10435 /* With power7 weakly ordered memory model, it is possible for ld.so
10436 to update a plt entry in one thread and have another thread see a
10437 stale zero toc entry. To avoid this we need some sort of acquire
10438 barrier in the call stub. One solution is to make the load of the
10439 toc word seem to appear to depend on the load of the function entry
10440 word. Another solution is to test for r2 being zero, and branch to
10441 the appropriate glink entry if so.
10442
10443 . fake dep barrier compare
10444 . ld 12,xxx(2) ld 12,xxx(2)
10445 . mtctr 12 mtctr 12
10446 . xor 11,12,12 ld 2,xxx+8(2)
10447 . add 2,2,11 cmpldi 2,0
10448 . ld 2,xxx+8(2) bnectr+
10449 . bctr b <glink_entry>
10450
10451 The solution involving the compare turns out to be faster, so
10452 that's what we use unless the branch won't reach. */
10453
10454 #define ALWAYS_USE_FAKE_DEP 0
10455 #define ALWAYS_EMIT_R2SAVE 0
10456
10457 #define PPC_LO(v) ((v) & 0xffff)
10458 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10459 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10460
10461 static inline unsigned int
10462 plt_stub_size (struct ppc_link_hash_table *htab,
10463 struct ppc_stub_hash_entry *stub_entry,
10464 bfd_vma off)
10465 {
10466 unsigned size = 12;
10467
10468 if (ALWAYS_EMIT_R2SAVE
10469 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10470 size += 4;
10471 if (PPC_HA (off) != 0)
10472 size += 4;
10473 if (htab->opd_abi)
10474 {
10475 size += 4;
10476 if (htab->params->plt_static_chain)
10477 size += 4;
10478 if (htab->params->plt_thread_safe
10479 && htab->elf.dynamic_sections_created
10480 && stub_entry->h != NULL
10481 && stub_entry->h->elf.dynindx != -1)
10482 size += 8;
10483 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10484 size += 4;
10485 }
10486 if (stub_entry->h != NULL
10487 && (stub_entry->h == htab->tls_get_addr_fd
10488 || stub_entry->h == htab->tls_get_addr)
10489 && htab->params->tls_get_addr_opt)
10490 size += 13 * 4;
10491 return size;
10492 }
10493
10494 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10495 then return the padding needed to do so. */
10496 static inline unsigned int
10497 plt_stub_pad (struct ppc_link_hash_table *htab,
10498 struct ppc_stub_hash_entry *stub_entry,
10499 bfd_vma plt_off)
10500 {
10501 int stub_align = 1 << htab->params->plt_stub_align;
10502 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10503 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10504
10505 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10506 > ((stub_size - 1) & -stub_align))
10507 return stub_align - (stub_off & (stub_align - 1));
10508 return 0;
10509 }
10510
10511 /* Build a .plt call stub. */
10512
10513 static inline bfd_byte *
10514 build_plt_stub (struct ppc_link_hash_table *htab,
10515 struct ppc_stub_hash_entry *stub_entry,
10516 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10517 {
10518 bfd *obfd = htab->params->stub_bfd;
10519 bfd_boolean plt_load_toc = htab->opd_abi;
10520 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10521 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10522 && htab->elf.dynamic_sections_created
10523 && stub_entry->h != NULL
10524 && stub_entry->h->elf.dynindx != -1);
10525 bfd_boolean use_fake_dep = plt_thread_safe;
10526 bfd_vma cmp_branch_off = 0;
10527
10528 if (!ALWAYS_USE_FAKE_DEP
10529 && plt_load_toc
10530 && plt_thread_safe
10531 && !((stub_entry->h == htab->tls_get_addr_fd
10532 || stub_entry->h == htab->tls_get_addr)
10533 && htab->params->tls_get_addr_opt))
10534 {
10535 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10536 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10537 / PLT_ENTRY_SIZE (htab));
10538 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10539 bfd_vma to, from;
10540
10541 if (pltindex > 32768)
10542 glinkoff += (pltindex - 32768) * 4;
10543 to = (glinkoff
10544 + htab->glink->output_offset
10545 + htab->glink->output_section->vma);
10546 from = (p - stub_entry->group->stub_sec->contents
10547 + 4 * (ALWAYS_EMIT_R2SAVE
10548 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10549 + 4 * (PPC_HA (offset) != 0)
10550 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10551 != PPC_HA (offset))
10552 + 4 * (plt_static_chain != 0)
10553 + 20
10554 + stub_entry->group->stub_sec->output_offset
10555 + stub_entry->group->stub_sec->output_section->vma);
10556 cmp_branch_off = to - from;
10557 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10558 }
10559
10560 if (PPC_HA (offset) != 0)
10561 {
10562 if (r != NULL)
10563 {
10564 if (ALWAYS_EMIT_R2SAVE
10565 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10566 r[0].r_offset += 4;
10567 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10568 r[1].r_offset = r[0].r_offset + 4;
10569 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10570 r[1].r_addend = r[0].r_addend;
10571 if (plt_load_toc)
10572 {
10573 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10574 {
10575 r[2].r_offset = r[1].r_offset + 4;
10576 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10577 r[2].r_addend = r[0].r_addend;
10578 }
10579 else
10580 {
10581 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10582 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10583 r[2].r_addend = r[0].r_addend + 8;
10584 if (plt_static_chain)
10585 {
10586 r[3].r_offset = r[2].r_offset + 4;
10587 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10588 r[3].r_addend = r[0].r_addend + 16;
10589 }
10590 }
10591 }
10592 }
10593 if (ALWAYS_EMIT_R2SAVE
10594 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10595 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10596 if (plt_load_toc)
10597 {
10598 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10599 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10600 }
10601 else
10602 {
10603 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10604 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10605 }
10606 if (plt_load_toc
10607 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10608 {
10609 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10610 offset = 0;
10611 }
10612 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10613 if (plt_load_toc)
10614 {
10615 if (use_fake_dep)
10616 {
10617 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10618 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10619 }
10620 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10621 if (plt_static_chain)
10622 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10623 }
10624 }
10625 else
10626 {
10627 if (r != NULL)
10628 {
10629 if (ALWAYS_EMIT_R2SAVE
10630 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10631 r[0].r_offset += 4;
10632 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10633 if (plt_load_toc)
10634 {
10635 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10636 {
10637 r[1].r_offset = r[0].r_offset + 4;
10638 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10639 r[1].r_addend = r[0].r_addend;
10640 }
10641 else
10642 {
10643 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10644 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10645 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10646 if (plt_static_chain)
10647 {
10648 r[2].r_offset = r[1].r_offset + 4;
10649 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10650 r[2].r_addend = r[0].r_addend + 8;
10651 }
10652 }
10653 }
10654 }
10655 if (ALWAYS_EMIT_R2SAVE
10656 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10657 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10658 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10659 if (plt_load_toc
10660 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10661 {
10662 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10663 offset = 0;
10664 }
10665 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10666 if (plt_load_toc)
10667 {
10668 if (use_fake_dep)
10669 {
10670 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10671 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10672 }
10673 if (plt_static_chain)
10674 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10675 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10676 }
10677 }
10678 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10679 {
10680 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10681 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10682 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10683 }
10684 else
10685 bfd_put_32 (obfd, BCTR, p), p += 4;
10686 return p;
10687 }
10688
10689 /* Build a special .plt call stub for __tls_get_addr. */
10690
10691 #define LD_R11_0R3 0xe9630000
10692 #define LD_R12_0R3 0xe9830000
10693 #define MR_R0_R3 0x7c601b78
10694 #define CMPDI_R11_0 0x2c2b0000
10695 #define ADD_R3_R12_R13 0x7c6c6a14
10696 #define BEQLR 0x4d820020
10697 #define MR_R3_R0 0x7c030378
10698 #define STD_R11_0R1 0xf9610000
10699 #define BCTRL 0x4e800421
10700 #define LD_R11_0R1 0xe9610000
10701 #define MTLR_R11 0x7d6803a6
10702
10703 static inline bfd_byte *
10704 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10705 struct ppc_stub_hash_entry *stub_entry,
10706 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10707 {
10708 bfd *obfd = htab->params->stub_bfd;
10709
10710 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10711 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10712 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10713 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10714 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10715 bfd_put_32 (obfd, BEQLR, p), p += 4;
10716 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10717 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10718 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10719
10720 if (r != NULL)
10721 r[0].r_offset += 9 * 4;
10722 p = build_plt_stub (htab, stub_entry, p, offset, r);
10723 bfd_put_32 (obfd, BCTRL, p - 4);
10724
10725 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10726 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10727 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10728 bfd_put_32 (obfd, BLR, p), p += 4;
10729
10730 return p;
10731 }
10732
10733 static Elf_Internal_Rela *
10734 get_relocs (asection *sec, int count)
10735 {
10736 Elf_Internal_Rela *relocs;
10737 struct bfd_elf_section_data *elfsec_data;
10738
10739 elfsec_data = elf_section_data (sec);
10740 relocs = elfsec_data->relocs;
10741 if (relocs == NULL)
10742 {
10743 bfd_size_type relsize;
10744 relsize = sec->reloc_count * sizeof (*relocs);
10745 relocs = bfd_alloc (sec->owner, relsize);
10746 if (relocs == NULL)
10747 return NULL;
10748 elfsec_data->relocs = relocs;
10749 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10750 sizeof (Elf_Internal_Shdr));
10751 if (elfsec_data->rela.hdr == NULL)
10752 return NULL;
10753 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10754 * sizeof (Elf64_External_Rela));
10755 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10756 sec->reloc_count = 0;
10757 }
10758 relocs += sec->reloc_count;
10759 sec->reloc_count += count;
10760 return relocs;
10761 }
10762
10763 static bfd_vma
10764 get_r2off (struct bfd_link_info *info,
10765 struct ppc_stub_hash_entry *stub_entry)
10766 {
10767 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10768 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10769
10770 if (r2off == 0)
10771 {
10772 /* Support linking -R objects. Get the toc pointer from the
10773 opd entry. */
10774 char buf[8];
10775 if (!htab->opd_abi)
10776 return r2off;
10777 asection *opd = stub_entry->h->elf.root.u.def.section;
10778 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10779
10780 if (strcmp (opd->name, ".opd") != 0
10781 || opd->reloc_count != 0)
10782 {
10783 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10784 stub_entry->h->elf.root.root.string);
10785 bfd_set_error (bfd_error_bad_value);
10786 return (bfd_vma) -1;
10787 }
10788 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10789 return (bfd_vma) -1;
10790 r2off = bfd_get_64 (opd->owner, buf);
10791 r2off -= elf_gp (info->output_bfd);
10792 }
10793 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10794 return r2off;
10795 }
10796
10797 static bfd_boolean
10798 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10799 {
10800 struct ppc_stub_hash_entry *stub_entry;
10801 struct ppc_branch_hash_entry *br_entry;
10802 struct bfd_link_info *info;
10803 struct ppc_link_hash_table *htab;
10804 bfd_byte *loc;
10805 bfd_byte *p;
10806 bfd_vma dest, off;
10807 int size;
10808 Elf_Internal_Rela *r;
10809 asection *plt;
10810
10811 /* Massage our args to the form they really have. */
10812 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10813 info = in_arg;
10814
10815 htab = ppc_hash_table (info);
10816 if (htab == NULL)
10817 return FALSE;
10818
10819 /* Make a note of the offset within the stubs for this entry. */
10820 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10821 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10822
10823 htab->stub_count[stub_entry->stub_type - 1] += 1;
10824 switch (stub_entry->stub_type)
10825 {
10826 case ppc_stub_long_branch:
10827 case ppc_stub_long_branch_r2off:
10828 /* Branches are relative. This is where we are going to. */
10829 dest = (stub_entry->target_value
10830 + stub_entry->target_section->output_offset
10831 + stub_entry->target_section->output_section->vma);
10832 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10833 off = dest;
10834
10835 /* And this is where we are coming from. */
10836 off -= (stub_entry->stub_offset
10837 + stub_entry->group->stub_sec->output_offset
10838 + stub_entry->group->stub_sec->output_section->vma);
10839
10840 size = 4;
10841 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10842 {
10843 bfd_vma r2off = get_r2off (info, stub_entry);
10844
10845 if (r2off == (bfd_vma) -1)
10846 {
10847 htab->stub_error = TRUE;
10848 return FALSE;
10849 }
10850 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10851 loc += 4;
10852 size = 8;
10853 if (PPC_HA (r2off) != 0)
10854 {
10855 bfd_put_32 (htab->params->stub_bfd,
10856 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10857 loc += 4;
10858 size += 4;
10859 }
10860 if (PPC_LO (r2off) != 0)
10861 {
10862 bfd_put_32 (htab->params->stub_bfd,
10863 ADDI_R2_R2 | PPC_LO (r2off), loc);
10864 loc += 4;
10865 size += 4;
10866 }
10867 off -= size - 4;
10868 }
10869 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10870
10871 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10872 {
10873 info->callbacks->einfo
10874 (_("%P: long branch stub `%s' offset overflow\n"),
10875 stub_entry->root.string);
10876 htab->stub_error = TRUE;
10877 return FALSE;
10878 }
10879
10880 if (info->emitrelocations)
10881 {
10882 r = get_relocs (stub_entry->group->stub_sec, 1);
10883 if (r == NULL)
10884 return FALSE;
10885 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10886 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10887 r->r_addend = dest;
10888 if (stub_entry->h != NULL)
10889 {
10890 struct elf_link_hash_entry **hashes;
10891 unsigned long symndx;
10892 struct ppc_link_hash_entry *h;
10893
10894 hashes = elf_sym_hashes (htab->params->stub_bfd);
10895 if (hashes == NULL)
10896 {
10897 bfd_size_type hsize;
10898
10899 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10900 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10901 if (hashes == NULL)
10902 return FALSE;
10903 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10904 htab->stub_globals = 1;
10905 }
10906 symndx = htab->stub_globals++;
10907 h = stub_entry->h;
10908 hashes[symndx] = &h->elf;
10909 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10910 if (h->oh != NULL && h->oh->is_func)
10911 h = ppc_follow_link (h->oh);
10912 if (h->elf.root.u.def.section != stub_entry->target_section)
10913 /* H is an opd symbol. The addend must be zero. */
10914 r->r_addend = 0;
10915 else
10916 {
10917 off = (h->elf.root.u.def.value
10918 + h->elf.root.u.def.section->output_offset
10919 + h->elf.root.u.def.section->output_section->vma);
10920 r->r_addend -= off;
10921 }
10922 }
10923 }
10924 break;
10925
10926 case ppc_stub_plt_branch:
10927 case ppc_stub_plt_branch_r2off:
10928 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10929 stub_entry->root.string + 9,
10930 FALSE, FALSE);
10931 if (br_entry == NULL)
10932 {
10933 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10934 stub_entry->root.string);
10935 htab->stub_error = TRUE;
10936 return FALSE;
10937 }
10938
10939 dest = (stub_entry->target_value
10940 + stub_entry->target_section->output_offset
10941 + stub_entry->target_section->output_section->vma);
10942 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10943 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10944
10945 bfd_put_64 (htab->brlt->owner, dest,
10946 htab->brlt->contents + br_entry->offset);
10947
10948 if (br_entry->iter == htab->stub_iteration)
10949 {
10950 br_entry->iter = 0;
10951
10952 if (htab->relbrlt != NULL)
10953 {
10954 /* Create a reloc for the branch lookup table entry. */
10955 Elf_Internal_Rela rela;
10956 bfd_byte *rl;
10957
10958 rela.r_offset = (br_entry->offset
10959 + htab->brlt->output_offset
10960 + htab->brlt->output_section->vma);
10961 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10962 rela.r_addend = dest;
10963
10964 rl = htab->relbrlt->contents;
10965 rl += (htab->relbrlt->reloc_count++
10966 * sizeof (Elf64_External_Rela));
10967 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10968 }
10969 else if (info->emitrelocations)
10970 {
10971 r = get_relocs (htab->brlt, 1);
10972 if (r == NULL)
10973 return FALSE;
10974 /* brlt, being SEC_LINKER_CREATED does not go through the
10975 normal reloc processing. Symbols and offsets are not
10976 translated from input file to output file form, so
10977 set up the offset per the output file. */
10978 r->r_offset = (br_entry->offset
10979 + htab->brlt->output_offset
10980 + htab->brlt->output_section->vma);
10981 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10982 r->r_addend = dest;
10983 }
10984 }
10985
10986 dest = (br_entry->offset
10987 + htab->brlt->output_offset
10988 + htab->brlt->output_section->vma);
10989
10990 off = (dest
10991 - elf_gp (htab->brlt->output_section->owner)
10992 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10993
10994 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10995 {
10996 info->callbacks->einfo
10997 (_("%P: linkage table error against `%T'\n"),
10998 stub_entry->root.string);
10999 bfd_set_error (bfd_error_bad_value);
11000 htab->stub_error = TRUE;
11001 return FALSE;
11002 }
11003
11004 if (info->emitrelocations)
11005 {
11006 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11007 if (r == NULL)
11008 return FALSE;
11009 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11010 if (bfd_big_endian (info->output_bfd))
11011 r[0].r_offset += 2;
11012 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11013 r[0].r_offset += 4;
11014 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11015 r[0].r_addend = dest;
11016 if (PPC_HA (off) != 0)
11017 {
11018 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11019 r[1].r_offset = r[0].r_offset + 4;
11020 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11021 r[1].r_addend = r[0].r_addend;
11022 }
11023 }
11024
11025 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11026 {
11027 if (PPC_HA (off) != 0)
11028 {
11029 size = 16;
11030 bfd_put_32 (htab->params->stub_bfd,
11031 ADDIS_R12_R2 | PPC_HA (off), loc);
11032 loc += 4;
11033 bfd_put_32 (htab->params->stub_bfd,
11034 LD_R12_0R12 | PPC_LO (off), loc);
11035 }
11036 else
11037 {
11038 size = 12;
11039 bfd_put_32 (htab->params->stub_bfd,
11040 LD_R12_0R2 | PPC_LO (off), loc);
11041 }
11042 }
11043 else
11044 {
11045 bfd_vma r2off = get_r2off (info, stub_entry);
11046
11047 if (r2off == (bfd_vma) -1)
11048 {
11049 htab->stub_error = TRUE;
11050 return FALSE;
11051 }
11052
11053 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11054 loc += 4;
11055 size = 16;
11056 if (PPC_HA (off) != 0)
11057 {
11058 size += 4;
11059 bfd_put_32 (htab->params->stub_bfd,
11060 ADDIS_R12_R2 | PPC_HA (off), loc);
11061 loc += 4;
11062 bfd_put_32 (htab->params->stub_bfd,
11063 LD_R12_0R12 | PPC_LO (off), loc);
11064 }
11065 else
11066 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11067
11068 if (PPC_HA (r2off) != 0)
11069 {
11070 size += 4;
11071 loc += 4;
11072 bfd_put_32 (htab->params->stub_bfd,
11073 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11074 }
11075 if (PPC_LO (r2off) != 0)
11076 {
11077 size += 4;
11078 loc += 4;
11079 bfd_put_32 (htab->params->stub_bfd,
11080 ADDI_R2_R2 | PPC_LO (r2off), loc);
11081 }
11082 }
11083 loc += 4;
11084 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11085 loc += 4;
11086 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11087 break;
11088
11089 case ppc_stub_plt_call:
11090 case ppc_stub_plt_call_r2save:
11091 if (stub_entry->h != NULL
11092 && stub_entry->h->is_func_descriptor
11093 && stub_entry->h->oh != NULL)
11094 {
11095 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11096
11097 /* If the old-ABI "dot-symbol" is undefined make it weak so
11098 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11099 if (fh->elf.root.type == bfd_link_hash_undefined
11100 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11101 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11102 fh->elf.root.type = bfd_link_hash_undefweak;
11103 }
11104
11105 /* Now build the stub. */
11106 dest = stub_entry->plt_ent->plt.offset & ~1;
11107 if (dest >= (bfd_vma) -2)
11108 abort ();
11109
11110 plt = htab->elf.splt;
11111 if (!htab->elf.dynamic_sections_created
11112 || stub_entry->h == NULL
11113 || stub_entry->h->elf.dynindx == -1)
11114 plt = htab->elf.iplt;
11115
11116 dest += plt->output_offset + plt->output_section->vma;
11117
11118 if (stub_entry->h == NULL
11119 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11120 {
11121 Elf_Internal_Rela rela;
11122 bfd_byte *rl;
11123
11124 rela.r_offset = dest;
11125 if (htab->opd_abi)
11126 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11127 else
11128 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11129 rela.r_addend = (stub_entry->target_value
11130 + stub_entry->target_section->output_offset
11131 + stub_entry->target_section->output_section->vma);
11132
11133 rl = (htab->elf.irelplt->contents
11134 + (htab->elf.irelplt->reloc_count++
11135 * sizeof (Elf64_External_Rela)));
11136 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11137 stub_entry->plt_ent->plt.offset |= 1;
11138 }
11139
11140 off = (dest
11141 - elf_gp (plt->output_section->owner)
11142 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11143
11144 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11145 {
11146 info->callbacks->einfo
11147 /* xgettext:c-format */
11148 (_("%P: linkage table error against `%T'\n"),
11149 stub_entry->h != NULL
11150 ? stub_entry->h->elf.root.root.string
11151 : "<local sym>");
11152 bfd_set_error (bfd_error_bad_value);
11153 htab->stub_error = TRUE;
11154 return FALSE;
11155 }
11156
11157 if (htab->params->plt_stub_align != 0)
11158 {
11159 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11160
11161 stub_entry->group->stub_sec->size += pad;
11162 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11163 loc += pad;
11164 }
11165
11166 r = NULL;
11167 if (info->emitrelocations)
11168 {
11169 r = get_relocs (stub_entry->group->stub_sec,
11170 ((PPC_HA (off) != 0)
11171 + (htab->opd_abi
11172 ? 2 + (htab->params->plt_static_chain
11173 && PPC_HA (off + 16) == PPC_HA (off))
11174 : 1)));
11175 if (r == NULL)
11176 return FALSE;
11177 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11178 if (bfd_big_endian (info->output_bfd))
11179 r[0].r_offset += 2;
11180 r[0].r_addend = dest;
11181 }
11182 if (stub_entry->h != NULL
11183 && (stub_entry->h == htab->tls_get_addr_fd
11184 || stub_entry->h == htab->tls_get_addr)
11185 && htab->params->tls_get_addr_opt)
11186 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11187 else
11188 p = build_plt_stub (htab, stub_entry, loc, off, r);
11189 size = p - loc;
11190 break;
11191
11192 case ppc_stub_save_res:
11193 return TRUE;
11194
11195 default:
11196 BFD_FAIL ();
11197 return FALSE;
11198 }
11199
11200 stub_entry->group->stub_sec->size += size;
11201
11202 if (htab->params->emit_stub_syms)
11203 {
11204 struct elf_link_hash_entry *h;
11205 size_t len1, len2;
11206 char *name;
11207 const char *const stub_str[] = { "long_branch",
11208 "long_branch_r2off",
11209 "plt_branch",
11210 "plt_branch_r2off",
11211 "plt_call",
11212 "plt_call" };
11213
11214 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11215 len2 = strlen (stub_entry->root.string);
11216 name = bfd_malloc (len1 + len2 + 2);
11217 if (name == NULL)
11218 return FALSE;
11219 memcpy (name, stub_entry->root.string, 9);
11220 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11221 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11222 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11223 if (h == NULL)
11224 return FALSE;
11225 if (h->root.type == bfd_link_hash_new)
11226 {
11227 h->root.type = bfd_link_hash_defined;
11228 h->root.u.def.section = stub_entry->group->stub_sec;
11229 h->root.u.def.value = stub_entry->stub_offset;
11230 h->ref_regular = 1;
11231 h->def_regular = 1;
11232 h->ref_regular_nonweak = 1;
11233 h->forced_local = 1;
11234 h->non_elf = 0;
11235 h->root.linker_def = 1;
11236 }
11237 }
11238
11239 return TRUE;
11240 }
11241
11242 /* As above, but don't actually build the stub. Just bump offset so
11243 we know stub section sizes, and select plt_branch stubs where
11244 long_branch stubs won't do. */
11245
11246 static bfd_boolean
11247 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11248 {
11249 struct ppc_stub_hash_entry *stub_entry;
11250 struct bfd_link_info *info;
11251 struct ppc_link_hash_table *htab;
11252 bfd_vma off;
11253 int size;
11254
11255 /* Massage our args to the form they really have. */
11256 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11257 info = in_arg;
11258
11259 htab = ppc_hash_table (info);
11260 if (htab == NULL)
11261 return FALSE;
11262
11263 if (stub_entry->h != NULL
11264 && stub_entry->h->save_res
11265 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11266 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11267 {
11268 /* Don't make stubs to out-of-line register save/restore
11269 functions. Instead, emit copies of the functions. */
11270 stub_entry->group->needs_save_res = 1;
11271 stub_entry->stub_type = ppc_stub_save_res;
11272 return TRUE;
11273 }
11274
11275 if (stub_entry->stub_type == ppc_stub_plt_call
11276 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11277 {
11278 asection *plt;
11279 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11280 if (off >= (bfd_vma) -2)
11281 abort ();
11282 plt = htab->elf.splt;
11283 if (!htab->elf.dynamic_sections_created
11284 || stub_entry->h == NULL
11285 || stub_entry->h->elf.dynindx == -1)
11286 plt = htab->elf.iplt;
11287 off += (plt->output_offset
11288 + plt->output_section->vma
11289 - elf_gp (plt->output_section->owner)
11290 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11291
11292 size = plt_stub_size (htab, stub_entry, off);
11293 if (htab->params->plt_stub_align)
11294 size += plt_stub_pad (htab, stub_entry, off);
11295 if (info->emitrelocations)
11296 {
11297 stub_entry->group->stub_sec->reloc_count
11298 += ((PPC_HA (off) != 0)
11299 + (htab->opd_abi
11300 ? 2 + (htab->params->plt_static_chain
11301 && PPC_HA (off + 16) == PPC_HA (off))
11302 : 1));
11303 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11304 }
11305 }
11306 else
11307 {
11308 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11309 variants. */
11310 bfd_vma r2off = 0;
11311 bfd_vma local_off = 0;
11312
11313 off = (stub_entry->target_value
11314 + stub_entry->target_section->output_offset
11315 + stub_entry->target_section->output_section->vma);
11316 off -= (stub_entry->group->stub_sec->size
11317 + stub_entry->group->stub_sec->output_offset
11318 + stub_entry->group->stub_sec->output_section->vma);
11319
11320 /* Reset the stub type from the plt variant in case we now
11321 can reach with a shorter stub. */
11322 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11323 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11324
11325 size = 4;
11326 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11327 {
11328 r2off = get_r2off (info, stub_entry);
11329 if (r2off == (bfd_vma) -1)
11330 {
11331 htab->stub_error = TRUE;
11332 return FALSE;
11333 }
11334 size = 8;
11335 if (PPC_HA (r2off) != 0)
11336 size += 4;
11337 if (PPC_LO (r2off) != 0)
11338 size += 4;
11339 off -= size - 4;
11340 }
11341
11342 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11343
11344 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11345 Do the same for -R objects without function descriptors. */
11346 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11347 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11348 && r2off == 0
11349 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11350 {
11351 struct ppc_branch_hash_entry *br_entry;
11352
11353 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11354 stub_entry->root.string + 9,
11355 TRUE, FALSE);
11356 if (br_entry == NULL)
11357 {
11358 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11359 stub_entry->root.string);
11360 htab->stub_error = TRUE;
11361 return FALSE;
11362 }
11363
11364 if (br_entry->iter != htab->stub_iteration)
11365 {
11366 br_entry->iter = htab->stub_iteration;
11367 br_entry->offset = htab->brlt->size;
11368 htab->brlt->size += 8;
11369
11370 if (htab->relbrlt != NULL)
11371 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11372 else if (info->emitrelocations)
11373 {
11374 htab->brlt->reloc_count += 1;
11375 htab->brlt->flags |= SEC_RELOC;
11376 }
11377 }
11378
11379 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11380 off = (br_entry->offset
11381 + htab->brlt->output_offset
11382 + htab->brlt->output_section->vma
11383 - elf_gp (htab->brlt->output_section->owner)
11384 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11385
11386 if (info->emitrelocations)
11387 {
11388 stub_entry->group->stub_sec->reloc_count
11389 += 1 + (PPC_HA (off) != 0);
11390 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11391 }
11392
11393 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11394 {
11395 size = 12;
11396 if (PPC_HA (off) != 0)
11397 size = 16;
11398 }
11399 else
11400 {
11401 size = 16;
11402 if (PPC_HA (off) != 0)
11403 size += 4;
11404
11405 if (PPC_HA (r2off) != 0)
11406 size += 4;
11407 if (PPC_LO (r2off) != 0)
11408 size += 4;
11409 }
11410 }
11411 else if (info->emitrelocations)
11412 {
11413 stub_entry->group->stub_sec->reloc_count += 1;
11414 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11415 }
11416 }
11417
11418 stub_entry->group->stub_sec->size += size;
11419 return TRUE;
11420 }
11421
11422 /* Set up various things so that we can make a list of input sections
11423 for each output section included in the link. Returns -1 on error,
11424 0 when no stubs will be needed, and 1 on success. */
11425
11426 int
11427 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11428 {
11429 unsigned int id;
11430 bfd_size_type amt;
11431 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11432
11433 if (htab == NULL)
11434 return -1;
11435
11436 htab->sec_info_arr_size = bfd_get_next_section_id ();
11437 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11438 htab->sec_info = bfd_zmalloc (amt);
11439 if (htab->sec_info == NULL)
11440 return -1;
11441
11442 /* Set toc_off for com, und, abs and ind sections. */
11443 for (id = 0; id < 3; id++)
11444 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11445
11446 return 1;
11447 }
11448
11449 /* Set up for first pass at multitoc partitioning. */
11450
11451 void
11452 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11453 {
11454 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11455
11456 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11457 htab->toc_bfd = NULL;
11458 htab->toc_first_sec = NULL;
11459 }
11460
11461 /* The linker repeatedly calls this function for each TOC input section
11462 and linker generated GOT section. Group input bfds such that the toc
11463 within a group is less than 64k in size. */
11464
11465 bfd_boolean
11466 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11467 {
11468 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11469 bfd_vma addr, off, limit;
11470
11471 if (htab == NULL)
11472 return FALSE;
11473
11474 if (!htab->second_toc_pass)
11475 {
11476 /* Keep track of the first .toc or .got section for this input bfd. */
11477 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11478
11479 if (new_bfd)
11480 {
11481 htab->toc_bfd = isec->owner;
11482 htab->toc_first_sec = isec;
11483 }
11484
11485 addr = isec->output_offset + isec->output_section->vma;
11486 off = addr - htab->toc_curr;
11487 limit = 0x80008000;
11488 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11489 limit = 0x10000;
11490 if (off + isec->size > limit)
11491 {
11492 addr = (htab->toc_first_sec->output_offset
11493 + htab->toc_first_sec->output_section->vma);
11494 htab->toc_curr = addr;
11495 htab->toc_curr &= -TOC_BASE_ALIGN;
11496 }
11497
11498 /* toc_curr is the base address of this toc group. Set elf_gp
11499 for the input section to be the offset relative to the
11500 output toc base plus 0x8000. Making the input elf_gp an
11501 offset allows us to move the toc as a whole without
11502 recalculating input elf_gp. */
11503 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11504 off += TOC_BASE_OFF;
11505
11506 /* Die if someone uses a linker script that doesn't keep input
11507 file .toc and .got together. */
11508 if (new_bfd
11509 && elf_gp (isec->owner) != 0
11510 && elf_gp (isec->owner) != off)
11511 return FALSE;
11512
11513 elf_gp (isec->owner) = off;
11514 return TRUE;
11515 }
11516
11517 /* During the second pass toc_first_sec points to the start of
11518 a toc group, and toc_curr is used to track the old elf_gp.
11519 We use toc_bfd to ensure we only look at each bfd once. */
11520 if (htab->toc_bfd == isec->owner)
11521 return TRUE;
11522 htab->toc_bfd = isec->owner;
11523
11524 if (htab->toc_first_sec == NULL
11525 || htab->toc_curr != elf_gp (isec->owner))
11526 {
11527 htab->toc_curr = elf_gp (isec->owner);
11528 htab->toc_first_sec = isec;
11529 }
11530 addr = (htab->toc_first_sec->output_offset
11531 + htab->toc_first_sec->output_section->vma);
11532 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11533 elf_gp (isec->owner) = off;
11534
11535 return TRUE;
11536 }
11537
11538 /* Called via elf_link_hash_traverse to merge GOT entries for global
11539 symbol H. */
11540
11541 static bfd_boolean
11542 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11543 {
11544 if (h->root.type == bfd_link_hash_indirect)
11545 return TRUE;
11546
11547 merge_got_entries (&h->got.glist);
11548
11549 return TRUE;
11550 }
11551
11552 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11553 symbol H. */
11554
11555 static bfd_boolean
11556 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11557 {
11558 struct got_entry *gent;
11559
11560 if (h->root.type == bfd_link_hash_indirect)
11561 return TRUE;
11562
11563 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11564 if (!gent->is_indirect)
11565 allocate_got (h, (struct bfd_link_info *) inf, gent);
11566 return TRUE;
11567 }
11568
11569 /* Called on the first multitoc pass after the last call to
11570 ppc64_elf_next_toc_section. This function removes duplicate GOT
11571 entries. */
11572
11573 bfd_boolean
11574 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11575 {
11576 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11577 struct bfd *ibfd, *ibfd2;
11578 bfd_boolean done_something;
11579
11580 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11581
11582 if (!htab->do_multi_toc)
11583 return FALSE;
11584
11585 /* Merge global sym got entries within a toc group. */
11586 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11587
11588 /* And tlsld_got. */
11589 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11590 {
11591 struct got_entry *ent, *ent2;
11592
11593 if (!is_ppc64_elf (ibfd))
11594 continue;
11595
11596 ent = ppc64_tlsld_got (ibfd);
11597 if (!ent->is_indirect
11598 && ent->got.offset != (bfd_vma) -1)
11599 {
11600 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11601 {
11602 if (!is_ppc64_elf (ibfd2))
11603 continue;
11604
11605 ent2 = ppc64_tlsld_got (ibfd2);
11606 if (!ent2->is_indirect
11607 && ent2->got.offset != (bfd_vma) -1
11608 && elf_gp (ibfd2) == elf_gp (ibfd))
11609 {
11610 ent2->is_indirect = TRUE;
11611 ent2->got.ent = ent;
11612 }
11613 }
11614 }
11615 }
11616
11617 /* Zap sizes of got sections. */
11618 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11619 htab->elf.irelplt->size -= htab->got_reli_size;
11620 htab->got_reli_size = 0;
11621
11622 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11623 {
11624 asection *got, *relgot;
11625
11626 if (!is_ppc64_elf (ibfd))
11627 continue;
11628
11629 got = ppc64_elf_tdata (ibfd)->got;
11630 if (got != NULL)
11631 {
11632 got->rawsize = got->size;
11633 got->size = 0;
11634 relgot = ppc64_elf_tdata (ibfd)->relgot;
11635 relgot->rawsize = relgot->size;
11636 relgot->size = 0;
11637 }
11638 }
11639
11640 /* Now reallocate the got, local syms first. We don't need to
11641 allocate section contents again since we never increase size. */
11642 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11643 {
11644 struct got_entry **lgot_ents;
11645 struct got_entry **end_lgot_ents;
11646 struct plt_entry **local_plt;
11647 struct plt_entry **end_local_plt;
11648 unsigned char *lgot_masks;
11649 bfd_size_type locsymcount;
11650 Elf_Internal_Shdr *symtab_hdr;
11651 asection *s;
11652
11653 if (!is_ppc64_elf (ibfd))
11654 continue;
11655
11656 lgot_ents = elf_local_got_ents (ibfd);
11657 if (!lgot_ents)
11658 continue;
11659
11660 symtab_hdr = &elf_symtab_hdr (ibfd);
11661 locsymcount = symtab_hdr->sh_info;
11662 end_lgot_ents = lgot_ents + locsymcount;
11663 local_plt = (struct plt_entry **) end_lgot_ents;
11664 end_local_plt = local_plt + locsymcount;
11665 lgot_masks = (unsigned char *) end_local_plt;
11666 s = ppc64_elf_tdata (ibfd)->got;
11667 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11668 {
11669 struct got_entry *ent;
11670
11671 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11672 {
11673 unsigned int ent_size = 8;
11674 unsigned int rel_size = sizeof (Elf64_External_Rela);
11675
11676 ent->got.offset = s->size;
11677 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11678 {
11679 ent_size *= 2;
11680 rel_size *= 2;
11681 }
11682 s->size += ent_size;
11683 if ((*lgot_masks & PLT_IFUNC) != 0)
11684 {
11685 htab->elf.irelplt->size += rel_size;
11686 htab->got_reli_size += rel_size;
11687 }
11688 else if (bfd_link_pic (info))
11689 {
11690 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11691 srel->size += rel_size;
11692 }
11693 }
11694 }
11695 }
11696
11697 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11698
11699 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11700 {
11701 struct got_entry *ent;
11702
11703 if (!is_ppc64_elf (ibfd))
11704 continue;
11705
11706 ent = ppc64_tlsld_got (ibfd);
11707 if (!ent->is_indirect
11708 && ent->got.offset != (bfd_vma) -1)
11709 {
11710 asection *s = ppc64_elf_tdata (ibfd)->got;
11711 ent->got.offset = s->size;
11712 s->size += 16;
11713 if (bfd_link_pic (info))
11714 {
11715 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11716 srel->size += sizeof (Elf64_External_Rela);
11717 }
11718 }
11719 }
11720
11721 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11722 if (!done_something)
11723 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11724 {
11725 asection *got;
11726
11727 if (!is_ppc64_elf (ibfd))
11728 continue;
11729
11730 got = ppc64_elf_tdata (ibfd)->got;
11731 if (got != NULL)
11732 {
11733 done_something = got->rawsize != got->size;
11734 if (done_something)
11735 break;
11736 }
11737 }
11738
11739 if (done_something)
11740 (*htab->params->layout_sections_again) ();
11741
11742 /* Set up for second pass over toc sections to recalculate elf_gp
11743 on input sections. */
11744 htab->toc_bfd = NULL;
11745 htab->toc_first_sec = NULL;
11746 htab->second_toc_pass = TRUE;
11747 return done_something;
11748 }
11749
11750 /* Called after second pass of multitoc partitioning. */
11751
11752 void
11753 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11754 {
11755 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11756
11757 /* After the second pass, toc_curr tracks the TOC offset used
11758 for code sections below in ppc64_elf_next_input_section. */
11759 htab->toc_curr = TOC_BASE_OFF;
11760 }
11761
11762 /* No toc references were found in ISEC. If the code in ISEC makes no
11763 calls, then there's no need to use toc adjusting stubs when branching
11764 into ISEC. Actually, indirect calls from ISEC are OK as they will
11765 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11766 needed, and 2 if a cyclical call-graph was found but no other reason
11767 for a stub was detected. If called from the top level, a return of
11768 2 means the same as a return of 0. */
11769
11770 static int
11771 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11772 {
11773 int ret;
11774
11775 /* Mark this section as checked. */
11776 isec->call_check_done = 1;
11777
11778 /* We know none of our code bearing sections will need toc stubs. */
11779 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11780 return 0;
11781
11782 if (isec->size == 0)
11783 return 0;
11784
11785 if (isec->output_section == NULL)
11786 return 0;
11787
11788 ret = 0;
11789 if (isec->reloc_count != 0)
11790 {
11791 Elf_Internal_Rela *relstart, *rel;
11792 Elf_Internal_Sym *local_syms;
11793 struct ppc_link_hash_table *htab;
11794
11795 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11796 info->keep_memory);
11797 if (relstart == NULL)
11798 return -1;
11799
11800 /* Look for branches to outside of this section. */
11801 local_syms = NULL;
11802 htab = ppc_hash_table (info);
11803 if (htab == NULL)
11804 return -1;
11805
11806 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11807 {
11808 enum elf_ppc64_reloc_type r_type;
11809 unsigned long r_symndx;
11810 struct elf_link_hash_entry *h;
11811 struct ppc_link_hash_entry *eh;
11812 Elf_Internal_Sym *sym;
11813 asection *sym_sec;
11814 struct _opd_sec_data *opd;
11815 bfd_vma sym_value;
11816 bfd_vma dest;
11817
11818 r_type = ELF64_R_TYPE (rel->r_info);
11819 if (r_type != R_PPC64_REL24
11820 && r_type != R_PPC64_REL14
11821 && r_type != R_PPC64_REL14_BRTAKEN
11822 && r_type != R_PPC64_REL14_BRNTAKEN)
11823 continue;
11824
11825 r_symndx = ELF64_R_SYM (rel->r_info);
11826 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11827 isec->owner))
11828 {
11829 ret = -1;
11830 break;
11831 }
11832
11833 /* Calls to dynamic lib functions go through a plt call stub
11834 that uses r2. */
11835 eh = (struct ppc_link_hash_entry *) h;
11836 if (eh != NULL
11837 && (eh->elf.plt.plist != NULL
11838 || (eh->oh != NULL
11839 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11840 {
11841 ret = 1;
11842 break;
11843 }
11844
11845 if (sym_sec == NULL)
11846 /* Ignore other undefined symbols. */
11847 continue;
11848
11849 /* Assume branches to other sections not included in the
11850 link need stubs too, to cover -R and absolute syms. */
11851 if (sym_sec->output_section == NULL)
11852 {
11853 ret = 1;
11854 break;
11855 }
11856
11857 if (h == NULL)
11858 sym_value = sym->st_value;
11859 else
11860 {
11861 if (h->root.type != bfd_link_hash_defined
11862 && h->root.type != bfd_link_hash_defweak)
11863 abort ();
11864 sym_value = h->root.u.def.value;
11865 }
11866 sym_value += rel->r_addend;
11867
11868 /* If this branch reloc uses an opd sym, find the code section. */
11869 opd = get_opd_info (sym_sec);
11870 if (opd != NULL)
11871 {
11872 if (h == NULL && opd->adjust != NULL)
11873 {
11874 long adjust;
11875
11876 adjust = opd->adjust[OPD_NDX (sym_value)];
11877 if (adjust == -1)
11878 /* Assume deleted functions won't ever be called. */
11879 continue;
11880 sym_value += adjust;
11881 }
11882
11883 dest = opd_entry_value (sym_sec, sym_value,
11884 &sym_sec, NULL, FALSE);
11885 if (dest == (bfd_vma) -1)
11886 continue;
11887 }
11888 else
11889 dest = (sym_value
11890 + sym_sec->output_offset
11891 + sym_sec->output_section->vma);
11892
11893 /* Ignore branch to self. */
11894 if (sym_sec == isec)
11895 continue;
11896
11897 /* If the called function uses the toc, we need a stub. */
11898 if (sym_sec->has_toc_reloc
11899 || sym_sec->makes_toc_func_call)
11900 {
11901 ret = 1;
11902 break;
11903 }
11904
11905 /* Assume any branch that needs a long branch stub might in fact
11906 need a plt_branch stub. A plt_branch stub uses r2. */
11907 else if (dest - (isec->output_offset
11908 + isec->output_section->vma
11909 + rel->r_offset) + (1 << 25)
11910 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11911 ? h->other
11912 : sym->st_other))
11913 {
11914 ret = 1;
11915 break;
11916 }
11917
11918 /* If calling back to a section in the process of being
11919 tested, we can't say for sure that no toc adjusting stubs
11920 are needed, so don't return zero. */
11921 else if (sym_sec->call_check_in_progress)
11922 ret = 2;
11923
11924 /* Branches to another section that itself doesn't have any TOC
11925 references are OK. Recursively call ourselves to check. */
11926 else if (!sym_sec->call_check_done)
11927 {
11928 int recur;
11929
11930 /* Mark current section as indeterminate, so that other
11931 sections that call back to current won't be marked as
11932 known. */
11933 isec->call_check_in_progress = 1;
11934 recur = toc_adjusting_stub_needed (info, sym_sec);
11935 isec->call_check_in_progress = 0;
11936
11937 if (recur != 0)
11938 {
11939 ret = recur;
11940 if (recur != 2)
11941 break;
11942 }
11943 }
11944 }
11945
11946 if (local_syms != NULL
11947 && (elf_symtab_hdr (isec->owner).contents
11948 != (unsigned char *) local_syms))
11949 free (local_syms);
11950 if (elf_section_data (isec)->relocs != relstart)
11951 free (relstart);
11952 }
11953
11954 if ((ret & 1) == 0
11955 && isec->map_head.s != NULL
11956 && (strcmp (isec->output_section->name, ".init") == 0
11957 || strcmp (isec->output_section->name, ".fini") == 0))
11958 {
11959 if (isec->map_head.s->has_toc_reloc
11960 || isec->map_head.s->makes_toc_func_call)
11961 ret = 1;
11962 else if (!isec->map_head.s->call_check_done)
11963 {
11964 int recur;
11965 isec->call_check_in_progress = 1;
11966 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11967 isec->call_check_in_progress = 0;
11968 if (recur != 0)
11969 ret = recur;
11970 }
11971 }
11972
11973 if (ret == 1)
11974 isec->makes_toc_func_call = 1;
11975
11976 return ret;
11977 }
11978
11979 /* The linker repeatedly calls this function for each input section,
11980 in the order that input sections are linked into output sections.
11981 Build lists of input sections to determine groupings between which
11982 we may insert linker stubs. */
11983
11984 bfd_boolean
11985 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11986 {
11987 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11988
11989 if (htab == NULL)
11990 return FALSE;
11991
11992 if ((isec->output_section->flags & SEC_CODE) != 0
11993 && isec->output_section->id < htab->sec_info_arr_size)
11994 {
11995 /* This happens to make the list in reverse order,
11996 which is what we want. */
11997 htab->sec_info[isec->id].u.list
11998 = htab->sec_info[isec->output_section->id].u.list;
11999 htab->sec_info[isec->output_section->id].u.list = isec;
12000 }
12001
12002 if (htab->multi_toc_needed)
12003 {
12004 /* Analyse sections that aren't already flagged as needing a
12005 valid toc pointer. Exclude .fixup for the linux kernel.
12006 .fixup contains branches, but only back to the function that
12007 hit an exception. */
12008 if (!(isec->has_toc_reloc
12009 || (isec->flags & SEC_CODE) == 0
12010 || strcmp (isec->name, ".fixup") == 0
12011 || isec->call_check_done))
12012 {
12013 if (toc_adjusting_stub_needed (info, isec) < 0)
12014 return FALSE;
12015 }
12016 /* Make all sections use the TOC assigned for this object file.
12017 This will be wrong for pasted sections; We fix that in
12018 check_pasted_section(). */
12019 if (elf_gp (isec->owner) != 0)
12020 htab->toc_curr = elf_gp (isec->owner);
12021 }
12022
12023 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12024 return TRUE;
12025 }
12026
12027 /* Check that all .init and .fini sections use the same toc, if they
12028 have toc relocs. */
12029
12030 static bfd_boolean
12031 check_pasted_section (struct bfd_link_info *info, const char *name)
12032 {
12033 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12034
12035 if (o != NULL)
12036 {
12037 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12038 bfd_vma toc_off = 0;
12039 asection *i;
12040
12041 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12042 if (i->has_toc_reloc)
12043 {
12044 if (toc_off == 0)
12045 toc_off = htab->sec_info[i->id].toc_off;
12046 else if (toc_off != htab->sec_info[i->id].toc_off)
12047 return FALSE;
12048 }
12049
12050 if (toc_off == 0)
12051 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12052 if (i->makes_toc_func_call)
12053 {
12054 toc_off = htab->sec_info[i->id].toc_off;
12055 break;
12056 }
12057
12058 /* Make sure the whole pasted function uses the same toc offset. */
12059 if (toc_off != 0)
12060 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12061 htab->sec_info[i->id].toc_off = toc_off;
12062 }
12063 return TRUE;
12064 }
12065
12066 bfd_boolean
12067 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12068 {
12069 return (check_pasted_section (info, ".init")
12070 & check_pasted_section (info, ".fini"));
12071 }
12072
12073 /* See whether we can group stub sections together. Grouping stub
12074 sections may result in fewer stubs. More importantly, we need to
12075 put all .init* and .fini* stubs at the beginning of the .init or
12076 .fini output sections respectively, because glibc splits the
12077 _init and _fini functions into multiple parts. Putting a stub in
12078 the middle of a function is not a good idea. */
12079
12080 static bfd_boolean
12081 group_sections (struct bfd_link_info *info,
12082 bfd_size_type stub_group_size,
12083 bfd_boolean stubs_always_before_branch)
12084 {
12085 struct ppc_link_hash_table *htab;
12086 asection *osec;
12087 bfd_boolean suppress_size_errors;
12088
12089 htab = ppc_hash_table (info);
12090 if (htab == NULL)
12091 return FALSE;
12092
12093 suppress_size_errors = FALSE;
12094 if (stub_group_size == 1)
12095 {
12096 /* Default values. */
12097 if (stubs_always_before_branch)
12098 stub_group_size = 0x1e00000;
12099 else
12100 stub_group_size = 0x1c00000;
12101 suppress_size_errors = TRUE;
12102 }
12103
12104 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12105 {
12106 asection *tail;
12107
12108 if (osec->id >= htab->sec_info_arr_size)
12109 continue;
12110
12111 tail = htab->sec_info[osec->id].u.list;
12112 while (tail != NULL)
12113 {
12114 asection *curr;
12115 asection *prev;
12116 bfd_size_type total;
12117 bfd_boolean big_sec;
12118 bfd_vma curr_toc;
12119 struct map_stub *group;
12120 bfd_size_type group_size;
12121
12122 curr = tail;
12123 total = tail->size;
12124 group_size = (ppc64_elf_section_data (tail) != NULL
12125 && ppc64_elf_section_data (tail)->has_14bit_branch
12126 ? stub_group_size >> 10 : stub_group_size);
12127
12128 big_sec = total > group_size;
12129 if (big_sec && !suppress_size_errors)
12130 /* xgettext:c-format */
12131 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12132 tail->owner, tail);
12133 curr_toc = htab->sec_info[tail->id].toc_off;
12134
12135 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12136 && ((total += curr->output_offset - prev->output_offset)
12137 < (ppc64_elf_section_data (prev) != NULL
12138 && ppc64_elf_section_data (prev)->has_14bit_branch
12139 ? (group_size = stub_group_size >> 10) : group_size))
12140 && htab->sec_info[prev->id].toc_off == curr_toc)
12141 curr = prev;
12142
12143 /* OK, the size from the start of CURR to the end is less
12144 than group_size and thus can be handled by one stub
12145 section. (or the tail section is itself larger than
12146 group_size, in which case we may be toast.) We should
12147 really be keeping track of the total size of stubs added
12148 here, as stubs contribute to the final output section
12149 size. That's a little tricky, and this way will only
12150 break if stubs added make the total size more than 2^25,
12151 ie. for the default stub_group_size, if stubs total more
12152 than 2097152 bytes, or nearly 75000 plt call stubs. */
12153 group = bfd_alloc (curr->owner, sizeof (*group));
12154 if (group == NULL)
12155 return FALSE;
12156 group->link_sec = curr;
12157 group->stub_sec = NULL;
12158 group->needs_save_res = 0;
12159 group->next = htab->group;
12160 htab->group = group;
12161 do
12162 {
12163 prev = htab->sec_info[tail->id].u.list;
12164 /* Set up this stub group. */
12165 htab->sec_info[tail->id].u.group = group;
12166 }
12167 while (tail != curr && (tail = prev) != NULL);
12168
12169 /* But wait, there's more! Input sections up to group_size
12170 bytes before the stub section can be handled by it too.
12171 Don't do this if we have a really large section after the
12172 stubs, as adding more stubs increases the chance that
12173 branches may not reach into the stub section. */
12174 if (!stubs_always_before_branch && !big_sec)
12175 {
12176 total = 0;
12177 while (prev != NULL
12178 && ((total += tail->output_offset - prev->output_offset)
12179 < (ppc64_elf_section_data (prev) != NULL
12180 && ppc64_elf_section_data (prev)->has_14bit_branch
12181 ? (group_size = stub_group_size >> 10) : group_size))
12182 && htab->sec_info[prev->id].toc_off == curr_toc)
12183 {
12184 tail = prev;
12185 prev = htab->sec_info[tail->id].u.list;
12186 htab->sec_info[tail->id].u.group = group;
12187 }
12188 }
12189 tail = prev;
12190 }
12191 }
12192 return TRUE;
12193 }
12194
12195 static const unsigned char glink_eh_frame_cie[] =
12196 {
12197 0, 0, 0, 16, /* length. */
12198 0, 0, 0, 0, /* id. */
12199 1, /* CIE version. */
12200 'z', 'R', 0, /* Augmentation string. */
12201 4, /* Code alignment. */
12202 0x78, /* Data alignment. */
12203 65, /* RA reg. */
12204 1, /* Augmentation size. */
12205 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12206 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12207 0, 0, 0, 0
12208 };
12209
12210 /* Stripping output sections is normally done before dynamic section
12211 symbols have been allocated. This function is called later, and
12212 handles cases like htab->brlt which is mapped to its own output
12213 section. */
12214
12215 static void
12216 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12217 {
12218 if (isec->size == 0
12219 && isec->output_section->size == 0
12220 && !(isec->output_section->flags & SEC_KEEP)
12221 && !bfd_section_removed_from_list (info->output_bfd,
12222 isec->output_section)
12223 && elf_section_data (isec->output_section)->dynindx == 0)
12224 {
12225 isec->output_section->flags |= SEC_EXCLUDE;
12226 bfd_section_list_remove (info->output_bfd, isec->output_section);
12227 info->output_bfd->section_count--;
12228 }
12229 }
12230
12231 /* Determine and set the size of the stub section for a final link.
12232
12233 The basic idea here is to examine all the relocations looking for
12234 PC-relative calls to a target that is unreachable with a "bl"
12235 instruction. */
12236
12237 bfd_boolean
12238 ppc64_elf_size_stubs (struct bfd_link_info *info)
12239 {
12240 bfd_size_type stub_group_size;
12241 bfd_boolean stubs_always_before_branch;
12242 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12243
12244 if (htab == NULL)
12245 return FALSE;
12246
12247 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12248 htab->params->plt_thread_safe = 1;
12249 if (!htab->opd_abi)
12250 htab->params->plt_thread_safe = 0;
12251 else if (htab->params->plt_thread_safe == -1)
12252 {
12253 static const char *const thread_starter[] =
12254 {
12255 "pthread_create",
12256 /* libstdc++ */
12257 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12258 /* librt */
12259 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12260 "mq_notify", "create_timer",
12261 /* libanl */
12262 "getaddrinfo_a",
12263 /* libgomp */
12264 "GOMP_parallel",
12265 "GOMP_parallel_start",
12266 "GOMP_parallel_loop_static",
12267 "GOMP_parallel_loop_static_start",
12268 "GOMP_parallel_loop_dynamic",
12269 "GOMP_parallel_loop_dynamic_start",
12270 "GOMP_parallel_loop_guided",
12271 "GOMP_parallel_loop_guided_start",
12272 "GOMP_parallel_loop_runtime",
12273 "GOMP_parallel_loop_runtime_start",
12274 "GOMP_parallel_sections",
12275 "GOMP_parallel_sections_start",
12276 /* libgo */
12277 "__go_go",
12278 };
12279 unsigned i;
12280
12281 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12282 {
12283 struct elf_link_hash_entry *h;
12284 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12285 FALSE, FALSE, TRUE);
12286 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12287 if (htab->params->plt_thread_safe)
12288 break;
12289 }
12290 }
12291 stubs_always_before_branch = htab->params->group_size < 0;
12292 if (htab->params->group_size < 0)
12293 stub_group_size = -htab->params->group_size;
12294 else
12295 stub_group_size = htab->params->group_size;
12296
12297 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12298 return FALSE;
12299
12300 #define STUB_SHRINK_ITER 20
12301 /* Loop until no stubs added. After iteration 20 of this loop we may
12302 exit on a stub section shrinking. This is to break out of a
12303 pathological case where adding stubs on one iteration decreases
12304 section gaps (perhaps due to alignment), which then requires
12305 fewer or smaller stubs on the next iteration. */
12306
12307 while (1)
12308 {
12309 bfd *input_bfd;
12310 unsigned int bfd_indx;
12311 struct map_stub *group;
12312 asection *stub_sec;
12313
12314 htab->stub_iteration += 1;
12315
12316 for (input_bfd = info->input_bfds, bfd_indx = 0;
12317 input_bfd != NULL;
12318 input_bfd = input_bfd->link.next, bfd_indx++)
12319 {
12320 Elf_Internal_Shdr *symtab_hdr;
12321 asection *section;
12322 Elf_Internal_Sym *local_syms = NULL;
12323
12324 if (!is_ppc64_elf (input_bfd))
12325 continue;
12326
12327 /* We'll need the symbol table in a second. */
12328 symtab_hdr = &elf_symtab_hdr (input_bfd);
12329 if (symtab_hdr->sh_info == 0)
12330 continue;
12331
12332 /* Walk over each section attached to the input bfd. */
12333 for (section = input_bfd->sections;
12334 section != NULL;
12335 section = section->next)
12336 {
12337 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12338
12339 /* If there aren't any relocs, then there's nothing more
12340 to do. */
12341 if ((section->flags & SEC_RELOC) == 0
12342 || (section->flags & SEC_ALLOC) == 0
12343 || (section->flags & SEC_LOAD) == 0
12344 || (section->flags & SEC_CODE) == 0
12345 || section->reloc_count == 0)
12346 continue;
12347
12348 /* If this section is a link-once section that will be
12349 discarded, then don't create any stubs. */
12350 if (section->output_section == NULL
12351 || section->output_section->owner != info->output_bfd)
12352 continue;
12353
12354 /* Get the relocs. */
12355 internal_relocs
12356 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12357 info->keep_memory);
12358 if (internal_relocs == NULL)
12359 goto error_ret_free_local;
12360
12361 /* Now examine each relocation. */
12362 irela = internal_relocs;
12363 irelaend = irela + section->reloc_count;
12364 for (; irela < irelaend; irela++)
12365 {
12366 enum elf_ppc64_reloc_type r_type;
12367 unsigned int r_indx;
12368 enum ppc_stub_type stub_type;
12369 struct ppc_stub_hash_entry *stub_entry;
12370 asection *sym_sec, *code_sec;
12371 bfd_vma sym_value, code_value;
12372 bfd_vma destination;
12373 unsigned long local_off;
12374 bfd_boolean ok_dest;
12375 struct ppc_link_hash_entry *hash;
12376 struct ppc_link_hash_entry *fdh;
12377 struct elf_link_hash_entry *h;
12378 Elf_Internal_Sym *sym;
12379 char *stub_name;
12380 const asection *id_sec;
12381 struct _opd_sec_data *opd;
12382 struct plt_entry *plt_ent;
12383
12384 r_type = ELF64_R_TYPE (irela->r_info);
12385 r_indx = ELF64_R_SYM (irela->r_info);
12386
12387 if (r_type >= R_PPC64_max)
12388 {
12389 bfd_set_error (bfd_error_bad_value);
12390 goto error_ret_free_internal;
12391 }
12392
12393 /* Only look for stubs on branch instructions. */
12394 if (r_type != R_PPC64_REL24
12395 && r_type != R_PPC64_REL14
12396 && r_type != R_PPC64_REL14_BRTAKEN
12397 && r_type != R_PPC64_REL14_BRNTAKEN)
12398 continue;
12399
12400 /* Now determine the call target, its name, value,
12401 section. */
12402 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12403 r_indx, input_bfd))
12404 goto error_ret_free_internal;
12405 hash = (struct ppc_link_hash_entry *) h;
12406
12407 ok_dest = FALSE;
12408 fdh = NULL;
12409 sym_value = 0;
12410 if (hash == NULL)
12411 {
12412 sym_value = sym->st_value;
12413 if (sym_sec != NULL
12414 && sym_sec->output_section != NULL)
12415 ok_dest = TRUE;
12416 }
12417 else if (hash->elf.root.type == bfd_link_hash_defined
12418 || hash->elf.root.type == bfd_link_hash_defweak)
12419 {
12420 sym_value = hash->elf.root.u.def.value;
12421 if (sym_sec->output_section != NULL)
12422 ok_dest = TRUE;
12423 }
12424 else if (hash->elf.root.type == bfd_link_hash_undefweak
12425 || hash->elf.root.type == bfd_link_hash_undefined)
12426 {
12427 /* Recognise an old ABI func code entry sym, and
12428 use the func descriptor sym instead if it is
12429 defined. */
12430 if (hash->elf.root.root.string[0] == '.'
12431 && hash->oh != NULL)
12432 {
12433 fdh = ppc_follow_link (hash->oh);
12434 if (fdh->elf.root.type == bfd_link_hash_defined
12435 || fdh->elf.root.type == bfd_link_hash_defweak)
12436 {
12437 sym_sec = fdh->elf.root.u.def.section;
12438 sym_value = fdh->elf.root.u.def.value;
12439 if (sym_sec->output_section != NULL)
12440 ok_dest = TRUE;
12441 }
12442 else
12443 fdh = NULL;
12444 }
12445 }
12446 else
12447 {
12448 bfd_set_error (bfd_error_bad_value);
12449 goto error_ret_free_internal;
12450 }
12451
12452 destination = 0;
12453 local_off = 0;
12454 if (ok_dest)
12455 {
12456 sym_value += irela->r_addend;
12457 destination = (sym_value
12458 + sym_sec->output_offset
12459 + sym_sec->output_section->vma);
12460 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12461 ? hash->elf.other
12462 : sym->st_other);
12463 }
12464
12465 code_sec = sym_sec;
12466 code_value = sym_value;
12467 opd = get_opd_info (sym_sec);
12468 if (opd != NULL)
12469 {
12470 bfd_vma dest;
12471
12472 if (hash == NULL && opd->adjust != NULL)
12473 {
12474 long adjust = opd->adjust[OPD_NDX (sym_value)];
12475 if (adjust == -1)
12476 continue;
12477 code_value += adjust;
12478 sym_value += adjust;
12479 }
12480 dest = opd_entry_value (sym_sec, sym_value,
12481 &code_sec, &code_value, FALSE);
12482 if (dest != (bfd_vma) -1)
12483 {
12484 destination = dest;
12485 if (fdh != NULL)
12486 {
12487 /* Fixup old ABI sym to point at code
12488 entry. */
12489 hash->elf.root.type = bfd_link_hash_defweak;
12490 hash->elf.root.u.def.section = code_sec;
12491 hash->elf.root.u.def.value = code_value;
12492 }
12493 }
12494 }
12495
12496 /* Determine what (if any) linker stub is needed. */
12497 plt_ent = NULL;
12498 stub_type = ppc_type_of_stub (section, irela, &hash,
12499 &plt_ent, destination,
12500 local_off);
12501
12502 if (stub_type != ppc_stub_plt_call)
12503 {
12504 /* Check whether we need a TOC adjusting stub.
12505 Since the linker pastes together pieces from
12506 different object files when creating the
12507 _init and _fini functions, it may be that a
12508 call to what looks like a local sym is in
12509 fact a call needing a TOC adjustment. */
12510 if (code_sec != NULL
12511 && code_sec->output_section != NULL
12512 && (htab->sec_info[code_sec->id].toc_off
12513 != htab->sec_info[section->id].toc_off)
12514 && (code_sec->has_toc_reloc
12515 || code_sec->makes_toc_func_call))
12516 stub_type = ppc_stub_long_branch_r2off;
12517 }
12518
12519 if (stub_type == ppc_stub_none)
12520 continue;
12521
12522 /* __tls_get_addr calls might be eliminated. */
12523 if (stub_type != ppc_stub_plt_call
12524 && hash != NULL
12525 && (hash == htab->tls_get_addr
12526 || hash == htab->tls_get_addr_fd)
12527 && section->has_tls_reloc
12528 && irela != internal_relocs)
12529 {
12530 /* Get tls info. */
12531 unsigned char *tls_mask;
12532
12533 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12534 irela - 1, input_bfd))
12535 goto error_ret_free_internal;
12536 if (*tls_mask != 0)
12537 continue;
12538 }
12539
12540 if (stub_type == ppc_stub_plt_call
12541 && irela + 1 < irelaend
12542 && irela[1].r_offset == irela->r_offset + 4
12543 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12544 {
12545 if (!tocsave_find (htab, INSERT,
12546 &local_syms, irela + 1, input_bfd))
12547 goto error_ret_free_internal;
12548 }
12549 else if (stub_type == ppc_stub_plt_call)
12550 stub_type = ppc_stub_plt_call_r2save;
12551
12552 /* Support for grouping stub sections. */
12553 id_sec = htab->sec_info[section->id].u.group->link_sec;
12554
12555 /* Get the name of this stub. */
12556 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12557 if (!stub_name)
12558 goto error_ret_free_internal;
12559
12560 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12561 stub_name, FALSE, FALSE);
12562 if (stub_entry != NULL)
12563 {
12564 /* The proper stub has already been created. */
12565 free (stub_name);
12566 if (stub_type == ppc_stub_plt_call_r2save)
12567 stub_entry->stub_type = stub_type;
12568 continue;
12569 }
12570
12571 stub_entry = ppc_add_stub (stub_name, section, info);
12572 if (stub_entry == NULL)
12573 {
12574 free (stub_name);
12575 error_ret_free_internal:
12576 if (elf_section_data (section)->relocs == NULL)
12577 free (internal_relocs);
12578 error_ret_free_local:
12579 if (local_syms != NULL
12580 && (symtab_hdr->contents
12581 != (unsigned char *) local_syms))
12582 free (local_syms);
12583 return FALSE;
12584 }
12585
12586 stub_entry->stub_type = stub_type;
12587 if (stub_type != ppc_stub_plt_call
12588 && stub_type != ppc_stub_plt_call_r2save)
12589 {
12590 stub_entry->target_value = code_value;
12591 stub_entry->target_section = code_sec;
12592 }
12593 else
12594 {
12595 stub_entry->target_value = sym_value;
12596 stub_entry->target_section = sym_sec;
12597 }
12598 stub_entry->h = hash;
12599 stub_entry->plt_ent = plt_ent;
12600 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12601
12602 if (stub_entry->h != NULL)
12603 htab->stub_globals += 1;
12604 }
12605
12606 /* We're done with the internal relocs, free them. */
12607 if (elf_section_data (section)->relocs != internal_relocs)
12608 free (internal_relocs);
12609 }
12610
12611 if (local_syms != NULL
12612 && symtab_hdr->contents != (unsigned char *) local_syms)
12613 {
12614 if (!info->keep_memory)
12615 free (local_syms);
12616 else
12617 symtab_hdr->contents = (unsigned char *) local_syms;
12618 }
12619 }
12620
12621 /* We may have added some stubs. Find out the new size of the
12622 stub sections. */
12623 for (stub_sec = htab->params->stub_bfd->sections;
12624 stub_sec != NULL;
12625 stub_sec = stub_sec->next)
12626 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12627 {
12628 if (htab->stub_iteration <= STUB_SHRINK_ITER
12629 || stub_sec->rawsize < stub_sec->size)
12630 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12631 stub_sec->rawsize = stub_sec->size;
12632 stub_sec->size = 0;
12633 stub_sec->reloc_count = 0;
12634 stub_sec->flags &= ~SEC_RELOC;
12635 }
12636
12637 htab->brlt->size = 0;
12638 htab->brlt->reloc_count = 0;
12639 htab->brlt->flags &= ~SEC_RELOC;
12640 if (htab->relbrlt != NULL)
12641 htab->relbrlt->size = 0;
12642
12643 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12644
12645 for (group = htab->group; group != NULL; group = group->next)
12646 if (group->needs_save_res)
12647 group->stub_sec->size += htab->sfpr->size;
12648
12649 if (info->emitrelocations
12650 && htab->glink != NULL && htab->glink->size != 0)
12651 {
12652 htab->glink->reloc_count = 1;
12653 htab->glink->flags |= SEC_RELOC;
12654 }
12655
12656 if (htab->glink_eh_frame != NULL
12657 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12658 && htab->glink_eh_frame->output_section->size != 0)
12659 {
12660 size_t size = 0, align;
12661
12662 for (stub_sec = htab->params->stub_bfd->sections;
12663 stub_sec != NULL;
12664 stub_sec = stub_sec->next)
12665 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12666 size += 24;
12667 if (htab->glink != NULL && htab->glink->size != 0)
12668 size += 24;
12669 if (size != 0)
12670 size += sizeof (glink_eh_frame_cie);
12671 align = 1;
12672 align <<= htab->glink_eh_frame->output_section->alignment_power;
12673 align -= 1;
12674 size = (size + align) & ~align;
12675 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12676 htab->glink_eh_frame->size = size;
12677 }
12678
12679 if (htab->params->plt_stub_align != 0)
12680 for (stub_sec = htab->params->stub_bfd->sections;
12681 stub_sec != NULL;
12682 stub_sec = stub_sec->next)
12683 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12684 stub_sec->size = ((stub_sec->size
12685 + (1 << htab->params->plt_stub_align) - 1)
12686 & -(1 << htab->params->plt_stub_align));
12687
12688 for (stub_sec = htab->params->stub_bfd->sections;
12689 stub_sec != NULL;
12690 stub_sec = stub_sec->next)
12691 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12692 && stub_sec->rawsize != stub_sec->size
12693 && (htab->stub_iteration <= STUB_SHRINK_ITER
12694 || stub_sec->rawsize < stub_sec->size))
12695 break;
12696
12697 if (stub_sec == NULL
12698 && (htab->glink_eh_frame == NULL
12699 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12700 break;
12701
12702 /* Ask the linker to do its stuff. */
12703 (*htab->params->layout_sections_again) ();
12704 }
12705
12706 if (htab->glink_eh_frame != NULL
12707 && htab->glink_eh_frame->size != 0)
12708 {
12709 bfd_vma val;
12710 bfd_byte *p, *last_fde;
12711 size_t last_fde_len, size, align, pad;
12712 asection *stub_sec;
12713
12714 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12715 if (p == NULL)
12716 return FALSE;
12717 htab->glink_eh_frame->contents = p;
12718 last_fde = p;
12719
12720 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12721 /* CIE length (rewrite in case little-endian). */
12722 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12723 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12724 p += sizeof (glink_eh_frame_cie);
12725
12726 for (stub_sec = htab->params->stub_bfd->sections;
12727 stub_sec != NULL;
12728 stub_sec = stub_sec->next)
12729 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12730 {
12731 last_fde = p;
12732 last_fde_len = 20;
12733 /* FDE length. */
12734 bfd_put_32 (htab->elf.dynobj, 20, p);
12735 p += 4;
12736 /* CIE pointer. */
12737 val = p - htab->glink_eh_frame->contents;
12738 bfd_put_32 (htab->elf.dynobj, val, p);
12739 p += 4;
12740 /* Offset to stub section, written later. */
12741 p += 4;
12742 /* stub section size. */
12743 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12744 p += 4;
12745 /* Augmentation. */
12746 p += 1;
12747 /* Pad. */
12748 p += 7;
12749 }
12750 if (htab->glink != NULL && htab->glink->size != 0)
12751 {
12752 last_fde = p;
12753 last_fde_len = 20;
12754 /* FDE length. */
12755 bfd_put_32 (htab->elf.dynobj, 20, p);
12756 p += 4;
12757 /* CIE pointer. */
12758 val = p - htab->glink_eh_frame->contents;
12759 bfd_put_32 (htab->elf.dynobj, val, p);
12760 p += 4;
12761 /* Offset to .glink, written later. */
12762 p += 4;
12763 /* .glink size. */
12764 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12765 p += 4;
12766 /* Augmentation. */
12767 p += 1;
12768
12769 *p++ = DW_CFA_advance_loc + 1;
12770 *p++ = DW_CFA_register;
12771 *p++ = 65;
12772 *p++ = htab->opd_abi ? 12 : 0;
12773 *p++ = DW_CFA_advance_loc + 4;
12774 *p++ = DW_CFA_restore_extended;
12775 *p++ = 65;
12776 }
12777 /* Subsume any padding into the last FDE if user .eh_frame
12778 sections are aligned more than glink_eh_frame. Otherwise any
12779 zero padding will be seen as a terminator. */
12780 size = p - htab->glink_eh_frame->contents;
12781 align = 1;
12782 align <<= htab->glink_eh_frame->output_section->alignment_power;
12783 align -= 1;
12784 pad = ((size + align) & ~align) - size;
12785 htab->glink_eh_frame->size = size + pad;
12786 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12787 }
12788
12789 maybe_strip_output (info, htab->brlt);
12790 if (htab->glink_eh_frame != NULL)
12791 maybe_strip_output (info, htab->glink_eh_frame);
12792
12793 return TRUE;
12794 }
12795
12796 /* Called after we have determined section placement. If sections
12797 move, we'll be called again. Provide a value for TOCstart. */
12798
12799 bfd_vma
12800 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12801 {
12802 asection *s;
12803 bfd_vma TOCstart, adjust;
12804
12805 if (info != NULL)
12806 {
12807 struct elf_link_hash_entry *h;
12808 struct elf_link_hash_table *htab = elf_hash_table (info);
12809
12810 if (is_elf_hash_table (htab)
12811 && htab->hgot != NULL)
12812 h = htab->hgot;
12813 else
12814 {
12815 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12816 if (is_elf_hash_table (htab))
12817 htab->hgot = h;
12818 }
12819 if (h != NULL
12820 && h->root.type == bfd_link_hash_defined
12821 && !h->root.linker_def
12822 && (!is_elf_hash_table (htab)
12823 || h->def_regular))
12824 {
12825 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12826 + h->root.u.def.section->output_offset
12827 + h->root.u.def.section->output_section->vma);
12828 _bfd_set_gp_value (obfd, TOCstart);
12829 return TOCstart;
12830 }
12831 }
12832
12833 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12834 order. The TOC starts where the first of these sections starts. */
12835 s = bfd_get_section_by_name (obfd, ".got");
12836 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12837 s = bfd_get_section_by_name (obfd, ".toc");
12838 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12839 s = bfd_get_section_by_name (obfd, ".tocbss");
12840 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12841 s = bfd_get_section_by_name (obfd, ".plt");
12842 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12843 {
12844 /* This may happen for
12845 o references to TOC base (SYM@toc / TOC[tc0]) without a
12846 .toc directive
12847 o bad linker script
12848 o --gc-sections and empty TOC sections
12849
12850 FIXME: Warn user? */
12851
12852 /* Look for a likely section. We probably won't even be
12853 using TOCstart. */
12854 for (s = obfd->sections; s != NULL; s = s->next)
12855 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12856 | SEC_EXCLUDE))
12857 == (SEC_ALLOC | SEC_SMALL_DATA))
12858 break;
12859 if (s == NULL)
12860 for (s = obfd->sections; s != NULL; s = s->next)
12861 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12862 == (SEC_ALLOC | SEC_SMALL_DATA))
12863 break;
12864 if (s == NULL)
12865 for (s = obfd->sections; s != NULL; s = s->next)
12866 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12867 == SEC_ALLOC)
12868 break;
12869 if (s == NULL)
12870 for (s = obfd->sections; s != NULL; s = s->next)
12871 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12872 break;
12873 }
12874
12875 TOCstart = 0;
12876 if (s != NULL)
12877 TOCstart = s->output_section->vma + s->output_offset;
12878
12879 /* Force alignment. */
12880 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12881 TOCstart -= adjust;
12882 _bfd_set_gp_value (obfd, TOCstart);
12883
12884 if (info != NULL && s != NULL)
12885 {
12886 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12887
12888 if (htab != NULL)
12889 {
12890 if (htab->elf.hgot != NULL)
12891 {
12892 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12893 htab->elf.hgot->root.u.def.section = s;
12894 }
12895 }
12896 else
12897 {
12898 struct bfd_link_hash_entry *bh = NULL;
12899 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12900 s, TOC_BASE_OFF - adjust,
12901 NULL, FALSE, FALSE, &bh);
12902 }
12903 }
12904 return TOCstart;
12905 }
12906
12907 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12908 write out any global entry stubs. */
12909
12910 static bfd_boolean
12911 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12912 {
12913 struct bfd_link_info *info;
12914 struct ppc_link_hash_table *htab;
12915 struct plt_entry *pent;
12916 asection *s;
12917
12918 if (h->root.type == bfd_link_hash_indirect)
12919 return TRUE;
12920
12921 if (!h->pointer_equality_needed)
12922 return TRUE;
12923
12924 if (h->def_regular)
12925 return TRUE;
12926
12927 info = inf;
12928 htab = ppc_hash_table (info);
12929 if (htab == NULL)
12930 return FALSE;
12931
12932 s = htab->glink;
12933 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12934 if (pent->plt.offset != (bfd_vma) -1
12935 && pent->addend == 0)
12936 {
12937 bfd_byte *p;
12938 asection *plt;
12939 bfd_vma off;
12940
12941 p = s->contents + h->root.u.def.value;
12942 plt = htab->elf.splt;
12943 if (!htab->elf.dynamic_sections_created
12944 || h->dynindx == -1)
12945 plt = htab->elf.iplt;
12946 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12947 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12948
12949 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12950 {
12951 info->callbacks->einfo
12952 (_("%P: linkage table error against `%T'\n"),
12953 h->root.root.string);
12954 bfd_set_error (bfd_error_bad_value);
12955 htab->stub_error = TRUE;
12956 }
12957
12958 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12959 if (htab->params->emit_stub_syms)
12960 {
12961 size_t len = strlen (h->root.root.string);
12962 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12963
12964 if (name == NULL)
12965 return FALSE;
12966
12967 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12968 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12969 if (h == NULL)
12970 return FALSE;
12971 if (h->root.type == bfd_link_hash_new)
12972 {
12973 h->root.type = bfd_link_hash_defined;
12974 h->root.u.def.section = s;
12975 h->root.u.def.value = p - s->contents;
12976 h->ref_regular = 1;
12977 h->def_regular = 1;
12978 h->ref_regular_nonweak = 1;
12979 h->forced_local = 1;
12980 h->non_elf = 0;
12981 h->root.linker_def = 1;
12982 }
12983 }
12984
12985 if (PPC_HA (off) != 0)
12986 {
12987 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12988 p += 4;
12989 }
12990 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12991 p += 4;
12992 bfd_put_32 (s->owner, MTCTR_R12, p);
12993 p += 4;
12994 bfd_put_32 (s->owner, BCTR, p);
12995 break;
12996 }
12997 return TRUE;
12998 }
12999
13000 /* Build all the stubs associated with the current output file.
13001 The stubs are kept in a hash table attached to the main linker
13002 hash table. This function is called via gldelf64ppc_finish. */
13003
13004 bfd_boolean
13005 ppc64_elf_build_stubs (struct bfd_link_info *info,
13006 char **stats)
13007 {
13008 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13009 struct map_stub *group;
13010 asection *stub_sec;
13011 bfd_byte *p;
13012 int stub_sec_count = 0;
13013
13014 if (htab == NULL)
13015 return FALSE;
13016
13017 /* Allocate memory to hold the linker stubs. */
13018 for (stub_sec = htab->params->stub_bfd->sections;
13019 stub_sec != NULL;
13020 stub_sec = stub_sec->next)
13021 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13022 && stub_sec->size != 0)
13023 {
13024 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13025 if (stub_sec->contents == NULL)
13026 return FALSE;
13027 stub_sec->size = 0;
13028 }
13029
13030 if (htab->glink != NULL && htab->glink->size != 0)
13031 {
13032 unsigned int indx;
13033 bfd_vma plt0;
13034
13035 /* Build the .glink plt call stub. */
13036 if (htab->params->emit_stub_syms)
13037 {
13038 struct elf_link_hash_entry *h;
13039 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13040 TRUE, FALSE, FALSE);
13041 if (h == NULL)
13042 return FALSE;
13043 if (h->root.type == bfd_link_hash_new)
13044 {
13045 h->root.type = bfd_link_hash_defined;
13046 h->root.u.def.section = htab->glink;
13047 h->root.u.def.value = 8;
13048 h->ref_regular = 1;
13049 h->def_regular = 1;
13050 h->ref_regular_nonweak = 1;
13051 h->forced_local = 1;
13052 h->non_elf = 0;
13053 h->root.linker_def = 1;
13054 }
13055 }
13056 plt0 = (htab->elf.splt->output_section->vma
13057 + htab->elf.splt->output_offset
13058 - 16);
13059 if (info->emitrelocations)
13060 {
13061 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13062 if (r == NULL)
13063 return FALSE;
13064 r->r_offset = (htab->glink->output_offset
13065 + htab->glink->output_section->vma);
13066 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13067 r->r_addend = plt0;
13068 }
13069 p = htab->glink->contents;
13070 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13071 bfd_put_64 (htab->glink->owner, plt0, p);
13072 p += 8;
13073 if (htab->opd_abi)
13074 {
13075 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13076 p += 4;
13077 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13078 p += 4;
13079 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13080 p += 4;
13081 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13082 p += 4;
13083 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13084 p += 4;
13085 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13086 p += 4;
13087 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13088 p += 4;
13089 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13090 p += 4;
13091 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13092 p += 4;
13093 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13094 p += 4;
13095 }
13096 else
13097 {
13098 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13099 p += 4;
13100 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13101 p += 4;
13102 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13103 p += 4;
13104 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13105 p += 4;
13106 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13107 p += 4;
13108 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13109 p += 4;
13110 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13111 p += 4;
13112 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13113 p += 4;
13114 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13115 p += 4;
13116 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13117 p += 4;
13118 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13119 p += 4;
13120 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13121 p += 4;
13122 }
13123 bfd_put_32 (htab->glink->owner, BCTR, p);
13124 p += 4;
13125 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13126 {
13127 bfd_put_32 (htab->glink->owner, NOP, p);
13128 p += 4;
13129 }
13130
13131 /* Build the .glink lazy link call stubs. */
13132 indx = 0;
13133 while (p < htab->glink->contents + htab->glink->rawsize)
13134 {
13135 if (htab->opd_abi)
13136 {
13137 if (indx < 0x8000)
13138 {
13139 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13140 p += 4;
13141 }
13142 else
13143 {
13144 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13145 p += 4;
13146 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13147 p);
13148 p += 4;
13149 }
13150 }
13151 bfd_put_32 (htab->glink->owner,
13152 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13153 indx++;
13154 p += 4;
13155 }
13156
13157 /* Build .glink global entry stubs. */
13158 if (htab->glink->size > htab->glink->rawsize)
13159 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13160 }
13161
13162 if (htab->brlt != NULL && htab->brlt->size != 0)
13163 {
13164 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13165 htab->brlt->size);
13166 if (htab->brlt->contents == NULL)
13167 return FALSE;
13168 }
13169 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13170 {
13171 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13172 htab->relbrlt->size);
13173 if (htab->relbrlt->contents == NULL)
13174 return FALSE;
13175 }
13176
13177 /* Build the stubs as directed by the stub hash table. */
13178 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13179
13180 for (group = htab->group; group != NULL; group = group->next)
13181 if (group->needs_save_res)
13182 {
13183 stub_sec = group->stub_sec;
13184 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13185 htab->sfpr->size);
13186 if (htab->params->emit_stub_syms)
13187 {
13188 unsigned int i;
13189
13190 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13191 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13192 return FALSE;
13193 }
13194 stub_sec->size += htab->sfpr->size;
13195 }
13196
13197 if (htab->relbrlt != NULL)
13198 htab->relbrlt->reloc_count = 0;
13199
13200 if (htab->params->plt_stub_align != 0)
13201 for (stub_sec = htab->params->stub_bfd->sections;
13202 stub_sec != NULL;
13203 stub_sec = stub_sec->next)
13204 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13205 stub_sec->size = ((stub_sec->size
13206 + (1 << htab->params->plt_stub_align) - 1)
13207 & -(1 << htab->params->plt_stub_align));
13208
13209 for (stub_sec = htab->params->stub_bfd->sections;
13210 stub_sec != NULL;
13211 stub_sec = stub_sec->next)
13212 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13213 {
13214 stub_sec_count += 1;
13215 if (stub_sec->rawsize != stub_sec->size
13216 && (htab->stub_iteration <= STUB_SHRINK_ITER
13217 || stub_sec->rawsize < stub_sec->size))
13218 break;
13219 }
13220
13221 /* Note that the glink_eh_frame check here is not only testing that
13222 the generated size matched the calculated size but also that
13223 bfd_elf_discard_info didn't make any changes to the section. */
13224 if (stub_sec != NULL
13225 || (htab->glink_eh_frame != NULL
13226 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13227 {
13228 htab->stub_error = TRUE;
13229 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13230 }
13231
13232 if (htab->stub_error)
13233 return FALSE;
13234
13235 if (stats != NULL)
13236 {
13237 *stats = bfd_malloc (500);
13238 if (*stats == NULL)
13239 return FALSE;
13240
13241 sprintf (*stats, _("linker stubs in %u group%s\n"
13242 " branch %lu\n"
13243 " toc adjust %lu\n"
13244 " long branch %lu\n"
13245 " long toc adj %lu\n"
13246 " plt call %lu\n"
13247 " plt call toc %lu\n"
13248 " global entry %lu"),
13249 stub_sec_count,
13250 stub_sec_count == 1 ? "" : "s",
13251 htab->stub_count[ppc_stub_long_branch - 1],
13252 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13253 htab->stub_count[ppc_stub_plt_branch - 1],
13254 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13255 htab->stub_count[ppc_stub_plt_call - 1],
13256 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13257 htab->stub_count[ppc_stub_global_entry - 1]);
13258 }
13259 return TRUE;
13260 }
13261
13262 /* What to do when ld finds relocations against symbols defined in
13263 discarded sections. */
13264
13265 static unsigned int
13266 ppc64_elf_action_discarded (asection *sec)
13267 {
13268 if (strcmp (".opd", sec->name) == 0)
13269 return 0;
13270
13271 if (strcmp (".toc", sec->name) == 0)
13272 return 0;
13273
13274 if (strcmp (".toc1", sec->name) == 0)
13275 return 0;
13276
13277 return _bfd_elf_default_action_discarded (sec);
13278 }
13279
13280 /* The RELOCATE_SECTION function is called by the ELF backend linker
13281 to handle the relocations for a section.
13282
13283 The relocs are always passed as Rela structures; if the section
13284 actually uses Rel structures, the r_addend field will always be
13285 zero.
13286
13287 This function is responsible for adjust the section contents as
13288 necessary, and (if using Rela relocs and generating a
13289 relocatable output file) adjusting the reloc addend as
13290 necessary.
13291
13292 This function does not have to worry about setting the reloc
13293 address or the reloc symbol index.
13294
13295 LOCAL_SYMS is a pointer to the swapped in local symbols.
13296
13297 LOCAL_SECTIONS is an array giving the section in the input file
13298 corresponding to the st_shndx field of each local symbol.
13299
13300 The global hash table entry for the global symbols can be found
13301 via elf_sym_hashes (input_bfd).
13302
13303 When generating relocatable output, this function must handle
13304 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13305 going to be the section symbol corresponding to the output
13306 section, which means that the addend must be adjusted
13307 accordingly. */
13308
13309 static bfd_boolean
13310 ppc64_elf_relocate_section (bfd *output_bfd,
13311 struct bfd_link_info *info,
13312 bfd *input_bfd,
13313 asection *input_section,
13314 bfd_byte *contents,
13315 Elf_Internal_Rela *relocs,
13316 Elf_Internal_Sym *local_syms,
13317 asection **local_sections)
13318 {
13319 struct ppc_link_hash_table *htab;
13320 Elf_Internal_Shdr *symtab_hdr;
13321 struct elf_link_hash_entry **sym_hashes;
13322 Elf_Internal_Rela *rel;
13323 Elf_Internal_Rela *wrel;
13324 Elf_Internal_Rela *relend;
13325 Elf_Internal_Rela outrel;
13326 bfd_byte *loc;
13327 struct got_entry **local_got_ents;
13328 bfd_vma TOCstart;
13329 bfd_boolean ret = TRUE;
13330 bfd_boolean is_opd;
13331 /* Assume 'at' branch hints. */
13332 bfd_boolean is_isa_v2 = TRUE;
13333 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13334
13335 /* Initialize howto table if needed. */
13336 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13337 ppc_howto_init ();
13338
13339 htab = ppc_hash_table (info);
13340 if (htab == NULL)
13341 return FALSE;
13342
13343 /* Don't relocate stub sections. */
13344 if (input_section->owner == htab->params->stub_bfd)
13345 return TRUE;
13346
13347 BFD_ASSERT (is_ppc64_elf (input_bfd));
13348
13349 local_got_ents = elf_local_got_ents (input_bfd);
13350 TOCstart = elf_gp (output_bfd);
13351 symtab_hdr = &elf_symtab_hdr (input_bfd);
13352 sym_hashes = elf_sym_hashes (input_bfd);
13353 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13354
13355 rel = wrel = relocs;
13356 relend = relocs + input_section->reloc_count;
13357 for (; rel < relend; wrel++, rel++)
13358 {
13359 enum elf_ppc64_reloc_type r_type;
13360 bfd_vma addend;
13361 bfd_reloc_status_type r;
13362 Elf_Internal_Sym *sym;
13363 asection *sec;
13364 struct elf_link_hash_entry *h_elf;
13365 struct ppc_link_hash_entry *h;
13366 struct ppc_link_hash_entry *fdh;
13367 const char *sym_name;
13368 unsigned long r_symndx, toc_symndx;
13369 bfd_vma toc_addend;
13370 unsigned char tls_mask, tls_gd, tls_type;
13371 unsigned char sym_type;
13372 bfd_vma relocation;
13373 bfd_boolean unresolved_reloc;
13374 bfd_boolean warned;
13375 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13376 unsigned int insn;
13377 unsigned int mask;
13378 struct ppc_stub_hash_entry *stub_entry;
13379 bfd_vma max_br_offset;
13380 bfd_vma from;
13381 Elf_Internal_Rela orig_rel;
13382 reloc_howto_type *howto;
13383 struct reloc_howto_struct alt_howto;
13384
13385 again:
13386 orig_rel = *rel;
13387
13388 r_type = ELF64_R_TYPE (rel->r_info);
13389 r_symndx = ELF64_R_SYM (rel->r_info);
13390
13391 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13392 symbol of the previous ADDR64 reloc. The symbol gives us the
13393 proper TOC base to use. */
13394 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13395 && wrel != relocs
13396 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13397 && is_opd)
13398 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13399
13400 sym = NULL;
13401 sec = NULL;
13402 h_elf = NULL;
13403 sym_name = NULL;
13404 unresolved_reloc = FALSE;
13405 warned = FALSE;
13406
13407 if (r_symndx < symtab_hdr->sh_info)
13408 {
13409 /* It's a local symbol. */
13410 struct _opd_sec_data *opd;
13411
13412 sym = local_syms + r_symndx;
13413 sec = local_sections[r_symndx];
13414 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13415 sym_type = ELF64_ST_TYPE (sym->st_info);
13416 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13417 opd = get_opd_info (sec);
13418 if (opd != NULL && opd->adjust != NULL)
13419 {
13420 long adjust = opd->adjust[OPD_NDX (sym->st_value
13421 + rel->r_addend)];
13422 if (adjust == -1)
13423 relocation = 0;
13424 else
13425 {
13426 /* If this is a relocation against the opd section sym
13427 and we have edited .opd, adjust the reloc addend so
13428 that ld -r and ld --emit-relocs output is correct.
13429 If it is a reloc against some other .opd symbol,
13430 then the symbol value will be adjusted later. */
13431 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13432 rel->r_addend += adjust;
13433 else
13434 relocation += adjust;
13435 }
13436 }
13437 }
13438 else
13439 {
13440 bfd_boolean ignored;
13441
13442 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13443 r_symndx, symtab_hdr, sym_hashes,
13444 h_elf, sec, relocation,
13445 unresolved_reloc, warned, ignored);
13446 sym_name = h_elf->root.root.string;
13447 sym_type = h_elf->type;
13448 if (sec != NULL
13449 && sec->owner == output_bfd
13450 && strcmp (sec->name, ".opd") == 0)
13451 {
13452 /* This is a symbol defined in a linker script. All
13453 such are defined in output sections, even those
13454 defined by simple assignment from a symbol defined in
13455 an input section. Transfer the symbol to an
13456 appropriate input .opd section, so that a branch to
13457 this symbol will be mapped to the location specified
13458 by the opd entry. */
13459 struct bfd_link_order *lo;
13460 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13461 if (lo->type == bfd_indirect_link_order)
13462 {
13463 asection *isec = lo->u.indirect.section;
13464 if (h_elf->root.u.def.value >= isec->output_offset
13465 && h_elf->root.u.def.value < (isec->output_offset
13466 + isec->size))
13467 {
13468 h_elf->root.u.def.value -= isec->output_offset;
13469 h_elf->root.u.def.section = isec;
13470 sec = isec;
13471 break;
13472 }
13473 }
13474 }
13475 }
13476 h = (struct ppc_link_hash_entry *) h_elf;
13477
13478 if (sec != NULL && discarded_section (sec))
13479 {
13480 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13481 input_bfd, input_section,
13482 contents + rel->r_offset);
13483 wrel->r_offset = rel->r_offset;
13484 wrel->r_info = 0;
13485 wrel->r_addend = 0;
13486
13487 /* For ld -r, remove relocations in debug sections against
13488 sections defined in discarded sections. Not done for
13489 non-debug to preserve relocs in .eh_frame which the
13490 eh_frame editing code expects to be present. */
13491 if (bfd_link_relocatable (info)
13492 && (input_section->flags & SEC_DEBUGGING))
13493 wrel--;
13494
13495 continue;
13496 }
13497
13498 if (bfd_link_relocatable (info))
13499 goto copy_reloc;
13500
13501 if (h != NULL && &h->elf == htab->elf.hgot)
13502 {
13503 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13504 sec = bfd_abs_section_ptr;
13505 unresolved_reloc = FALSE;
13506 }
13507
13508 /* TLS optimizations. Replace instruction sequences and relocs
13509 based on information we collected in tls_optimize. We edit
13510 RELOCS so that --emit-relocs will output something sensible
13511 for the final instruction stream. */
13512 tls_mask = 0;
13513 tls_gd = 0;
13514 toc_symndx = 0;
13515 if (h != NULL)
13516 tls_mask = h->tls_mask;
13517 else if (local_got_ents != NULL)
13518 {
13519 struct plt_entry **local_plt = (struct plt_entry **)
13520 (local_got_ents + symtab_hdr->sh_info);
13521 unsigned char *lgot_masks = (unsigned char *)
13522 (local_plt + symtab_hdr->sh_info);
13523 tls_mask = lgot_masks[r_symndx];
13524 }
13525 if (tls_mask == 0
13526 && (r_type == R_PPC64_TLS
13527 || r_type == R_PPC64_TLSGD
13528 || r_type == R_PPC64_TLSLD))
13529 {
13530 /* Check for toc tls entries. */
13531 unsigned char *toc_tls;
13532
13533 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13534 &local_syms, rel, input_bfd))
13535 return FALSE;
13536
13537 if (toc_tls)
13538 tls_mask = *toc_tls;
13539 }
13540
13541 /* Check that tls relocs are used with tls syms, and non-tls
13542 relocs are used with non-tls syms. */
13543 if (r_symndx != STN_UNDEF
13544 && r_type != R_PPC64_NONE
13545 && (h == NULL
13546 || h->elf.root.type == bfd_link_hash_defined
13547 || h->elf.root.type == bfd_link_hash_defweak)
13548 && (IS_PPC64_TLS_RELOC (r_type)
13549 != (sym_type == STT_TLS
13550 || (sym_type == STT_SECTION
13551 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13552 {
13553 if (tls_mask != 0
13554 && (r_type == R_PPC64_TLS
13555 || r_type == R_PPC64_TLSGD
13556 || r_type == R_PPC64_TLSLD))
13557 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13558 ;
13559 else
13560 info->callbacks->einfo
13561 (!IS_PPC64_TLS_RELOC (r_type)
13562 /* xgettext:c-format */
13563 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13564 /* xgettext:c-format */
13565 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13566 input_bfd, input_section, rel->r_offset,
13567 ppc64_elf_howto_table[r_type]->name,
13568 sym_name);
13569 }
13570
13571 /* Ensure reloc mapping code below stays sane. */
13572 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13573 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13574 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13575 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13576 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13577 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13578 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13579 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13580 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13581 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13582 abort ();
13583
13584 switch (r_type)
13585 {
13586 default:
13587 break;
13588
13589 case R_PPC64_LO_DS_OPT:
13590 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13591 if ((insn & (0x3f << 26)) != 58u << 26)
13592 abort ();
13593 insn += (14u << 26) - (58u << 26);
13594 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13595 r_type = R_PPC64_TOC16_LO;
13596 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13597 break;
13598
13599 case R_PPC64_TOC16:
13600 case R_PPC64_TOC16_LO:
13601 case R_PPC64_TOC16_DS:
13602 case R_PPC64_TOC16_LO_DS:
13603 {
13604 /* Check for toc tls entries. */
13605 unsigned char *toc_tls;
13606 int retval;
13607
13608 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13609 &local_syms, rel, input_bfd);
13610 if (retval == 0)
13611 return FALSE;
13612
13613 if (toc_tls)
13614 {
13615 tls_mask = *toc_tls;
13616 if (r_type == R_PPC64_TOC16_DS
13617 || r_type == R_PPC64_TOC16_LO_DS)
13618 {
13619 if (tls_mask != 0
13620 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13621 goto toctprel;
13622 }
13623 else
13624 {
13625 /* If we found a GD reloc pair, then we might be
13626 doing a GD->IE transition. */
13627 if (retval == 2)
13628 {
13629 tls_gd = TLS_TPRELGD;
13630 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13631 goto tls_ldgd_opt;
13632 }
13633 else if (retval == 3)
13634 {
13635 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13636 goto tls_ldgd_opt;
13637 }
13638 }
13639 }
13640 }
13641 break;
13642
13643 case R_PPC64_GOT_TPREL16_HI:
13644 case R_PPC64_GOT_TPREL16_HA:
13645 if (tls_mask != 0
13646 && (tls_mask & TLS_TPREL) == 0)
13647 {
13648 rel->r_offset -= d_offset;
13649 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13650 r_type = R_PPC64_NONE;
13651 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13652 }
13653 break;
13654
13655 case R_PPC64_GOT_TPREL16_DS:
13656 case R_PPC64_GOT_TPREL16_LO_DS:
13657 if (tls_mask != 0
13658 && (tls_mask & TLS_TPREL) == 0)
13659 {
13660 toctprel:
13661 insn = bfd_get_32 (input_bfd,
13662 contents + rel->r_offset - d_offset);
13663 insn &= 31 << 21;
13664 insn |= 0x3c0d0000; /* addis 0,13,0 */
13665 bfd_put_32 (input_bfd, insn,
13666 contents + rel->r_offset - d_offset);
13667 r_type = R_PPC64_TPREL16_HA;
13668 if (toc_symndx != 0)
13669 {
13670 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13671 rel->r_addend = toc_addend;
13672 /* We changed the symbol. Start over in order to
13673 get h, sym, sec etc. right. */
13674 goto again;
13675 }
13676 else
13677 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13678 }
13679 break;
13680
13681 case R_PPC64_TLS:
13682 if (tls_mask != 0
13683 && (tls_mask & TLS_TPREL) == 0)
13684 {
13685 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13686 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13687 if (insn == 0)
13688 abort ();
13689 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13690 /* Was PPC64_TLS which sits on insn boundary, now
13691 PPC64_TPREL16_LO which is at low-order half-word. */
13692 rel->r_offset += d_offset;
13693 r_type = R_PPC64_TPREL16_LO;
13694 if (toc_symndx != 0)
13695 {
13696 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13697 rel->r_addend = toc_addend;
13698 /* We changed the symbol. Start over in order to
13699 get h, sym, sec etc. right. */
13700 goto again;
13701 }
13702 else
13703 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13704 }
13705 break;
13706
13707 case R_PPC64_GOT_TLSGD16_HI:
13708 case R_PPC64_GOT_TLSGD16_HA:
13709 tls_gd = TLS_TPRELGD;
13710 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13711 goto tls_gdld_hi;
13712 break;
13713
13714 case R_PPC64_GOT_TLSLD16_HI:
13715 case R_PPC64_GOT_TLSLD16_HA:
13716 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13717 {
13718 tls_gdld_hi:
13719 if ((tls_mask & tls_gd) != 0)
13720 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13721 + R_PPC64_GOT_TPREL16_DS);
13722 else
13723 {
13724 rel->r_offset -= d_offset;
13725 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13726 r_type = R_PPC64_NONE;
13727 }
13728 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13729 }
13730 break;
13731
13732 case R_PPC64_GOT_TLSGD16:
13733 case R_PPC64_GOT_TLSGD16_LO:
13734 tls_gd = TLS_TPRELGD;
13735 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13736 goto tls_ldgd_opt;
13737 break;
13738
13739 case R_PPC64_GOT_TLSLD16:
13740 case R_PPC64_GOT_TLSLD16_LO:
13741 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13742 {
13743 unsigned int insn1, insn2, insn3;
13744 bfd_vma offset;
13745
13746 tls_ldgd_opt:
13747 offset = (bfd_vma) -1;
13748 /* If not using the newer R_PPC64_TLSGD/LD to mark
13749 __tls_get_addr calls, we must trust that the call
13750 stays with its arg setup insns, ie. that the next
13751 reloc is the __tls_get_addr call associated with
13752 the current reloc. Edit both insns. */
13753 if (input_section->has_tls_get_addr_call
13754 && rel + 1 < relend
13755 && branch_reloc_hash_match (input_bfd, rel + 1,
13756 htab->tls_get_addr,
13757 htab->tls_get_addr_fd))
13758 offset = rel[1].r_offset;
13759 /* We read the low GOT_TLS (or TOC16) insn because we
13760 need to keep the destination reg. It may be
13761 something other than the usual r3, and moved to r3
13762 before the call by intervening code. */
13763 insn1 = bfd_get_32 (input_bfd,
13764 contents + rel->r_offset - d_offset);
13765 if ((tls_mask & tls_gd) != 0)
13766 {
13767 /* IE */
13768 insn1 &= (0x1f << 21) | (0x1f << 16);
13769 insn1 |= 58 << 26; /* ld */
13770 insn2 = 0x7c636a14; /* add 3,3,13 */
13771 if (offset != (bfd_vma) -1)
13772 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13773 if ((tls_mask & TLS_EXPLICIT) == 0)
13774 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13775 + R_PPC64_GOT_TPREL16_DS);
13776 else
13777 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13778 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13779 }
13780 else
13781 {
13782 /* LE */
13783 insn1 &= 0x1f << 21;
13784 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13785 insn2 = 0x38630000; /* addi 3,3,0 */
13786 if (tls_gd == 0)
13787 {
13788 /* Was an LD reloc. */
13789 if (toc_symndx)
13790 sec = local_sections[toc_symndx];
13791 for (r_symndx = 0;
13792 r_symndx < symtab_hdr->sh_info;
13793 r_symndx++)
13794 if (local_sections[r_symndx] == sec)
13795 break;
13796 if (r_symndx >= symtab_hdr->sh_info)
13797 r_symndx = STN_UNDEF;
13798 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13799 if (r_symndx != STN_UNDEF)
13800 rel->r_addend -= (local_syms[r_symndx].st_value
13801 + sec->output_offset
13802 + sec->output_section->vma);
13803 }
13804 else if (toc_symndx != 0)
13805 {
13806 r_symndx = toc_symndx;
13807 rel->r_addend = toc_addend;
13808 }
13809 r_type = R_PPC64_TPREL16_HA;
13810 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13811 if (offset != (bfd_vma) -1)
13812 {
13813 rel[1].r_info = ELF64_R_INFO (r_symndx,
13814 R_PPC64_TPREL16_LO);
13815 rel[1].r_offset = offset + d_offset;
13816 rel[1].r_addend = rel->r_addend;
13817 }
13818 }
13819 bfd_put_32 (input_bfd, insn1,
13820 contents + rel->r_offset - d_offset);
13821 if (offset != (bfd_vma) -1)
13822 {
13823 insn3 = bfd_get_32 (input_bfd,
13824 contents + offset + 4);
13825 if (insn3 == NOP
13826 || insn3 == CROR_151515 || insn3 == CROR_313131)
13827 {
13828 rel[1].r_offset += 4;
13829 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13830 insn2 = NOP;
13831 }
13832 bfd_put_32 (input_bfd, insn2, contents + offset);
13833 }
13834 if ((tls_mask & tls_gd) == 0
13835 && (tls_gd == 0 || toc_symndx != 0))
13836 {
13837 /* We changed the symbol. Start over in order
13838 to get h, sym, sec etc. right. */
13839 goto again;
13840 }
13841 }
13842 break;
13843
13844 case R_PPC64_TLSGD:
13845 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13846 {
13847 unsigned int insn2, insn3;
13848 bfd_vma offset = rel->r_offset;
13849
13850 if ((tls_mask & TLS_TPRELGD) != 0)
13851 {
13852 /* IE */
13853 r_type = R_PPC64_NONE;
13854 insn2 = 0x7c636a14; /* add 3,3,13 */
13855 }
13856 else
13857 {
13858 /* LE */
13859 if (toc_symndx != 0)
13860 {
13861 r_symndx = toc_symndx;
13862 rel->r_addend = toc_addend;
13863 }
13864 r_type = R_PPC64_TPREL16_LO;
13865 rel->r_offset = offset + d_offset;
13866 insn2 = 0x38630000; /* addi 3,3,0 */
13867 }
13868 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13869 /* Zap the reloc on the _tls_get_addr call too. */
13870 BFD_ASSERT (offset == rel[1].r_offset);
13871 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13872 insn3 = bfd_get_32 (input_bfd,
13873 contents + offset + 4);
13874 if (insn3 == NOP
13875 || insn3 == CROR_151515 || insn3 == CROR_313131)
13876 {
13877 rel->r_offset += 4;
13878 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13879 insn2 = NOP;
13880 }
13881 bfd_put_32 (input_bfd, insn2, contents + offset);
13882 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13883 goto again;
13884 }
13885 break;
13886
13887 case R_PPC64_TLSLD:
13888 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13889 {
13890 unsigned int insn2, insn3;
13891 bfd_vma offset = rel->r_offset;
13892
13893 if (toc_symndx)
13894 sec = local_sections[toc_symndx];
13895 for (r_symndx = 0;
13896 r_symndx < symtab_hdr->sh_info;
13897 r_symndx++)
13898 if (local_sections[r_symndx] == sec)
13899 break;
13900 if (r_symndx >= symtab_hdr->sh_info)
13901 r_symndx = STN_UNDEF;
13902 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13903 if (r_symndx != STN_UNDEF)
13904 rel->r_addend -= (local_syms[r_symndx].st_value
13905 + sec->output_offset
13906 + sec->output_section->vma);
13907
13908 r_type = R_PPC64_TPREL16_LO;
13909 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13910 rel->r_offset = offset + d_offset;
13911 /* Zap the reloc on the _tls_get_addr call too. */
13912 BFD_ASSERT (offset == rel[1].r_offset);
13913 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13914 insn2 = 0x38630000; /* addi 3,3,0 */
13915 insn3 = bfd_get_32 (input_bfd,
13916 contents + offset + 4);
13917 if (insn3 == NOP
13918 || insn3 == CROR_151515 || insn3 == CROR_313131)
13919 {
13920 rel->r_offset += 4;
13921 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13922 insn2 = NOP;
13923 }
13924 bfd_put_32 (input_bfd, insn2, contents + offset);
13925 goto again;
13926 }
13927 break;
13928
13929 case R_PPC64_DTPMOD64:
13930 if (rel + 1 < relend
13931 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13932 && rel[1].r_offset == rel->r_offset + 8)
13933 {
13934 if ((tls_mask & TLS_GD) == 0)
13935 {
13936 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13937 if ((tls_mask & TLS_TPRELGD) != 0)
13938 r_type = R_PPC64_TPREL64;
13939 else
13940 {
13941 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13942 r_type = R_PPC64_NONE;
13943 }
13944 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13945 }
13946 }
13947 else
13948 {
13949 if ((tls_mask & TLS_LD) == 0)
13950 {
13951 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13952 r_type = R_PPC64_NONE;
13953 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13954 }
13955 }
13956 break;
13957
13958 case R_PPC64_TPREL64:
13959 if ((tls_mask & TLS_TPREL) == 0)
13960 {
13961 r_type = R_PPC64_NONE;
13962 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13963 }
13964 break;
13965
13966 case R_PPC64_ENTRY:
13967 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13968 if (!bfd_link_pic (info)
13969 && !info->traditional_format
13970 && relocation + 0x80008000 <= 0xffffffff)
13971 {
13972 unsigned int insn1, insn2;
13973
13974 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13975 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13976 if ((insn1 & ~0xfffc) == LD_R2_0R12
13977 && insn2 == ADD_R2_R2_R12)
13978 {
13979 bfd_put_32 (input_bfd,
13980 LIS_R2 + PPC_HA (relocation),
13981 contents + rel->r_offset);
13982 bfd_put_32 (input_bfd,
13983 ADDI_R2_R2 + PPC_LO (relocation),
13984 contents + rel->r_offset + 4);
13985 }
13986 }
13987 else
13988 {
13989 relocation -= (rel->r_offset
13990 + input_section->output_offset
13991 + input_section->output_section->vma);
13992 if (relocation + 0x80008000 <= 0xffffffff)
13993 {
13994 unsigned int insn1, insn2;
13995
13996 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13997 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13998 if ((insn1 & ~0xfffc) == LD_R2_0R12
13999 && insn2 == ADD_R2_R2_R12)
14000 {
14001 bfd_put_32 (input_bfd,
14002 ADDIS_R2_R12 + PPC_HA (relocation),
14003 contents + rel->r_offset);
14004 bfd_put_32 (input_bfd,
14005 ADDI_R2_R2 + PPC_LO (relocation),
14006 contents + rel->r_offset + 4);
14007 }
14008 }
14009 }
14010 break;
14011
14012 case R_PPC64_REL16_HA:
14013 /* If we are generating a non-PIC executable, edit
14014 . 0: addis 2,12,.TOC.-0b@ha
14015 . addi 2,2,.TOC.-0b@l
14016 used by ELFv2 global entry points to set up r2, to
14017 . lis 2,.TOC.@ha
14018 . addi 2,2,.TOC.@l
14019 if .TOC. is in range. */
14020 if (!bfd_link_pic (info)
14021 && !info->traditional_format
14022 && !htab->opd_abi
14023 && rel->r_addend == d_offset
14024 && h != NULL && &h->elf == htab->elf.hgot
14025 && rel + 1 < relend
14026 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14027 && rel[1].r_offset == rel->r_offset + 4
14028 && rel[1].r_addend == rel->r_addend + 4
14029 && relocation + 0x80008000 <= 0xffffffff)
14030 {
14031 unsigned int insn1, insn2;
14032 bfd_vma offset = rel->r_offset - d_offset;
14033 insn1 = bfd_get_32 (input_bfd, contents + offset);
14034 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14035 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14036 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14037 {
14038 r_type = R_PPC64_ADDR16_HA;
14039 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14040 rel->r_addend -= d_offset;
14041 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14042 rel[1].r_addend -= d_offset + 4;
14043 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14044 }
14045 }
14046 break;
14047 }
14048
14049 /* Handle other relocations that tweak non-addend part of insn. */
14050 insn = 0;
14051 max_br_offset = 1 << 25;
14052 addend = rel->r_addend;
14053 reloc_dest = DEST_NORMAL;
14054 switch (r_type)
14055 {
14056 default:
14057 break;
14058
14059 case R_PPC64_TOCSAVE:
14060 if (relocation + addend == (rel->r_offset
14061 + input_section->output_offset
14062 + input_section->output_section->vma)
14063 && tocsave_find (htab, NO_INSERT,
14064 &local_syms, rel, input_bfd))
14065 {
14066 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14067 if (insn == NOP
14068 || insn == CROR_151515 || insn == CROR_313131)
14069 bfd_put_32 (input_bfd,
14070 STD_R2_0R1 + STK_TOC (htab),
14071 contents + rel->r_offset);
14072 }
14073 break;
14074
14075 /* Branch taken prediction relocations. */
14076 case R_PPC64_ADDR14_BRTAKEN:
14077 case R_PPC64_REL14_BRTAKEN:
14078 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14079 /* Fall through. */
14080
14081 /* Branch not taken prediction relocations. */
14082 case R_PPC64_ADDR14_BRNTAKEN:
14083 case R_PPC64_REL14_BRNTAKEN:
14084 insn |= bfd_get_32 (input_bfd,
14085 contents + rel->r_offset) & ~(0x01 << 21);
14086 /* Fall through. */
14087
14088 case R_PPC64_REL14:
14089 max_br_offset = 1 << 15;
14090 /* Fall through. */
14091
14092 case R_PPC64_REL24:
14093 /* Calls to functions with a different TOC, such as calls to
14094 shared objects, need to alter the TOC pointer. This is
14095 done using a linkage stub. A REL24 branching to these
14096 linkage stubs needs to be followed by a nop, as the nop
14097 will be replaced with an instruction to restore the TOC
14098 base pointer. */
14099 fdh = h;
14100 if (h != NULL
14101 && h->oh != NULL
14102 && h->oh->is_func_descriptor)
14103 fdh = ppc_follow_link (h->oh);
14104 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14105 htab);
14106 if (stub_entry != NULL
14107 && (stub_entry->stub_type == ppc_stub_plt_call
14108 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14109 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14110 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14111 {
14112 bfd_boolean can_plt_call = FALSE;
14113
14114 /* All of these stubs will modify r2, so there must be a
14115 branch and link followed by a nop. The nop is
14116 replaced by an insn to restore r2. */
14117 if (rel->r_offset + 8 <= input_section->size)
14118 {
14119 unsigned long br;
14120
14121 br = bfd_get_32 (input_bfd,
14122 contents + rel->r_offset);
14123 if ((br & 1) != 0)
14124 {
14125 unsigned long nop;
14126
14127 nop = bfd_get_32 (input_bfd,
14128 contents + rel->r_offset + 4);
14129 if (nop == NOP
14130 || nop == CROR_151515 || nop == CROR_313131)
14131 {
14132 if (h != NULL
14133 && (h == htab->tls_get_addr_fd
14134 || h == htab->tls_get_addr)
14135 && htab->params->tls_get_addr_opt)
14136 {
14137 /* Special stub used, leave nop alone. */
14138 }
14139 else
14140 bfd_put_32 (input_bfd,
14141 LD_R2_0R1 + STK_TOC (htab),
14142 contents + rel->r_offset + 4);
14143 can_plt_call = TRUE;
14144 }
14145 }
14146 }
14147
14148 if (!can_plt_call && h != NULL)
14149 {
14150 const char *name = h->elf.root.root.string;
14151
14152 if (*name == '.')
14153 ++name;
14154
14155 if (strncmp (name, "__libc_start_main", 17) == 0
14156 && (name[17] == 0 || name[17] == '@'))
14157 {
14158 /* Allow crt1 branch to go via a toc adjusting
14159 stub. Other calls that never return could do
14160 the same, if we could detect such. */
14161 can_plt_call = TRUE;
14162 }
14163 }
14164
14165 if (!can_plt_call)
14166 {
14167 /* g++ as of 20130507 emits self-calls without a
14168 following nop. This is arguably wrong since we
14169 have conflicting information. On the one hand a
14170 global symbol and on the other a local call
14171 sequence, but don't error for this special case.
14172 It isn't possible to cheaply verify we have
14173 exactly such a call. Allow all calls to the same
14174 section. */
14175 asection *code_sec = sec;
14176
14177 if (get_opd_info (sec) != NULL)
14178 {
14179 bfd_vma off = (relocation + addend
14180 - sec->output_section->vma
14181 - sec->output_offset);
14182
14183 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14184 }
14185 if (code_sec == input_section)
14186 can_plt_call = TRUE;
14187 }
14188
14189 if (!can_plt_call)
14190 {
14191 if (stub_entry->stub_type == ppc_stub_plt_call
14192 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14193 info->callbacks->einfo
14194 /* xgettext:c-format */
14195 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14196 "recompile with -fPIC\n"),
14197 input_bfd, input_section, rel->r_offset, sym_name);
14198 else
14199 info->callbacks->einfo
14200 /* xgettext:c-format */
14201 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14202 "(-mcmodel=small toc adjust stub)\n"),
14203 input_bfd, input_section, rel->r_offset, sym_name);
14204
14205 bfd_set_error (bfd_error_bad_value);
14206 ret = FALSE;
14207 }
14208
14209 if (can_plt_call
14210 && (stub_entry->stub_type == ppc_stub_plt_call
14211 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14212 unresolved_reloc = FALSE;
14213 }
14214
14215 if ((stub_entry == NULL
14216 || stub_entry->stub_type == ppc_stub_long_branch
14217 || stub_entry->stub_type == ppc_stub_plt_branch)
14218 && get_opd_info (sec) != NULL)
14219 {
14220 /* The branch destination is the value of the opd entry. */
14221 bfd_vma off = (relocation + addend
14222 - sec->output_section->vma
14223 - sec->output_offset);
14224 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14225 if (dest != (bfd_vma) -1)
14226 {
14227 relocation = dest;
14228 addend = 0;
14229 reloc_dest = DEST_OPD;
14230 }
14231 }
14232
14233 /* If the branch is out of reach we ought to have a long
14234 branch stub. */
14235 from = (rel->r_offset
14236 + input_section->output_offset
14237 + input_section->output_section->vma);
14238
14239 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14240 ? fdh->elf.other
14241 : sym->st_other);
14242
14243 if (stub_entry != NULL
14244 && (stub_entry->stub_type == ppc_stub_long_branch
14245 || stub_entry->stub_type == ppc_stub_plt_branch)
14246 && (r_type == R_PPC64_ADDR14_BRTAKEN
14247 || r_type == R_PPC64_ADDR14_BRNTAKEN
14248 || (relocation + addend - from + max_br_offset
14249 < 2 * max_br_offset)))
14250 /* Don't use the stub if this branch is in range. */
14251 stub_entry = NULL;
14252
14253 if (stub_entry != NULL)
14254 {
14255 /* Munge up the value and addend so that we call the stub
14256 rather than the procedure directly. */
14257 asection *stub_sec = stub_entry->group->stub_sec;
14258
14259 if (stub_entry->stub_type == ppc_stub_save_res)
14260 relocation += (stub_sec->output_offset
14261 + stub_sec->output_section->vma
14262 + stub_sec->size - htab->sfpr->size
14263 - htab->sfpr->output_offset
14264 - htab->sfpr->output_section->vma);
14265 else
14266 relocation = (stub_entry->stub_offset
14267 + stub_sec->output_offset
14268 + stub_sec->output_section->vma);
14269 addend = 0;
14270 reloc_dest = DEST_STUB;
14271
14272 if ((stub_entry->stub_type == ppc_stub_plt_call
14273 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14274 && (ALWAYS_EMIT_R2SAVE
14275 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14276 && rel + 1 < relend
14277 && rel[1].r_offset == rel->r_offset + 4
14278 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14279 relocation += 4;
14280 }
14281
14282 if (insn != 0)
14283 {
14284 if (is_isa_v2)
14285 {
14286 /* Set 'a' bit. This is 0b00010 in BO field for branch
14287 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14288 for branch on CTR insns (BO == 1a00t or 1a01t). */
14289 if ((insn & (0x14 << 21)) == (0x04 << 21))
14290 insn |= 0x02 << 21;
14291 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14292 insn |= 0x08 << 21;
14293 else
14294 break;
14295 }
14296 else
14297 {
14298 /* Invert 'y' bit if not the default. */
14299 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14300 insn ^= 0x01 << 21;
14301 }
14302
14303 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14304 }
14305
14306 /* NOP out calls to undefined weak functions.
14307 We can thus call a weak function without first
14308 checking whether the function is defined. */
14309 else if (h != NULL
14310 && h->elf.root.type == bfd_link_hash_undefweak
14311 && h->elf.dynindx == -1
14312 && r_type == R_PPC64_REL24
14313 && relocation == 0
14314 && addend == 0)
14315 {
14316 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14317 goto copy_reloc;
14318 }
14319 break;
14320 }
14321
14322 /* Set `addend'. */
14323 tls_type = 0;
14324 switch (r_type)
14325 {
14326 default:
14327 info->callbacks->einfo
14328 /* xgettext:c-format */
14329 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14330 input_bfd, (int) r_type, sym_name);
14331
14332 bfd_set_error (bfd_error_bad_value);
14333 ret = FALSE;
14334 goto copy_reloc;
14335
14336 case R_PPC64_NONE:
14337 case R_PPC64_TLS:
14338 case R_PPC64_TLSGD:
14339 case R_PPC64_TLSLD:
14340 case R_PPC64_TOCSAVE:
14341 case R_PPC64_GNU_VTINHERIT:
14342 case R_PPC64_GNU_VTENTRY:
14343 case R_PPC64_ENTRY:
14344 goto copy_reloc;
14345
14346 /* GOT16 relocations. Like an ADDR16 using the symbol's
14347 address in the GOT as relocation value instead of the
14348 symbol's value itself. Also, create a GOT entry for the
14349 symbol and put the symbol value there. */
14350 case R_PPC64_GOT_TLSGD16:
14351 case R_PPC64_GOT_TLSGD16_LO:
14352 case R_PPC64_GOT_TLSGD16_HI:
14353 case R_PPC64_GOT_TLSGD16_HA:
14354 tls_type = TLS_TLS | TLS_GD;
14355 goto dogot;
14356
14357 case R_PPC64_GOT_TLSLD16:
14358 case R_PPC64_GOT_TLSLD16_LO:
14359 case R_PPC64_GOT_TLSLD16_HI:
14360 case R_PPC64_GOT_TLSLD16_HA:
14361 tls_type = TLS_TLS | TLS_LD;
14362 goto dogot;
14363
14364 case R_PPC64_GOT_TPREL16_DS:
14365 case R_PPC64_GOT_TPREL16_LO_DS:
14366 case R_PPC64_GOT_TPREL16_HI:
14367 case R_PPC64_GOT_TPREL16_HA:
14368 tls_type = TLS_TLS | TLS_TPREL;
14369 goto dogot;
14370
14371 case R_PPC64_GOT_DTPREL16_DS:
14372 case R_PPC64_GOT_DTPREL16_LO_DS:
14373 case R_PPC64_GOT_DTPREL16_HI:
14374 case R_PPC64_GOT_DTPREL16_HA:
14375 tls_type = TLS_TLS | TLS_DTPREL;
14376 goto dogot;
14377
14378 case R_PPC64_GOT16:
14379 case R_PPC64_GOT16_LO:
14380 case R_PPC64_GOT16_HI:
14381 case R_PPC64_GOT16_HA:
14382 case R_PPC64_GOT16_DS:
14383 case R_PPC64_GOT16_LO_DS:
14384 dogot:
14385 {
14386 /* Relocation is to the entry for this symbol in the global
14387 offset table. */
14388 asection *got;
14389 bfd_vma *offp;
14390 bfd_vma off;
14391 unsigned long indx = 0;
14392 struct got_entry *ent;
14393
14394 if (tls_type == (TLS_TLS | TLS_LD)
14395 && (h == NULL
14396 || !h->elf.def_dynamic))
14397 ent = ppc64_tlsld_got (input_bfd);
14398 else
14399 {
14400
14401 if (h != NULL)
14402 {
14403 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14404 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14405 &h->elf)
14406 || (bfd_link_pic (info)
14407 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14408 /* This is actually a static link, or it is a
14409 -Bsymbolic link and the symbol is defined
14410 locally, or the symbol was forced to be local
14411 because of a version file. */
14412 ;
14413 else
14414 {
14415 BFD_ASSERT (h->elf.dynindx != -1);
14416 indx = h->elf.dynindx;
14417 unresolved_reloc = FALSE;
14418 }
14419 ent = h->elf.got.glist;
14420 }
14421 else
14422 {
14423 if (local_got_ents == NULL)
14424 abort ();
14425 ent = local_got_ents[r_symndx];
14426 }
14427
14428 for (; ent != NULL; ent = ent->next)
14429 if (ent->addend == orig_rel.r_addend
14430 && ent->owner == input_bfd
14431 && ent->tls_type == tls_type)
14432 break;
14433 }
14434
14435 if (ent == NULL)
14436 abort ();
14437 if (ent->is_indirect)
14438 ent = ent->got.ent;
14439 offp = &ent->got.offset;
14440 got = ppc64_elf_tdata (ent->owner)->got;
14441 if (got == NULL)
14442 abort ();
14443
14444 /* The offset must always be a multiple of 8. We use the
14445 least significant bit to record whether we have already
14446 processed this entry. */
14447 off = *offp;
14448 if ((off & 1) != 0)
14449 off &= ~1;
14450 else
14451 {
14452 /* Generate relocs for the dynamic linker, except in
14453 the case of TLSLD where we'll use one entry per
14454 module. */
14455 asection *relgot;
14456 bfd_boolean ifunc;
14457
14458 *offp = off | 1;
14459 relgot = NULL;
14460 ifunc = (h != NULL
14461 ? h->elf.type == STT_GNU_IFUNC
14462 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14463 if (ifunc)
14464 relgot = htab->elf.irelplt;
14465 else if ((bfd_link_pic (info) || indx != 0)
14466 && (h == NULL
14467 || (tls_type == (TLS_TLS | TLS_LD)
14468 && !h->elf.def_dynamic)
14469 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14470 || h->elf.root.type != bfd_link_hash_undefweak))
14471 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14472 if (relgot != NULL)
14473 {
14474 outrel.r_offset = (got->output_section->vma
14475 + got->output_offset
14476 + off);
14477 outrel.r_addend = addend;
14478 if (tls_type & (TLS_LD | TLS_GD))
14479 {
14480 outrel.r_addend = 0;
14481 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14482 if (tls_type == (TLS_TLS | TLS_GD))
14483 {
14484 loc = relgot->contents;
14485 loc += (relgot->reloc_count++
14486 * sizeof (Elf64_External_Rela));
14487 bfd_elf64_swap_reloca_out (output_bfd,
14488 &outrel, loc);
14489 outrel.r_offset += 8;
14490 outrel.r_addend = addend;
14491 outrel.r_info
14492 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14493 }
14494 }
14495 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14496 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14497 else if (tls_type == (TLS_TLS | TLS_TPREL))
14498 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14499 else if (indx != 0)
14500 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14501 else
14502 {
14503 if (ifunc)
14504 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14505 else
14506 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14507
14508 /* Write the .got section contents for the sake
14509 of prelink. */
14510 loc = got->contents + off;
14511 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14512 loc);
14513 }
14514
14515 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14516 {
14517 outrel.r_addend += relocation;
14518 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14519 {
14520 if (htab->elf.tls_sec == NULL)
14521 outrel.r_addend = 0;
14522 else
14523 outrel.r_addend -= htab->elf.tls_sec->vma;
14524 }
14525 }
14526 loc = relgot->contents;
14527 loc += (relgot->reloc_count++
14528 * sizeof (Elf64_External_Rela));
14529 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14530 }
14531
14532 /* Init the .got section contents here if we're not
14533 emitting a reloc. */
14534 else
14535 {
14536 relocation += addend;
14537 if (tls_type == (TLS_TLS | TLS_LD))
14538 relocation = 1;
14539 else if (tls_type != 0)
14540 {
14541 if (htab->elf.tls_sec == NULL)
14542 relocation = 0;
14543 else
14544 {
14545 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14546 if (tls_type == (TLS_TLS | TLS_TPREL))
14547 relocation += DTP_OFFSET - TP_OFFSET;
14548 }
14549
14550 if (tls_type == (TLS_TLS | TLS_GD))
14551 {
14552 bfd_put_64 (output_bfd, relocation,
14553 got->contents + off + 8);
14554 relocation = 1;
14555 }
14556 }
14557
14558 bfd_put_64 (output_bfd, relocation,
14559 got->contents + off);
14560 }
14561 }
14562
14563 if (off >= (bfd_vma) -2)
14564 abort ();
14565
14566 relocation = got->output_section->vma + got->output_offset + off;
14567 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14568 }
14569 break;
14570
14571 case R_PPC64_PLT16_HA:
14572 case R_PPC64_PLT16_HI:
14573 case R_PPC64_PLT16_LO:
14574 case R_PPC64_PLT32:
14575 case R_PPC64_PLT64:
14576 /* Relocation is to the entry for this symbol in the
14577 procedure linkage table. */
14578 {
14579 struct plt_entry **plt_list = NULL;
14580 if (h != NULL)
14581 plt_list = &h->elf.plt.plist;
14582 else if (local_got_ents != NULL)
14583 {
14584 struct plt_entry **local_plt = (struct plt_entry **)
14585 (local_got_ents + symtab_hdr->sh_info);
14586 unsigned char *local_got_tls_masks = (unsigned char *)
14587 (local_plt + symtab_hdr->sh_info);
14588 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14589 plt_list = local_plt + r_symndx;
14590 }
14591 if (plt_list)
14592 {
14593 struct plt_entry *ent;
14594
14595 for (ent = *plt_list; ent != NULL; ent = ent->next)
14596 if (ent->plt.offset != (bfd_vma) -1
14597 && ent->addend == orig_rel.r_addend)
14598 {
14599 asection *plt;
14600
14601 plt = htab->elf.splt;
14602 if (!htab->elf.dynamic_sections_created
14603 || h == NULL
14604 || h->elf.dynindx == -1)
14605 plt = htab->elf.iplt;
14606 relocation = (plt->output_section->vma
14607 + plt->output_offset
14608 + ent->plt.offset);
14609 addend = 0;
14610 unresolved_reloc = FALSE;
14611 break;
14612 }
14613 }
14614 }
14615 break;
14616
14617 case R_PPC64_TOC:
14618 /* Relocation value is TOC base. */
14619 relocation = TOCstart;
14620 if (r_symndx == STN_UNDEF)
14621 relocation += htab->sec_info[input_section->id].toc_off;
14622 else if (unresolved_reloc)
14623 ;
14624 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14625 relocation += htab->sec_info[sec->id].toc_off;
14626 else
14627 unresolved_reloc = TRUE;
14628 goto dodyn;
14629
14630 /* TOC16 relocs. We want the offset relative to the TOC base,
14631 which is the address of the start of the TOC plus 0x8000.
14632 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14633 in this order. */
14634 case R_PPC64_TOC16:
14635 case R_PPC64_TOC16_LO:
14636 case R_PPC64_TOC16_HI:
14637 case R_PPC64_TOC16_DS:
14638 case R_PPC64_TOC16_LO_DS:
14639 case R_PPC64_TOC16_HA:
14640 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14641 break;
14642
14643 /* Relocate against the beginning of the section. */
14644 case R_PPC64_SECTOFF:
14645 case R_PPC64_SECTOFF_LO:
14646 case R_PPC64_SECTOFF_HI:
14647 case R_PPC64_SECTOFF_DS:
14648 case R_PPC64_SECTOFF_LO_DS:
14649 case R_PPC64_SECTOFF_HA:
14650 if (sec != NULL)
14651 addend -= sec->output_section->vma;
14652 break;
14653
14654 case R_PPC64_REL16:
14655 case R_PPC64_REL16_LO:
14656 case R_PPC64_REL16_HI:
14657 case R_PPC64_REL16_HA:
14658 case R_PPC64_REL16DX_HA:
14659 break;
14660
14661 case R_PPC64_REL14:
14662 case R_PPC64_REL14_BRNTAKEN:
14663 case R_PPC64_REL14_BRTAKEN:
14664 case R_PPC64_REL24:
14665 break;
14666
14667 case R_PPC64_TPREL16:
14668 case R_PPC64_TPREL16_LO:
14669 case R_PPC64_TPREL16_HI:
14670 case R_PPC64_TPREL16_HA:
14671 case R_PPC64_TPREL16_DS:
14672 case R_PPC64_TPREL16_LO_DS:
14673 case R_PPC64_TPREL16_HIGH:
14674 case R_PPC64_TPREL16_HIGHA:
14675 case R_PPC64_TPREL16_HIGHER:
14676 case R_PPC64_TPREL16_HIGHERA:
14677 case R_PPC64_TPREL16_HIGHEST:
14678 case R_PPC64_TPREL16_HIGHESTA:
14679 if (h != NULL
14680 && h->elf.root.type == bfd_link_hash_undefweak
14681 && h->elf.dynindx == -1)
14682 {
14683 /* Make this relocation against an undefined weak symbol
14684 resolve to zero. This is really just a tweak, since
14685 code using weak externs ought to check that they are
14686 defined before using them. */
14687 bfd_byte *p = contents + rel->r_offset - d_offset;
14688
14689 insn = bfd_get_32 (input_bfd, p);
14690 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14691 if (insn != 0)
14692 bfd_put_32 (input_bfd, insn, p);
14693 break;
14694 }
14695 if (htab->elf.tls_sec != NULL)
14696 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14697 if (bfd_link_pic (info))
14698 /* The TPREL16 relocs shouldn't really be used in shared
14699 libs as they will result in DT_TEXTREL being set, but
14700 support them anyway. */
14701 goto dodyn;
14702 break;
14703
14704 case R_PPC64_DTPREL16:
14705 case R_PPC64_DTPREL16_LO:
14706 case R_PPC64_DTPREL16_HI:
14707 case R_PPC64_DTPREL16_HA:
14708 case R_PPC64_DTPREL16_DS:
14709 case R_PPC64_DTPREL16_LO_DS:
14710 case R_PPC64_DTPREL16_HIGH:
14711 case R_PPC64_DTPREL16_HIGHA:
14712 case R_PPC64_DTPREL16_HIGHER:
14713 case R_PPC64_DTPREL16_HIGHERA:
14714 case R_PPC64_DTPREL16_HIGHEST:
14715 case R_PPC64_DTPREL16_HIGHESTA:
14716 if (htab->elf.tls_sec != NULL)
14717 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14718 break;
14719
14720 case R_PPC64_ADDR64_LOCAL:
14721 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14722 ? h->elf.other
14723 : sym->st_other);
14724 break;
14725
14726 case R_PPC64_DTPMOD64:
14727 relocation = 1;
14728 addend = 0;
14729 goto dodyn;
14730
14731 case R_PPC64_TPREL64:
14732 if (htab->elf.tls_sec != NULL)
14733 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14734 goto dodyn;
14735
14736 case R_PPC64_DTPREL64:
14737 if (htab->elf.tls_sec != NULL)
14738 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14739 /* Fall through. */
14740
14741 /* Relocations that may need to be propagated if this is a
14742 dynamic object. */
14743 case R_PPC64_REL30:
14744 case R_PPC64_REL32:
14745 case R_PPC64_REL64:
14746 case R_PPC64_ADDR14:
14747 case R_PPC64_ADDR14_BRNTAKEN:
14748 case R_PPC64_ADDR14_BRTAKEN:
14749 case R_PPC64_ADDR16:
14750 case R_PPC64_ADDR16_DS:
14751 case R_PPC64_ADDR16_HA:
14752 case R_PPC64_ADDR16_HI:
14753 case R_PPC64_ADDR16_HIGH:
14754 case R_PPC64_ADDR16_HIGHA:
14755 case R_PPC64_ADDR16_HIGHER:
14756 case R_PPC64_ADDR16_HIGHERA:
14757 case R_PPC64_ADDR16_HIGHEST:
14758 case R_PPC64_ADDR16_HIGHESTA:
14759 case R_PPC64_ADDR16_LO:
14760 case R_PPC64_ADDR16_LO_DS:
14761 case R_PPC64_ADDR24:
14762 case R_PPC64_ADDR32:
14763 case R_PPC64_ADDR64:
14764 case R_PPC64_UADDR16:
14765 case R_PPC64_UADDR32:
14766 case R_PPC64_UADDR64:
14767 dodyn:
14768 if ((input_section->flags & SEC_ALLOC) == 0)
14769 break;
14770
14771 if (NO_OPD_RELOCS && is_opd)
14772 break;
14773
14774 if (bfd_link_pic (info)
14775 ? ((h != NULL && pc_dynrelocs (h))
14776 || must_be_dyn_reloc (info, r_type))
14777 : (h != NULL
14778 ? h->dyn_relocs != NULL
14779 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14780 {
14781 bfd_boolean skip, relocate;
14782 asection *sreloc;
14783 bfd_vma out_off;
14784
14785 /* When generating a dynamic object, these relocations
14786 are copied into the output file to be resolved at run
14787 time. */
14788
14789 skip = FALSE;
14790 relocate = FALSE;
14791
14792 out_off = _bfd_elf_section_offset (output_bfd, info,
14793 input_section, rel->r_offset);
14794 if (out_off == (bfd_vma) -1)
14795 skip = TRUE;
14796 else if (out_off == (bfd_vma) -2)
14797 skip = TRUE, relocate = TRUE;
14798 out_off += (input_section->output_section->vma
14799 + input_section->output_offset);
14800 outrel.r_offset = out_off;
14801 outrel.r_addend = rel->r_addend;
14802
14803 /* Optimize unaligned reloc use. */
14804 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14805 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14806 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14807 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14808 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14809 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14810 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14811 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14812 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14813
14814 if (skip)
14815 memset (&outrel, 0, sizeof outrel);
14816 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14817 && !is_opd
14818 && r_type != R_PPC64_TOC)
14819 {
14820 BFD_ASSERT (h->elf.dynindx != -1);
14821 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14822 }
14823 else
14824 {
14825 /* This symbol is local, or marked to become local,
14826 or this is an opd section reloc which must point
14827 at a local function. */
14828 outrel.r_addend += relocation;
14829 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14830 {
14831 if (is_opd && h != NULL)
14832 {
14833 /* Lie about opd entries. This case occurs
14834 when building shared libraries and we
14835 reference a function in another shared
14836 lib. The same thing happens for a weak
14837 definition in an application that's
14838 overridden by a strong definition in a
14839 shared lib. (I believe this is a generic
14840 bug in binutils handling of weak syms.)
14841 In these cases we won't use the opd
14842 entry in this lib. */
14843 unresolved_reloc = FALSE;
14844 }
14845 if (!is_opd
14846 && r_type == R_PPC64_ADDR64
14847 && (h != NULL
14848 ? h->elf.type == STT_GNU_IFUNC
14849 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14850 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14851 else
14852 {
14853 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14854
14855 /* We need to relocate .opd contents for ld.so.
14856 Prelink also wants simple and consistent rules
14857 for relocs. This make all RELATIVE relocs have
14858 *r_offset equal to r_addend. */
14859 relocate = TRUE;
14860 }
14861 }
14862 else
14863 {
14864 long indx = 0;
14865
14866 if (h != NULL
14867 ? h->elf.type == STT_GNU_IFUNC
14868 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14869 {
14870 info->callbacks->einfo
14871 /* xgettext:c-format */
14872 (_("%P: %H: %s for indirect "
14873 "function `%T' unsupported\n"),
14874 input_bfd, input_section, rel->r_offset,
14875 ppc64_elf_howto_table[r_type]->name,
14876 sym_name);
14877 ret = FALSE;
14878 }
14879 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14880 ;
14881 else if (sec == NULL || sec->owner == NULL)
14882 {
14883 bfd_set_error (bfd_error_bad_value);
14884 return FALSE;
14885 }
14886 else
14887 {
14888 asection *osec;
14889
14890 osec = sec->output_section;
14891 indx = elf_section_data (osec)->dynindx;
14892
14893 if (indx == 0)
14894 {
14895 if ((osec->flags & SEC_READONLY) == 0
14896 && htab->elf.data_index_section != NULL)
14897 osec = htab->elf.data_index_section;
14898 else
14899 osec = htab->elf.text_index_section;
14900 indx = elf_section_data (osec)->dynindx;
14901 }
14902 BFD_ASSERT (indx != 0);
14903
14904 /* We are turning this relocation into one
14905 against a section symbol, so subtract out
14906 the output section's address but not the
14907 offset of the input section in the output
14908 section. */
14909 outrel.r_addend -= osec->vma;
14910 }
14911
14912 outrel.r_info = ELF64_R_INFO (indx, r_type);
14913 }
14914 }
14915
14916 sreloc = elf_section_data (input_section)->sreloc;
14917 if (h != NULL
14918 ? h->elf.type == STT_GNU_IFUNC
14919 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14920 sreloc = htab->elf.irelplt;
14921 if (sreloc == NULL)
14922 abort ();
14923
14924 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14925 >= sreloc->size)
14926 abort ();
14927 loc = sreloc->contents;
14928 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14929 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14930
14931 /* If this reloc is against an external symbol, it will
14932 be computed at runtime, so there's no need to do
14933 anything now. However, for the sake of prelink ensure
14934 that the section contents are a known value. */
14935 if (! relocate)
14936 {
14937 unresolved_reloc = FALSE;
14938 /* The value chosen here is quite arbitrary as ld.so
14939 ignores section contents except for the special
14940 case of .opd where the contents might be accessed
14941 before relocation. Choose zero, as that won't
14942 cause reloc overflow. */
14943 relocation = 0;
14944 addend = 0;
14945 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14946 to improve backward compatibility with older
14947 versions of ld. */
14948 if (r_type == R_PPC64_ADDR64)
14949 addend = outrel.r_addend;
14950 /* Adjust pc_relative relocs to have zero in *r_offset. */
14951 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14952 addend = (input_section->output_section->vma
14953 + input_section->output_offset
14954 + rel->r_offset);
14955 }
14956 }
14957 break;
14958
14959 case R_PPC64_COPY:
14960 case R_PPC64_GLOB_DAT:
14961 case R_PPC64_JMP_SLOT:
14962 case R_PPC64_JMP_IREL:
14963 case R_PPC64_RELATIVE:
14964 /* We shouldn't ever see these dynamic relocs in relocatable
14965 files. */
14966 /* Fall through. */
14967
14968 case R_PPC64_PLTGOT16:
14969 case R_PPC64_PLTGOT16_DS:
14970 case R_PPC64_PLTGOT16_HA:
14971 case R_PPC64_PLTGOT16_HI:
14972 case R_PPC64_PLTGOT16_LO:
14973 case R_PPC64_PLTGOT16_LO_DS:
14974 case R_PPC64_PLTREL32:
14975 case R_PPC64_PLTREL64:
14976 /* These ones haven't been implemented yet. */
14977
14978 info->callbacks->einfo
14979 /* xgettext:c-format */
14980 (_("%P: %B: %s is not supported for `%T'\n"),
14981 input_bfd,
14982 ppc64_elf_howto_table[r_type]->name, sym_name);
14983
14984 bfd_set_error (bfd_error_invalid_operation);
14985 ret = FALSE;
14986 goto copy_reloc;
14987 }
14988
14989 /* Multi-instruction sequences that access the TOC can be
14990 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14991 to nop; addi rb,r2,x; */
14992 switch (r_type)
14993 {
14994 default:
14995 break;
14996
14997 case R_PPC64_GOT_TLSLD16_HI:
14998 case R_PPC64_GOT_TLSGD16_HI:
14999 case R_PPC64_GOT_TPREL16_HI:
15000 case R_PPC64_GOT_DTPREL16_HI:
15001 case R_PPC64_GOT16_HI:
15002 case R_PPC64_TOC16_HI:
15003 /* These relocs would only be useful if building up an
15004 offset to later add to r2, perhaps in an indexed
15005 addressing mode instruction. Don't try to optimize.
15006 Unfortunately, the possibility of someone building up an
15007 offset like this or even with the HA relocs, means that
15008 we need to check the high insn when optimizing the low
15009 insn. */
15010 break;
15011
15012 case R_PPC64_GOT_TLSLD16_HA:
15013 case R_PPC64_GOT_TLSGD16_HA:
15014 case R_PPC64_GOT_TPREL16_HA:
15015 case R_PPC64_GOT_DTPREL16_HA:
15016 case R_PPC64_GOT16_HA:
15017 case R_PPC64_TOC16_HA:
15018 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15019 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15020 {
15021 bfd_byte *p = contents + (rel->r_offset & ~3);
15022 bfd_put_32 (input_bfd, NOP, p);
15023 }
15024 break;
15025
15026 case R_PPC64_GOT_TLSLD16_LO:
15027 case R_PPC64_GOT_TLSGD16_LO:
15028 case R_PPC64_GOT_TPREL16_LO_DS:
15029 case R_PPC64_GOT_DTPREL16_LO_DS:
15030 case R_PPC64_GOT16_LO:
15031 case R_PPC64_GOT16_LO_DS:
15032 case R_PPC64_TOC16_LO:
15033 case R_PPC64_TOC16_LO_DS:
15034 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15035 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15036 {
15037 bfd_byte *p = contents + (rel->r_offset & ~3);
15038 insn = bfd_get_32 (input_bfd, p);
15039 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15040 {
15041 /* Transform addic to addi when we change reg. */
15042 insn &= ~((0x3f << 26) | (0x1f << 16));
15043 insn |= (14u << 26) | (2 << 16);
15044 }
15045 else
15046 {
15047 insn &= ~(0x1f << 16);
15048 insn |= 2 << 16;
15049 }
15050 bfd_put_32 (input_bfd, insn, p);
15051 }
15052 break;
15053 }
15054
15055 /* Do any further special processing. */
15056 howto = ppc64_elf_howto_table[(int) r_type];
15057 switch (r_type)
15058 {
15059 default:
15060 break;
15061
15062 case R_PPC64_REL16_HA:
15063 case R_PPC64_REL16DX_HA:
15064 case R_PPC64_ADDR16_HA:
15065 case R_PPC64_ADDR16_HIGHA:
15066 case R_PPC64_ADDR16_HIGHERA:
15067 case R_PPC64_ADDR16_HIGHESTA:
15068 case R_PPC64_TOC16_HA:
15069 case R_PPC64_SECTOFF_HA:
15070 case R_PPC64_TPREL16_HA:
15071 case R_PPC64_TPREL16_HIGHA:
15072 case R_PPC64_TPREL16_HIGHERA:
15073 case R_PPC64_TPREL16_HIGHESTA:
15074 case R_PPC64_DTPREL16_HA:
15075 case R_PPC64_DTPREL16_HIGHA:
15076 case R_PPC64_DTPREL16_HIGHERA:
15077 case R_PPC64_DTPREL16_HIGHESTA:
15078 /* It's just possible that this symbol is a weak symbol
15079 that's not actually defined anywhere. In that case,
15080 'sec' would be NULL, and we should leave the symbol
15081 alone (it will be set to zero elsewhere in the link). */
15082 if (sec == NULL)
15083 break;
15084 /* Fall through. */
15085
15086 case R_PPC64_GOT16_HA:
15087 case R_PPC64_PLTGOT16_HA:
15088 case R_PPC64_PLT16_HA:
15089 case R_PPC64_GOT_TLSGD16_HA:
15090 case R_PPC64_GOT_TLSLD16_HA:
15091 case R_PPC64_GOT_TPREL16_HA:
15092 case R_PPC64_GOT_DTPREL16_HA:
15093 /* Add 0x10000 if sign bit in 0:15 is set.
15094 Bits 0:15 are not used. */
15095 addend += 0x8000;
15096 break;
15097
15098 case R_PPC64_ADDR16_DS:
15099 case R_PPC64_ADDR16_LO_DS:
15100 case R_PPC64_GOT16_DS:
15101 case R_PPC64_GOT16_LO_DS:
15102 case R_PPC64_PLT16_LO_DS:
15103 case R_PPC64_SECTOFF_DS:
15104 case R_PPC64_SECTOFF_LO_DS:
15105 case R_PPC64_TOC16_DS:
15106 case R_PPC64_TOC16_LO_DS:
15107 case R_PPC64_PLTGOT16_DS:
15108 case R_PPC64_PLTGOT16_LO_DS:
15109 case R_PPC64_GOT_TPREL16_DS:
15110 case R_PPC64_GOT_TPREL16_LO_DS:
15111 case R_PPC64_GOT_DTPREL16_DS:
15112 case R_PPC64_GOT_DTPREL16_LO_DS:
15113 case R_PPC64_TPREL16_DS:
15114 case R_PPC64_TPREL16_LO_DS:
15115 case R_PPC64_DTPREL16_DS:
15116 case R_PPC64_DTPREL16_LO_DS:
15117 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15118 mask = 3;
15119 /* If this reloc is against an lq, lxv, or stxv insn, then
15120 the value must be a multiple of 16. This is somewhat of
15121 a hack, but the "correct" way to do this by defining _DQ
15122 forms of all the _DS relocs bloats all reloc switches in
15123 this file. It doesn't make much sense to use these
15124 relocs in data, so testing the insn should be safe. */
15125 if ((insn & (0x3f << 26)) == (56u << 26)
15126 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15127 mask = 15;
15128 relocation += addend;
15129 addend = insn & (mask ^ 3);
15130 if ((relocation & mask) != 0)
15131 {
15132 relocation ^= relocation & mask;
15133 info->callbacks->einfo
15134 /* xgettext:c-format */
15135 (_("%P: %H: error: %s not a multiple of %u\n"),
15136 input_bfd, input_section, rel->r_offset,
15137 howto->name,
15138 mask + 1);
15139 bfd_set_error (bfd_error_bad_value);
15140 ret = FALSE;
15141 goto copy_reloc;
15142 }
15143 break;
15144 }
15145
15146 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15147 because such sections are not SEC_ALLOC and thus ld.so will
15148 not process them. */
15149 if (unresolved_reloc
15150 && !((input_section->flags & SEC_DEBUGGING) != 0
15151 && h->elf.def_dynamic)
15152 && _bfd_elf_section_offset (output_bfd, info, input_section,
15153 rel->r_offset) != (bfd_vma) -1)
15154 {
15155 info->callbacks->einfo
15156 /* xgettext:c-format */
15157 (_("%P: %H: unresolvable %s against `%T'\n"),
15158 input_bfd, input_section, rel->r_offset,
15159 howto->name,
15160 h->elf.root.root.string);
15161 ret = FALSE;
15162 }
15163
15164 /* 16-bit fields in insns mostly have signed values, but a
15165 few insns have 16-bit unsigned values. Really, we should
15166 have different reloc types. */
15167 if (howto->complain_on_overflow != complain_overflow_dont
15168 && howto->dst_mask == 0xffff
15169 && (input_section->flags & SEC_CODE) != 0)
15170 {
15171 enum complain_overflow complain = complain_overflow_signed;
15172
15173 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15174 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15175 complain = complain_overflow_bitfield;
15176 else if (howto->rightshift == 0
15177 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15178 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15179 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15180 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15181 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15182 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15183 complain = complain_overflow_unsigned;
15184 if (howto->complain_on_overflow != complain)
15185 {
15186 alt_howto = *howto;
15187 alt_howto.complain_on_overflow = complain;
15188 howto = &alt_howto;
15189 }
15190 }
15191
15192 if (r_type == R_PPC64_REL16DX_HA)
15193 {
15194 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15195 if (rel->r_offset + 4 > input_section->size)
15196 r = bfd_reloc_outofrange;
15197 else
15198 {
15199 relocation += addend;
15200 relocation -= (rel->r_offset
15201 + input_section->output_offset
15202 + input_section->output_section->vma);
15203 relocation = (bfd_signed_vma) relocation >> 16;
15204 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15205 insn &= ~0x1fffc1;
15206 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15207 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15208 r = bfd_reloc_ok;
15209 if (relocation + 0x8000 > 0xffff)
15210 r = bfd_reloc_overflow;
15211 }
15212 }
15213 else
15214 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15215 rel->r_offset, relocation, addend);
15216
15217 if (r != bfd_reloc_ok)
15218 {
15219 char *more_info = NULL;
15220 const char *reloc_name = howto->name;
15221
15222 if (reloc_dest != DEST_NORMAL)
15223 {
15224 more_info = bfd_malloc (strlen (reloc_name) + 8);
15225 if (more_info != NULL)
15226 {
15227 strcpy (more_info, reloc_name);
15228 strcat (more_info, (reloc_dest == DEST_OPD
15229 ? " (OPD)" : " (stub)"));
15230 reloc_name = more_info;
15231 }
15232 }
15233
15234 if (r == bfd_reloc_overflow)
15235 {
15236 /* On code like "if (foo) foo();" don't report overflow
15237 on a branch to zero when foo is undefined. */
15238 if (!warned
15239 && (reloc_dest == DEST_STUB
15240 || !(h != NULL
15241 && (h->elf.root.type == bfd_link_hash_undefweak
15242 || h->elf.root.type == bfd_link_hash_undefined)
15243 && is_branch_reloc (r_type))))
15244 info->callbacks->reloc_overflow (info, &h->elf.root,
15245 sym_name, reloc_name,
15246 orig_rel.r_addend,
15247 input_bfd, input_section,
15248 rel->r_offset);
15249 }
15250 else
15251 {
15252 info->callbacks->einfo
15253 /* xgettext:c-format */
15254 (_("%P: %H: %s against `%T': error %d\n"),
15255 input_bfd, input_section, rel->r_offset,
15256 reloc_name, sym_name, (int) r);
15257 ret = FALSE;
15258 }
15259 if (more_info != NULL)
15260 free (more_info);
15261 }
15262 copy_reloc:
15263 if (wrel != rel)
15264 *wrel = *rel;
15265 }
15266
15267 if (wrel != rel)
15268 {
15269 Elf_Internal_Shdr *rel_hdr;
15270 size_t deleted = rel - wrel;
15271
15272 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15273 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15274 if (rel_hdr->sh_size == 0)
15275 {
15276 /* It is too late to remove an empty reloc section. Leave
15277 one NONE reloc.
15278 ??? What is wrong with an empty section??? */
15279 rel_hdr->sh_size = rel_hdr->sh_entsize;
15280 deleted -= 1;
15281 }
15282 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15283 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15284 input_section->reloc_count -= deleted;
15285 }
15286
15287 /* If we're emitting relocations, then shortly after this function
15288 returns, reloc offsets and addends for this section will be
15289 adjusted. Worse, reloc symbol indices will be for the output
15290 file rather than the input. Save a copy of the relocs for
15291 opd_entry_value. */
15292 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15293 {
15294 bfd_size_type amt;
15295 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15296 rel = bfd_alloc (input_bfd, amt);
15297 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15298 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15299 if (rel == NULL)
15300 return FALSE;
15301 memcpy (rel, relocs, amt);
15302 }
15303 return ret;
15304 }
15305
15306 /* Adjust the value of any local symbols in opd sections. */
15307
15308 static int
15309 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15310 const char *name ATTRIBUTE_UNUSED,
15311 Elf_Internal_Sym *elfsym,
15312 asection *input_sec,
15313 struct elf_link_hash_entry *h)
15314 {
15315 struct _opd_sec_data *opd;
15316 long adjust;
15317 bfd_vma value;
15318
15319 if (h != NULL)
15320 return 1;
15321
15322 opd = get_opd_info (input_sec);
15323 if (opd == NULL || opd->adjust == NULL)
15324 return 1;
15325
15326 value = elfsym->st_value - input_sec->output_offset;
15327 if (!bfd_link_relocatable (info))
15328 value -= input_sec->output_section->vma;
15329
15330 adjust = opd->adjust[OPD_NDX (value)];
15331 if (adjust == -1)
15332 return 2;
15333
15334 elfsym->st_value += adjust;
15335 return 1;
15336 }
15337
15338 /* Finish up dynamic symbol handling. We set the contents of various
15339 dynamic sections here. */
15340
15341 static bfd_boolean
15342 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15343 struct bfd_link_info *info,
15344 struct elf_link_hash_entry *h,
15345 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15346 {
15347 struct ppc_link_hash_table *htab;
15348 struct plt_entry *ent;
15349 Elf_Internal_Rela rela;
15350 bfd_byte *loc;
15351
15352 htab = ppc_hash_table (info);
15353 if (htab == NULL)
15354 return FALSE;
15355
15356 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15357 if (ent->plt.offset != (bfd_vma) -1)
15358 {
15359 /* This symbol has an entry in the procedure linkage
15360 table. Set it up. */
15361 if (!htab->elf.dynamic_sections_created
15362 || h->dynindx == -1)
15363 {
15364 BFD_ASSERT (h->type == STT_GNU_IFUNC
15365 && h->def_regular
15366 && (h->root.type == bfd_link_hash_defined
15367 || h->root.type == bfd_link_hash_defweak));
15368 rela.r_offset = (htab->elf.iplt->output_section->vma
15369 + htab->elf.iplt->output_offset
15370 + ent->plt.offset);
15371 if (htab->opd_abi)
15372 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15373 else
15374 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15375 rela.r_addend = (h->root.u.def.value
15376 + h->root.u.def.section->output_offset
15377 + h->root.u.def.section->output_section->vma
15378 + ent->addend);
15379 loc = (htab->elf.irelplt->contents
15380 + (htab->elf.irelplt->reloc_count++
15381 * sizeof (Elf64_External_Rela)));
15382 }
15383 else
15384 {
15385 rela.r_offset = (htab->elf.splt->output_section->vma
15386 + htab->elf.splt->output_offset
15387 + ent->plt.offset);
15388 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15389 rela.r_addend = ent->addend;
15390 loc = (htab->elf.srelplt->contents
15391 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15392 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15393 }
15394 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15395
15396 if (!htab->opd_abi)
15397 {
15398 if (!h->def_regular)
15399 {
15400 /* Mark the symbol as undefined, rather than as
15401 defined in glink. Leave the value if there were
15402 any relocations where pointer equality matters
15403 (this is a clue for the dynamic linker, to make
15404 function pointer comparisons work between an
15405 application and shared library), otherwise set it
15406 to zero. */
15407 sym->st_shndx = SHN_UNDEF;
15408 if (!h->pointer_equality_needed)
15409 sym->st_value = 0;
15410 else if (!h->ref_regular_nonweak)
15411 {
15412 /* This breaks function pointer comparisons, but
15413 that is better than breaking tests for a NULL
15414 function pointer. */
15415 sym->st_value = 0;
15416 }
15417 }
15418 }
15419 }
15420
15421 if (h->needs_copy)
15422 {
15423 /* This symbol needs a copy reloc. Set it up. */
15424
15425 if (h->dynindx == -1
15426 || (h->root.type != bfd_link_hash_defined
15427 && h->root.type != bfd_link_hash_defweak)
15428 || htab->elf.srelbss == NULL)
15429 abort ();
15430
15431 rela.r_offset = (h->root.u.def.value
15432 + h->root.u.def.section->output_section->vma
15433 + h->root.u.def.section->output_offset);
15434 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15435 rela.r_addend = 0;
15436 loc = htab->elf.srelbss->contents;
15437 loc += htab->elf.srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
15438 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15439 }
15440
15441 return TRUE;
15442 }
15443
15444 /* Used to decide how to sort relocs in an optimal manner for the
15445 dynamic linker, before writing them out. */
15446
15447 static enum elf_reloc_type_class
15448 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15449 const asection *rel_sec,
15450 const Elf_Internal_Rela *rela)
15451 {
15452 enum elf_ppc64_reloc_type r_type;
15453 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15454
15455 if (rel_sec == htab->elf.irelplt)
15456 return reloc_class_ifunc;
15457
15458 r_type = ELF64_R_TYPE (rela->r_info);
15459 switch (r_type)
15460 {
15461 case R_PPC64_RELATIVE:
15462 return reloc_class_relative;
15463 case R_PPC64_JMP_SLOT:
15464 return reloc_class_plt;
15465 case R_PPC64_COPY:
15466 return reloc_class_copy;
15467 default:
15468 return reloc_class_normal;
15469 }
15470 }
15471
15472 /* Finish up the dynamic sections. */
15473
15474 static bfd_boolean
15475 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15476 struct bfd_link_info *info)
15477 {
15478 struct ppc_link_hash_table *htab;
15479 bfd *dynobj;
15480 asection *sdyn;
15481
15482 htab = ppc_hash_table (info);
15483 if (htab == NULL)
15484 return FALSE;
15485
15486 dynobj = htab->elf.dynobj;
15487 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15488
15489 if (htab->elf.dynamic_sections_created)
15490 {
15491 Elf64_External_Dyn *dyncon, *dynconend;
15492
15493 if (sdyn == NULL || htab->elf.sgot == NULL)
15494 abort ();
15495
15496 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15497 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15498 for (; dyncon < dynconend; dyncon++)
15499 {
15500 Elf_Internal_Dyn dyn;
15501 asection *s;
15502
15503 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15504
15505 switch (dyn.d_tag)
15506 {
15507 default:
15508 continue;
15509
15510 case DT_PPC64_GLINK:
15511 s = htab->glink;
15512 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15513 /* We stupidly defined DT_PPC64_GLINK to be the start
15514 of glink rather than the first entry point, which is
15515 what ld.so needs, and now have a bigger stub to
15516 support automatic multiple TOCs. */
15517 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15518 break;
15519
15520 case DT_PPC64_OPD:
15521 s = bfd_get_section_by_name (output_bfd, ".opd");
15522 if (s == NULL)
15523 continue;
15524 dyn.d_un.d_ptr = s->vma;
15525 break;
15526
15527 case DT_PPC64_OPT:
15528 if (htab->do_multi_toc && htab->multi_toc_needed)
15529 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15530 break;
15531
15532 case DT_PPC64_OPDSZ:
15533 s = bfd_get_section_by_name (output_bfd, ".opd");
15534 if (s == NULL)
15535 continue;
15536 dyn.d_un.d_val = s->size;
15537 break;
15538
15539 case DT_PLTGOT:
15540 s = htab->elf.splt;
15541 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15542 break;
15543
15544 case DT_JMPREL:
15545 s = htab->elf.srelplt;
15546 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15547 break;
15548
15549 case DT_PLTRELSZ:
15550 dyn.d_un.d_val = htab->elf.srelplt->size;
15551 break;
15552 }
15553
15554 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15555 }
15556 }
15557
15558 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15559 {
15560 /* Fill in the first entry in the global offset table.
15561 We use it to hold the link-time TOCbase. */
15562 bfd_put_64 (output_bfd,
15563 elf_gp (output_bfd) + TOC_BASE_OFF,
15564 htab->elf.sgot->contents);
15565
15566 /* Set .got entry size. */
15567 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15568 }
15569
15570 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15571 {
15572 /* Set .plt entry size. */
15573 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15574 = PLT_ENTRY_SIZE (htab);
15575 }
15576
15577 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15578 brlt ourselves if emitrelocations. */
15579 if (htab->brlt != NULL
15580 && htab->brlt->reloc_count != 0
15581 && !_bfd_elf_link_output_relocs (output_bfd,
15582 htab->brlt,
15583 elf_section_data (htab->brlt)->rela.hdr,
15584 elf_section_data (htab->brlt)->relocs,
15585 NULL))
15586 return FALSE;
15587
15588 if (htab->glink != NULL
15589 && htab->glink->reloc_count != 0
15590 && !_bfd_elf_link_output_relocs (output_bfd,
15591 htab->glink,
15592 elf_section_data (htab->glink)->rela.hdr,
15593 elf_section_data (htab->glink)->relocs,
15594 NULL))
15595 return FALSE;
15596
15597 if (htab->glink_eh_frame != NULL
15598 && htab->glink_eh_frame->size != 0)
15599 {
15600 bfd_vma val;
15601 bfd_byte *p;
15602 asection *stub_sec;
15603
15604 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15605 for (stub_sec = htab->params->stub_bfd->sections;
15606 stub_sec != NULL;
15607 stub_sec = stub_sec->next)
15608 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15609 {
15610 /* FDE length. */
15611 p += 4;
15612 /* CIE pointer. */
15613 p += 4;
15614 /* Offset to stub section. */
15615 val = (stub_sec->output_section->vma
15616 + stub_sec->output_offset);
15617 val -= (htab->glink_eh_frame->output_section->vma
15618 + htab->glink_eh_frame->output_offset
15619 + (p - htab->glink_eh_frame->contents));
15620 if (val + 0x80000000 > 0xffffffff)
15621 {
15622 info->callbacks->einfo
15623 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15624 stub_sec->name);
15625 return FALSE;
15626 }
15627 bfd_put_32 (dynobj, val, p);
15628 p += 4;
15629 /* stub section size. */
15630 p += 4;
15631 /* Augmentation. */
15632 p += 1;
15633 /* Pad. */
15634 p += 7;
15635 }
15636 if (htab->glink != NULL && htab->glink->size != 0)
15637 {
15638 /* FDE length. */
15639 p += 4;
15640 /* CIE pointer. */
15641 p += 4;
15642 /* Offset to .glink. */
15643 val = (htab->glink->output_section->vma
15644 + htab->glink->output_offset
15645 + 8);
15646 val -= (htab->glink_eh_frame->output_section->vma
15647 + htab->glink_eh_frame->output_offset
15648 + (p - htab->glink_eh_frame->contents));
15649 if (val + 0x80000000 > 0xffffffff)
15650 {
15651 info->callbacks->einfo
15652 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15653 htab->glink->name);
15654 return FALSE;
15655 }
15656 bfd_put_32 (dynobj, val, p);
15657 p += 4;
15658 /* .glink size. */
15659 p += 4;
15660 /* Augmentation. */
15661 p += 1;
15662 /* Ops. */
15663 p += 7;
15664 }
15665
15666 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15667 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15668 htab->glink_eh_frame,
15669 htab->glink_eh_frame->contents))
15670 return FALSE;
15671 }
15672
15673 /* We need to handle writing out multiple GOT sections ourselves,
15674 since we didn't add them to DYNOBJ. We know dynobj is the first
15675 bfd. */
15676 while ((dynobj = dynobj->link.next) != NULL)
15677 {
15678 asection *s;
15679
15680 if (!is_ppc64_elf (dynobj))
15681 continue;
15682
15683 s = ppc64_elf_tdata (dynobj)->got;
15684 if (s != NULL
15685 && s->size != 0
15686 && s->output_section != bfd_abs_section_ptr
15687 && !bfd_set_section_contents (output_bfd, s->output_section,
15688 s->contents, s->output_offset,
15689 s->size))
15690 return FALSE;
15691 s = ppc64_elf_tdata (dynobj)->relgot;
15692 if (s != NULL
15693 && s->size != 0
15694 && s->output_section != bfd_abs_section_ptr
15695 && !bfd_set_section_contents (output_bfd, s->output_section,
15696 s->contents, s->output_offset,
15697 s->size))
15698 return FALSE;
15699 }
15700
15701 return TRUE;
15702 }
15703
15704 #include "elf64-target.h"
15705
15706 /* FreeBSD support */
15707
15708 #undef TARGET_LITTLE_SYM
15709 #undef TARGET_LITTLE_NAME
15710
15711 #undef TARGET_BIG_SYM
15712 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15713 #undef TARGET_BIG_NAME
15714 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15715
15716 #undef ELF_OSABI
15717 #define ELF_OSABI ELFOSABI_FREEBSD
15718
15719 #undef elf64_bed
15720 #define elf64_bed elf64_powerpc_fbsd_bed
15721
15722 #include "elf64-target.h"
15723
GDB Binutils - Deliverables
This page took 0.548758 seconds and 4 git commands to generate.